@harperfast/agent 0.13.6-ink → 0.13.7-ink

package/dist/agent.js

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
 // agent.ts
-import "dotenv/config";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 
 // agent/AgentManager.ts
 import { Agent as Agent3 } from "@openai/agents";
@@ -47,11 +46,24 @@ async function onceListener(name) {
 function emitToListeners(name, value, trigger) {
   const listeners = listenersMap[name];
   if (listeners) {
-    for (const listener of listeners) {
+    const stableCopyOfListeners = listeners.slice();
+    for (const listener of stableCopyOfListeners) {
       listener(value, trigger);
     }
   }
 }
+function addListener(name, callback) {
+  if (!listenersMap[name]) {
+    listenersMap[name] = [];
+  }
+  listenersMap[name].push(callback);
+  return () => {
+    const index = listenersMap[name].indexOf(callback);
+    if (index >= 0) {
+      listenersMap[name].splice(index, 1);
+    }
+  };
+}
 function curryEmitToListeners(name, value, trigger) {
   return (e) => emitToListeners(name, value, trigger ?? e);
 }
@@ -68,7 +80,12 @@ var trackedState = {
   sessionPath: null,
   useFlexTier: false,
   maxTurns: 30,
-  maxCost: null
+  maxCost: null,
+  autoApproveCodeInterpreter: false,
+  autoApprovePatches: false,
+  autoApproveShell: false,
+  monitorRateLimits: true,
+  rateLimitThreshold: 80
 };
 
 // lifecycle/defaultInstructions.ts
@@ -498,7 +515,7 @@ async function execute10({ skill }) {
 
 // tools/files/workspaceEditor.ts
 import { applyDiff } from "@openai/agents";
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import { mkdir, rm, writeFile } from "fs/promises";
 import path3 from "path";
 
@@ -520,16 +537,53 @@ function normalizeDiff(diff) {
 import path2 from "path";
 
 // utils/files/aiignore.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 import path from "path";
+
+// utils/logger.ts
+import { appendFileSync, existsSync as existsSync3, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join as join4 } from "path";
+var ERROR_LOG_PATH = join4(homedir(), ".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 = dirname2(ERROR_LOG_PATH);
+    if (!existsSync3(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 = path.join(trackedState.cwd, ".aiignore");
-  if (existsSync3(ignorePath)) {
+  if (existsSync4(ignorePath)) {
     try {
       const content = readFileSync3(ignorePath, "utf8");
       ignorePatterns = content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((pattern) => pattern.endsWith("/") || pattern.endsWith("\\") ? pattern.slice(0, -1) : pattern);
     } catch (error) {
+      logError(error);
       console.error(`Error reading .aiignore: ${error}`);
       ignorePatterns = [];
     }
@@ -600,7 +654,7 @@ var WorkspaceEditor = class {
   async updateFile(operation) {
     try {
       const targetPath = resolvePath(this.root(), operation.path);
-      if (!existsSync4(targetPath)) {
+      if (!existsSync5(targetPath)) {
         return { status: "failed", output: "Error: file not found at path " + targetPath };
       }
       const original = readFileSync4(targetPath, "utf8");
@@ -615,7 +669,7 @@ var WorkspaceEditor = class {
   async deleteFile(operation) {
     try {
       const targetPath = resolvePath(this.root(), operation.path);
-      if (!existsSync4(targetPath)) {
+      if (!existsSync5(targetPath)) {
         return { status: "failed", output: "Error: file not found at path " + targetPath };
       }
       await rm(targetPath, { force: true });
@@ -683,7 +737,25 @@ async function needsApproval(runContext, operation, callId) {
       return false;
     }
     const autoApproved = getEnv("HARPER_AGENT_AUTO_APPROVE_PATCHES", "APPLY_PATCH_AUTO_APPROVE") === "1";
-    return !autoApproved;
+    if (autoApproved) {
+      if (callId) {
+        emitToListeners("RegisterToolInfo", {
+          type: operation.type,
+          path: operation.path,
+          diff: operation.diff,
+          callId
+        });
+      }
+      return false;
+    }
+    emitToListeners("OpenApprovalViewer", {
+      type: operation.type,
+      path: operation.path,
+      diff: operation.diff,
+      mode: "ask",
+      callId
+    });
+    return true;
   } catch (err) {
     console.error("apply_patch approval step failed:", err);
     return false;
@@ -694,6 +766,7 @@ async function execute11(operation) {
     const needed = await requiredSkillForOperation(operation.path, operation.type);
     if (needed) {
       const content = await execute10({ skill: needed });
+      console.error(`Understanding ${needed} is necessary before applying this patch.`);
       return { status: "failed, skill guarded", output: content };
     }
     switch (operation.type) {
@@ -923,12 +996,28 @@ var codeInterpreterTool = tool17({
   execute: execute14,
   needsApproval: needsApproval2
 });
-async function needsApproval2(runContext, { code, language }, callId) {
+async function needsApproval2(runContext, parameters, callId) {
   if (callId && runContext.isToolApproved({ toolName: "code_interpreter", callId })) {
     return false;
   }
   const autoApproved = getEnv("HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER", "CODE_INTERPRETER_AUTO_APPROVE") === "1";
-  return !autoApproved;
+  if (autoApproved) {
+    if (callId) {
+      emitToListeners("RegisterToolInfo", {
+        type: "code_interpreter",
+        code: parameters.code,
+        callId
+      });
+    }
+    return false;
+  }
+  emitToListeners("OpenApprovalViewer", {
+    type: "code_interpreter",
+    code: parameters.code,
+    mode: "ask",
+    callId
+  });
+  return true;
 }
 async function execute14({ code, language }) {
   const extension = language === "javascript" ? "js" : "py";
@@ -956,14 +1045,20 @@ import { tool as tool18 } from "@openai/agents";
 import { z as z18 } from "zod";
 
 // utils/files/updateEnv.ts
-import { existsSync as existsSync5 } from "fs";
-import { readFileSync as readFileSync5, writeFileSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname3, join as join5 } from "path";
 function updateEnv(key, value) {
   process.env[key] = value;
-  const envPath = join4(trackedState.cwd, ".env");
+  const topLevelEnvPath = join5(homedir2(), ".harper", "harper-agent-env");
+  const localEnvPath = join5(trackedState.cwd, ".env");
+  const envPath = existsSync6(topLevelEnvPath) || !existsSync6(localEnvPath) ? topLevelEnvPath : localEnvPath;
+  const dir = dirname3(envPath);
+  if (!existsSync6(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
   let envContent = "";
-  if (existsSync5(envPath)) {
+  if (existsSync6(envPath)) {
     envContent = readFileSync5(envPath, "utf8");
   }
   const regex = new RegExp(`^${key}=.*`, "m");
@@ -998,6 +1093,8 @@ var setInterpreterAutoApproveTool = tool18({
     }
     try {
       updateEnv("HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER", newValue);
+      trackedState.autoApproveCodeInterpreter = autoApprove;
+      emitToListeners("SettingsUpdated", void 0);
       return `HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER has been set to ${newValue} in .env and current process.`;
     } catch (error) {
       return `Error updating .env file: ${error.message}`;
@@ -1026,6 +1123,8 @@ var setPatchAutoApproveTool = tool19({
     }
     try {
       updateEnv("HARPER_AGENT_AUTO_APPROVE_PATCHES", newValue);
+      trackedState.autoApprovePatches = autoApprove;
+      emitToListeners("SettingsUpdated", void 0);
       return `HARPER_AGENT_AUTO_APPROVE_PATCHES has been set to ${newValue} in .env and current process.`;
     } catch (error) {
       return `Error updating .env file: ${error.message}`;
@@ -1054,6 +1153,8 @@ var setShellAutoApproveTool = tool20({
     }
     try {
       updateEnv("HARPER_AGENT_AUTO_APPROVE_SHELL", newValue);
+      trackedState.autoApproveShell = autoApprove;
+      emitToListeners("SettingsUpdated", void 0);
       return `HARPER_AGENT_AUTO_APPROVE_SHELL has been set to ${newValue} in .env and current process.`;
     } catch (error) {
       return `Error updating .env file: ${error.message}`;
@@ -1242,7 +1343,23 @@ TIMEOUT`;
     const foundRiskyCommand = commands.find((command) => isRiskyCommand(command));
     const foundIgnoredInteraction = commands.find((command) => mentionsIgnoredPath(command));
     const autoApproved = getEnv("HARPER_AGENT_AUTO_APPROVE_SHELL", "SHELL_AUTO_APPROVE") === "1" && !foundRiskyCommand && !foundIgnoredInteraction;
-    return !autoApproved;
+    if (autoApproved) {
+      if (callId) {
+        emitToListeners("RegisterToolInfo", {
+          type: "shell",
+          commands,
+          callId
+        });
+      }
+      return false;
+    }
+    emitToListeners("OpenApprovalViewer", {
+      type: "shell",
+      commands,
+      mode: "ask",
+      callId
+    });
+    return true;
   }
 });
 
@@ -1449,8 +1566,8 @@ import { z as z29 } from "zod";
 // utils/shell/harperProcess.ts
 import spawn from "cross-spawn";
 import { execSync } from "child_process";
-import { homedir } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
 var HarperProcess = class {
   childProcess = null;
   externalPid = null;
@@ -1486,7 +1603,7 @@ var HarperProcess = class {
     this.stopTailingLogs();
   }
   startTailingLogs() {
-    const logPath = join5(homedir(), "hdb", "log", "hdb.log");
+    const logPath = join6(homedir3(), "hdb", "log", "hdb.log");
     this.logTailProcess = spawn("tail", ["-f", logPath], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -1677,7 +1794,7 @@ var createNewHarperApplicationTool = tool30({
 import { tool as tool31 } from "@openai/agents";
 import { readFile as readFile2 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname4, join as join7 } from "path";
 import { z as z31 } from "zod";
 var ToolParameters18 = z31.object({
   schemaType: z31.enum(["app", "root"]).describe(
@@ -1691,8 +1808,8 @@ var getHarperConfigSchemaTool = tool31({
   async execute({ schemaType }) {
     try {
       return await readFile2(
-        join6(
-          dirname2(createRequire2(import.meta.url).resolve("harperdb")),
+        join7(
+          dirname4(createRequire2(import.meta.url).resolve("harperdb")),
           `config-${schemaType}.schema.json`
         ),
         "utf8"
@@ -1707,7 +1824,7 @@ var getHarperConfigSchemaTool = tool31({
 import { tool as tool32 } from "@openai/agents";
 import { readFile as readFile3 } from "fs/promises";
 import { createRequire as createRequire3 } from "module";
-import { dirname as dirname3, join as join7 } from "path";
+import { dirname as dirname5, join as join8 } from "path";
 import { z as z32 } from "zod";
 var ToolParameters19 = z32.object({
   resourceFile: z32.enum([
@@ -1727,8 +1844,8 @@ var getHarperResourceInterfaceTool = tool32({
   async execute({ resourceFile }) {
     try {
       return await readFile3(
-        join7(
-          dirname3(createRequire3(import.meta.url).resolve("harperdb")),
+        join8(
+          dirname5(createRequire3(import.meta.url).resolve("harperdb")),
           "resources",
           `${resourceFile}.d.ts`
         ),
@@ -1744,7 +1861,7 @@ var getHarperResourceInterfaceTool = tool32({
 import { tool as tool33 } from "@openai/agents";
 import { readFile as readFile4 } from "fs/promises";
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname4, join as join8 } from "path";
+import { dirname as dirname6, join as join9 } from "path";
 import { z as z33 } from "zod";
 var ToolParameters20 = z33.object({});
 var getHarperSchemaGraphQLTool = tool33({
@@ -1754,8 +1871,8 @@ var getHarperSchemaGraphQLTool = tool33({
   async execute() {
     try {
       return await readFile4(
-        join8(
-          dirname4(createRequire4(import.meta.url).resolve("harperdb")),
+        join9(
+          dirname6(createRequire4(import.meta.url).resolve("harperdb")),
           `schema.graphql`
         ),
         "utf8"
@@ -1842,7 +1959,7 @@ var readHarperLogsTool = tool35({
 
 // tools/harper/startHarperTool.ts
 import { tool as tool36 } from "@openai/agents";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { basename, resolve } from "path";
 import { z as z36 } from "zod";
 
@@ -1869,7 +1986,7 @@ var startHarperTool = tool36({
     try {
       let effectiveDirectory = directoryName;
       const candidatePath = resolve(process.cwd(), directoryName);
-      if (!existsSync6(candidatePath)) {
+      if (!existsSync7(candidatePath)) {
         const cwd = process.cwd();
         if (basename(cwd) === directoryName) {
           effectiveDirectory = cwd;
@@ -1907,6 +2024,110 @@ var stopHarperTool = tool37({
   }
 });
 
+// tools/plan/addPlanItemTool.ts
+import { tool as tool38 } from "@openai/agents";
+import { z as z38 } from "zod";
+
+// ink/contexts/globalPlanContext.ts
+var globalPlanContext = {
+  planDescription: "",
+  planItems: [],
+  progress: 0
+};
+
+// tools/plan/addPlanItemTool.ts
+var AddPlanItemParameters = z38.object({
+  text: z38.string().describe("The description of the task or milestone to add to the plan.")
+});
+var addPlanItemTool = tool38({
+  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}`;
+  }
+});
+
+// tools/plan/setPlanDescriptionTool.ts
+import { tool as tool39 } from "@openai/agents";
+import { z as z39 } from "zod";
+var SetPlanDescriptionParameters = z39.object({
+  description: z39.string().describe("A high-level description of the overall plan and goals.")
+});
+var setPlanDescriptionTool = tool39({
+  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}`;
+  }
+});
+
+// tools/plan/setPlanItemsTool.ts
+import { tool as tool40 } from "@openai/agents";
+import { z as z40 } from "zod";
+var SetPlanItemsParameters = z40.object({
+  items: z40.array(z40.string()).describe("An array of task descriptions to set as the plan items.")
+});
+var setPlanItemsTool = tool40({
+  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.`;
+  }
+});
+
+// tools/plan/updatePlanItemTool.ts
+import { tool as tool41 } from "@openai/agents";
+import { z as z41 } from "zod";
+var UpdatePlanItemParameters = z41.object({
+  id: z41.number().describe("The ID of the plan item to update."),
+  text: z41.string().describe("The new description of the task."),
+  status: z41.enum(["unchanged", "todo", "in-progress", "done", "not-needed"]).describe(
+    "The new status of the task."
+  )
+});
+var updatePlanItemTool = tool41({
+  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.`;
+    }
+    emitToListeners("SetPlanItems", newItems);
+    return `Updated plan item ${id}`;
+  }
+});
+
 // tools/factory.ts
 function createTools() {
   return [
@@ -1919,6 +2140,7 @@ function createTools() {
     browserNavigateTool,
     browserScreenshotTool,
     browserTypeTool,
+    addPlanItemTool,
     changeCwdTool,
     checkHarperStatusTool,
     codeInterpreterTool,
@@ -1943,10 +2165,13 @@ function createTools() {
     readHarperLogsTool,
     setInterpreterAutoApproveTool,
     setPatchAutoApproveTool,
+    setPlanDescriptionTool,
+    setPlanItemsTool,
     setShellAutoApproveTool,
     shellTool,
     startHarperTool,
-    stopHarperTool
+    stopHarperTool,
+    updatePlanItemTool
   ];
 }
 
@@ -2037,9 +2262,9 @@ Stack: ${String(err.stack).split("\n").slice(0, 8).join("\n")}` : "";
 
 // utils/sessions/DiskSession.ts
 import { MemorySession } from "@openai/agents";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { mkdir as mkdir2, readFile as readFile5, rename, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname5 } from "path";
+import { dirname as dirname7 } from "path";
 var DiskSession = class extends MemorySession {
   filePath;
   ready;
@@ -2074,7 +2299,7 @@ var DiskSession = class extends MemorySession {
     }
   }
   async loadStorage() {
-    if (existsSync7(this.filePath)) {
+    if (existsSync8(this.filePath)) {
       try {
         const data = await readFile5(this.filePath, "utf-8");
         const parsed = JSON.parse(data);
@@ -2090,8 +2315,8 @@ var DiskSession = class extends MemorySession {
   async updateStorage(update) {
     const storage = await this.loadStorage();
     update(storage);
-    const dir = dirname5(this.filePath);
-    if (!existsSync7(dir)) {
+    const dir = dirname7(this.filePath);
+    if (!existsSync8(dir)) {
       await mkdir2(dir, { recursive: true });
     }
     const data = JSON.stringify(storage, null, 2);
@@ -2389,7 +2614,7 @@ function createSession(sessionPath = null) {
 }
 
 // agent/runAgentForOnePass.ts
-import { run as run2 } from "@openai/agents";
+import { run as run2, system as system2 } from "@openai/agents";
 
 // ink/contexts/ActionsContext.tsx
 import { createContext as createContext2, useContext as useContext2, useEffect as useEffect2, useMemo as useMemo2, useState as useState2 } from "react";
@@ -2547,6 +2772,9 @@ var CostTracker = class {
     );
     return this.getTotalCost() + turnCost + compactionCost;
   }
+  extractCachedTokens(inputTokenDetails) {
+    return extractCachedTokens(inputTokenDetails);
+  }
   recordTurn(model, usage, compactionModel) {
     const { turnCost, compactionCost, unknownPrices } = this.calculateUsageCosts(model, usage, compactionModel);
     this.totalInputTokens += usage.inputTokens;
@@ -2614,6 +2842,64 @@ var CostTracker = class {
 };
 var costTracker = new CostTracker();
 
+// utils/sessions/rateLimits.ts
+var RateLimitTracker = class {
+  status = {
+    limitRequests: null,
+    limitTokens: null,
+    remainingRequests: null,
+    remainingTokens: null,
+    resetRequests: null,
+    resetTokens: null
+  };
+  updateFromHeaders(headers) {
+    const getHeader = (name) => {
+      const value = headers[name] || headers[name.toLowerCase()];
+      return Array.isArray(value) ? value[0] : value;
+    };
+    const limitRequests = getHeader("x-ratelimit-limit-requests");
+    const limitTokens = getHeader("x-ratelimit-limit-tokens");
+    const remainingRequests = getHeader("x-ratelimit-remaining-requests");
+    const remainingTokens = getHeader("x-ratelimit-remaining-tokens");
+    const resetRequests = getHeader("x-ratelimit-reset-requests");
+    const resetTokens = getHeader("x-ratelimit-reset-tokens");
+    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;
+    }
+  }
+  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 };
+  }
+};
+var rateLimitTracker = new RateLimitTracker();
+
 // utils/strings/isTrue.ts
 function isTrue(v) {
   if (v === void 0) {
@@ -2625,6 +2911,7 @@ function isTrue(v) {
 
 // agent/showErrorToUser.ts
 function showErrorToUser(error, lastToolCallInfo) {
+  logError(error);
   const err = error ?? {};
   const name = err.name || "Error";
   const message = err.message || String(err);
@@ -2663,15 +2950,106 @@ Last tool call: ${lastToolCallInfo}` : "";
 // agent/runAgentForOnePass.ts
 async function runAgentForOnePass(agent, session, input, controller) {
   let lastToolCallInfo = null;
+  const toolInfoMap = /* @__PURE__ */ new Map();
+  const removeToolListener = addListener("RegisterToolInfo", (info) => {
+    toolInfoMap.set(info.callId, info);
+  });
   try {
     let hasStartedResponse = false;
-    const stream = await run2(agent, input, {
+    let adjustedInput = input;
+    const noPlanYet = globalPlanContext.planItems.length === 0 && (!globalPlanContext.planDescription || globalPlanContext.planDescription.trim().length === 0);
+    if (noPlanYet && (typeof input === "string" || Array.isArray(input))) {
+      const planningInstruction = [
+        "If there is no current plan, first establish one and keep it updated:",
+        "- Use the tools to manage the plan:",
+        "  \u2022 set_plan_description(description)",
+        "  \u2022 set_plan_items(items: string[])",
+        "  \u2022 add_plan_item(text)",
+        "  \u2022 update_plan_item(id, text, status: 'todo' | 'in-progress' | 'done' | 'not-needed' | 'unchanged')",
+        "- After setting the plan, as you progress, mark items as in-progress, done, or not-needed.",
+        "- Keep the plan concise and actionable. Update statuses as you move forward."
+      ].join("\n");
+      if (typeof input === "string") {
+        adjustedInput = [
+          system2(planningInstruction),
+          { type: "message", role: "user", content: input }
+        ];
+      } else {
+        adjustedInput = [system2(planningInstruction), ...input];
+      }
+    }
+    const stream = await run2(agent, adjustedInput, {
       session,
       stream: true,
       signal: controller.signal,
       maxTurns: trackedState.maxTurns
     });
     for await (const event of stream) {
+      if (trackedState.monitorRateLimits) {
+        const { requests, tokens } = rateLimitTracker.isApproachingLimit(trackedState.rateLimitThreshold);
+        const veryCloseThreshold = Math.min(99, trackedState.rateLimitThreshold + 15);
+        const veryClose = rateLimitTracker.isApproachingLimit(veryCloseThreshold);
+        if (veryClose.requests || veryClose.tokens) {
+          emitToListeners("SetInputMode", "approving");
+          emitToListeners("PushNewMessages", [{
+            type: "agent",
+            text: "Rate limit nearly exhausted. Approve to continue or wait for reset.",
+            version: 1
+          }]);
+          const approval = await new Promise((resolve2) => {
+            const removeApprove = addListener("ApproveCurrentApproval", () => {
+              removeApprove();
+              removeDeny();
+              resolve2("approved");
+            });
+            const removeDeny = addListener("DenyCurrentApproval", () => {
+              removeApprove();
+              removeDeny();
+              resolve2("denied");
+            });
+          });
+          if (approval === "denied") {
+            emitToListeners("SetInputMode", "denied");
+            emitToListeners("PushNewMessages", [{
+              type: "agent",
+              text: "Operation canceled due to rate limits.",
+              version: 1
+            }]);
+            if (controller) {
+              controller.abort();
+            }
+            process.exitCode = 1;
+            await handleExit();
+          }
+        } else if (requests || tokens) {
+          emitToListeners("PushNewMessages", [{ type: "agent", text: "Throttling to avoid rate limits\u2026", version: 1 }]);
+          const status = rateLimitTracker.getStatus();
+          let backoffMs = 1500;
+          const parseReset = (s) => {
+            if (!s) {
+              return null;
+            }
+            const ms = /([0-9]+)ms/.exec(s)?.[1];
+            if (ms) {
+              return parseInt(ms, 10);
+            }
+            const sec = /([0-9]+)s/.exec(s)?.[1];
+            if (sec) {
+              return parseInt(sec, 10) * 1e3;
+            }
+            const min = /([0-9]+)m/.exec(s)?.[1];
+            if (min) {
+              return parseInt(min, 10) * 6e4;
+            }
+            return null;
+          };
+          const resets = [parseReset(status.resetRequests || void 0), parseReset(status.resetTokens || void 0)].filter(Boolean);
+          if (resets.length > 0) {
+            backoffMs = Math.max(backoffMs, Math.min(...resets));
+          }
+          await sleep(backoffMs);
+        }
+      }
       switch (event.type) {
         case "raw_model_stream_event":
           const data = event.data;
@@ -2698,6 +3076,19 @@ async function runAgentForOnePass(agent, session, input, controller) {
               emitToListeners("SetInputMode", "waiting");
               break;
           }
+          const currentEstimatedCost = costTracker.getEstimatedTotalCost(
+            stream.state.usage,
+            trackedState.model,
+            trackedState.compactionModel
+          );
+          const sessionStats2 = costTracker.getSessionStats();
+          emitToListeners("UpdateCost", {
+            totalCost: currentEstimatedCost,
+            inputTokens: sessionStats2.inputTokens + stream.state.usage.inputTokens,
+            outputTokens: sessionStats2.outputTokens + stream.state.usage.outputTokens,
+            cachedInputTokens: sessionStats2.cachedInputTokens + costTracker.extractCachedTokens(stream.state.usage.inputTokensDetails),
+            hasUnknownPrices: sessionStats2.hasUnknownPrices
+          });
           break;
         case "run_item_stream_event":
           if (event.name === "tool_called") {
@@ -2711,17 +3102,20 @@ async function runAgentForOnePass(agent, session, input, controller) {
               args = JSON.stringify(item.operation);
             }
             const displayedArgs = args ? `(${args})` : "()";
+            const callId = item.callId || item.id;
             emitToListeners("PushNewMessages", [{
               type: "tool",
               text: name,
               args: displayedArgs,
-              version: 1
+              version: 1,
+              callId
             }]);
             emitToListeners("AddActionItem", {
               kind: name === "apply_patch" || item.type === "apply_patch_call" ? "apply_patch" : name === "create_new_harper_application" ? "create_app" : "tool",
               title: name,
               detail: displayedArgs,
-              running: false
+              running: false,
+              callId
             });
             lastToolCallInfo = `${name}${displayedArgs}`;
           }
@@ -2755,31 +3149,59 @@ async function runAgentForOnePass(agent, session, input, controller) {
       trackedState.model,
       trackedState.compactionModel
     );
+    const sessionStats = costTracker.getSessionStats();
     emitToListeners("UpdateCost", {
-      ...costTracker.getSessionStats(),
-      totalCost: estimatedTotalCost
+      totalCost: estimatedTotalCost,
+      inputTokens: sessionStats.inputTokens + stream.state.usage.inputTokens,
+      outputTokens: sessionStats.outputTokens + stream.state.usage.outputTokens,
+      cachedInputTokens: sessionStats.cachedInputTokens + costTracker.extractCachedTokens(stream.state.usage.inputTokensDetails),
+      hasUnknownPrices: sessionStats.hasUnknownPrices
     });
     if (stream.interruptions?.length) {
       emitToListeners("SetThinking", false);
       emitToListeners("SetInputMode", "approving");
       for (const interruption of stream.interruptions) {
+        const callId = interruption.callId || interruption.id;
+        const toolName = interruption.toolName;
+        const isModalTool = toolName === "apply_patch" || toolName === "code_interpreter" || toolName === "shell";
         const myApprovalId = actionId;
         emitToListeners("AddActionItem", {
           id: myApprovalId,
-          kind: "approval",
-          title: "approval",
+          kind: isModalTool ? toolName === "apply_patch" ? "apply_patch" : "approval" : "approval",
+          title: isModalTool ? toolName : "approval",
           detail: lastToolCallInfo ?? "awaiting approval",
-          running: true
+          running: true,
+          callId
         });
-        const newMessages = await onceListener("PushNewMessages");
-        let approved = false;
-        for (const newMessage of newMessages) {
-          if (newMessage.type === "user" && isTrue(newMessage.text)) {
-            approved = true;
-          }
-          newMessage.handled = true;
+        const approvalPromise = new Promise((resolve2) => {
+          const removeApprove = addListener("ApproveCurrentApproval", () => {
+            removeApprove();
+            removeDeny();
+            resolve2("approved");
+          });
+          const removeDeny = addListener("DenyCurrentApproval", () => {
+            removeApprove();
+            removeDeny();
+            resolve2("denied");
+          });
+        });
+        let result;
+        if (isModalTool) {
+          result = await approvalPromise;
+        } else {
+          const textInputPromise = onceListener("PushNewMessages").then((messages) => {
+            let approved = false;
+            for (const newMessage of messages) {
+              if (newMessage.type === "user" && isTrue(newMessage.text)) {
+                approved = true;
+              }
+              newMessage.handled = true;
+            }
+            return approved ? "approved" : "denied";
+          });
+          result = await Promise.race([approvalPromise, textInputPromise]);
         }
-        if (approved) {
+        if (result === "approved") {
           emitToListeners("SetInputMode", "approved");
           emitToListeners("UpdateActionItem", {
             id: myApprovalId,
@@ -2798,9 +3220,11 @@ async function runAgentForOnePass(agent, session, input, controller) {
           });
           stream.state.reject(interruption);
         }
+        emitToListeners("CloseApprovalViewer", void 0);
       }
       emitToListeners("SetThinking", true);
       setTimeout(curryEmitToListeners("SetInputMode", "waiting"), 1e3);
+      removeToolListener();
       return stream.state;
     } else {
       costTracker.recordTurn(
@@ -2810,6 +3234,7 @@ async function runAgentForOnePass(agent, session, input, controller) {
       );
       emitToListeners("UpdateCost", costTracker.getSessionStats());
     }
+    removeToolListener();
     return null;
   } catch (error) {
     showErrorToUser(error, lastToolCallInfo);
@@ -2931,8 +3356,8 @@ import "react";
 
 // ink/components/ChatContent.tsx
 import { Spinner as Spinner2 } from "@inkjs/ui";
-import { Box as Box10, Text as Text10, useInput as useInput3 } from "ink";
-import React11, { useCallback as useCallback4, useEffect as useEffect7, useMemo as useMemo10, useRef as useRef2, useState as useState11 } from "react";
+import { Box as Box10, Text as Text10, useInput as useInput4 } from "ink";
+import React11, { useCallback as useCallback4, useEffect as useEffect8, useMemo as useMemo10, useRef as useRef2, useState as useState13 } from "react";
 
 // ink/contexts/ChatContext.tsx
 import { createContext as createContext3, useContext as useContext3, useMemo as useMemo3, useState as useState3 } from "react";
@@ -3496,6 +3921,19 @@ function ActionsView({ height, isFocused }) {
     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 = useCallback2((count) => /* @__PURE__ */ jsxs3(Box3, { children: [
     /* @__PURE__ */ jsx6(Text3, { color: "gray", dimColor: true, children: "\u2502" }),
@@ -3650,15 +4088,6 @@ import "react";
 
 // ink/contexts/PlanContext.tsx
 import { createContext as createContext5, useContext as useContext5, useMemo as useMemo6, useState as useState8 } from "react";
-
-// ink/contexts/globalPlanContext.ts
-var globalPlanContext = {
-  planDescription: "",
-  planItems: [],
-  progress: 0
-};
-
-// ink/contexts/PlanContext.tsx
 import { jsx as jsx10 } from "react/jsx-runtime";
 var PlanContext = createContext5(globalPlanContext);
 var usePlan = () => {
@@ -3671,26 +4100,26 @@ var usePlan = () => {
 var PlanProvider = ({
   children
 }) => {
-  const [goal, setGoal] = useState8(globalPlanContext.planDescription);
-  const [progress, setProgress] = useState8(globalPlanContext.progress);
+  const [planDescription, setPlanDescription] = useState8(globalPlanContext.planDescription);
   const [planItems, setPlanItems] = useState8(globalPlanContext.planItems);
+  const [progress, setProgress] = useState8(globalPlanContext.progress);
+  useListener("SetPlanDescription", (newGoal) => {
+    globalPlanContext.planDescription = newGoal;
+    setPlanDescription(newGoal);
+  }, []);
   useListener("SetPlanItems", (planItems2) => {
     globalPlanContext.planItems = planItems2;
-    const completedCount = planItems2.filter((item) => item.completed).length;
+    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);
   }, []);
-  useListener("SetGoal", (newGoal) => {
-    globalPlanContext.planDescription = newGoal;
-    setGoal(newGoal);
-  }, []);
   const value = useMemo6(() => ({
     progress,
-    goal,
+    planDescription,
     planItems
-  }), [progress, goal, planItems]);
+  }), [progress, planDescription, planItems]);
   return /* @__PURE__ */ jsx10(PlanContext.Provider, { value, children });
 };
 
@@ -3700,10 +4129,17 @@ 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.completed ? "green" : "white", children: [
-      planItem.completed ? " \u25CF " : " \u25CB ",
-      planItem.text
-    ] }) }, planItem.id)) }),
+    /* @__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: ",
@@ -3716,12 +4152,12 @@ function PlanView() {
 }
 
 // ink/components/SettingsView.tsx
-import { Box as Box7, Text as Text7 } from "ink";
+import { Box as Box7, Text as Text7, useInput as useInput2 } from "ink";
 import path7 from "path";
-import { useMemo as useMemo8 } from "react";
+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 } from "react";
+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 = () => {
@@ -3734,22 +4170,128 @@ var useSettings = () => {
 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,
     maxTurns: trackedState.maxTurns,
-    maxCost: trackedState.maxCost
-  }), []);
+    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, maxTurns, maxCost } = useSettings();
+  const {
+    model,
+    compactionModel,
+    sessionPath,
+    cwd,
+    useFlexTier,
+    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;
@@ -3783,24 +4325,67 @@ function SettingsView({ isDense = false }) {
       /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "Max Turns:" }) }),
       /* @__PURE__ */ jsx13(Text7, { children: maxTurns })
     ] }),
+    /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
+      /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "Rate Limit Threshold:" }) }),
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        initialRateLimitThreshold,
+        "%"
+      ] })
+    ] }),
+    rateLimitStatus && rateLimitStatus.limitRequests !== null && /* @__PURE__ */ jsxs7(Box7, { marginBottom, flexDirection: "column", children: [
+      /* @__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,
+          ")"
+        ] })
+      ] }),
+      /* @__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 { useCallback as useCallback3, useState as useState10 } from "react";
+import { useCallback as useCallback3, useState as useState12 } from "react";
 
 // ink/components/BlinkingTextInput.tsx
 import chalk3 from "chalk";
-import { Box as Box8, Text as Text8, useInput as useInput2 } from "ink";
-import { useEffect as useEffect6, useMemo as useMemo9, useReducer, useState as useState9 } from "react";
+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) {
@@ -3854,8 +4439,8 @@ function BlinkingTextInput({
     previousValue: defaultValue,
     cursorOffset: defaultValue.length
   });
-  const [isCursorVisible, setIsCursorVisible] = useState9(true);
-  useEffect6(() => {
+  const [isCursorVisible, setIsCursorVisible] = useState11(true);
+  useEffect7(() => {
     if (isDisabled) {
       setIsCursorVisible(false);
       return;
@@ -3865,7 +4450,7 @@ function BlinkingTextInput({
     }, 500);
     return () => clearInterval(interval);
   }, [isDisabled]);
-  useEffect6(() => {
+  useEffect7(() => {
     if (state.value !== state.previousValue) {
       onChange?.(state.value);
     }
@@ -3876,7 +4461,7 @@ function BlinkingTextInput({
     }
     return suggestions.find((s) => s.startsWith(state.value))?.slice(state.value.length) || "";
   }, [state.value, suggestions]);
-  useInput2(
+  useInput3(
     (input, key) => {
       if (key.upArrow || key.downArrow || key.ctrl && input === "c" || key.tab || key.shift && key.tab) {
         return;
@@ -3965,8 +4550,11 @@ var modeSuggestion = {
 };
 function UserInput() {
   const { userInputMode, focusedArea } = useChat();
-  const [resetKey, setResetKey] = useState10(0);
-  const [, setBlankLines] = useState10(0);
+  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 = useCallback3((value) => {
@@ -4030,12 +4618,12 @@ function ChatContent() {
   const { messages, isThinking, focusedArea, setFocusedArea } = useChat();
   const size = useTerminalSize();
   useMessageListener();
-  const [activeTab, setActiveTab] = useState11("settings");
-  const [selectedIndex, setSelectedIndex] = useState11(0);
+  const [activeTab, setActiveTab] = useState13("settings");
+  const [selectedIndex, setSelectedIndex] = useState13(0);
   const wrapCache = useRef2(
     /* @__PURE__ */ new Map()
   );
-  useInput3((input, key) => {
+  useInput4((input, key) => {
     if (key.tab) {
       const focusOrder = ["input", "timeline", "status"];
       const currentIndex = focusOrder.indexOf(focusedArea);
@@ -4055,6 +4643,19 @@ function ChatContent() {
       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) {
@@ -4161,12 +4762,12 @@ function ChatContent() {
     }
     return acc;
   }, [messages, availableTextWidth, labelWidthFor]);
-  useEffect7(() => {
+  useEffect8(() => {
     if (lineItems.length > 0 && focusedArea !== "timeline") {
       setSelectedIndex(lineItems.length - 1);
     }
   }, [lineItems.length, focusedArea]);
-  useEffect7(() => {
+  useEffect8(() => {
     if (lineItems.length > 0) {
       setSelectedIndex(lineItems.length - 1);
     }
@@ -4311,10 +4912,246 @@ function ChatContent() {
   ] });
 }
 
+// ink/components/DiffApprovalView.tsx
+import { Box as Box11, Text as Text11, useInput as useInput5 } from "ink";
+import { useMemo as useMemo12, useState as useState15 } from "react";
+
+// ink/contexts/ApprovalContext.tsx
+import { createContext as createContext7, useCallback as useCallback5, useContext as useContext7, useMemo as useMemo11, useState as useState14 } from "react";
+import { jsx as jsx17 } from "react/jsx-runtime";
+var ApprovalContext = createContext7(void 0);
+var useApproval = () => {
+  const context = useContext7(ApprovalContext);
+  if (!context) {
+    throw new Error("useApproval must be used within an ApprovalProvider");
+  }
+  return context;
+};
+var ApprovalProvider = ({ children }) => {
+  const [payload, setPayload] = useState14(null);
+  const [toolInfos] = useState14(/* @__PURE__ */ new Map());
+  const registerToolInfo = useCallback5(
+    (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("RegisterToolInfo", (info) => {
+    registerToolInfo(info);
+  }, [registerToolInfo]);
+  useListener("CloseApprovalViewer", () => {
+    setPayload(null);
+  }, []);
+  const value = useMemo11(() => ({
+    payload,
+    setPayload,
+    registerToolInfo
+  }), [payload, registerToolInfo]);
+  return /* @__PURE__ */ jsx17(ApprovalContext.Provider, { value, children });
+};
+
+// ink/components/DiffApprovalView.tsx
+import { Fragment as Fragment2, jsx as jsx18, jsxs as jsxs10 } from "react/jsx-runtime";
+function DiffApprovalView() {
+  const { payload } = useApproval();
+  const size = useTerminalSize();
+  const [scrollIndex, setScrollIndex] = useState15(0);
+  const diffLines = useMemo12(() => {
+    if (!payload?.diff) {
+      return [];
+    }
+    return payload.diff.split("\n");
+  }, [payload?.diff]);
+  const wrappedLines = useMemo12(() => {
+    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 === "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__ */ jsx18(Text11, { color: "gray", children: "\u2502" }),
+              payload.path && /* @__PURE__ */ jsxs10(Fragment2, { children: [
+                /* @__PURE__ */ jsxs10(Text11, { bold: true, children: [
+                  payload.type,
+                  ":"
+                ] }),
+                /* @__PURE__ */ jsx18(Text11, { children: payload.path })
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx18(Box11, { flexGrow: 1, flexDirection: "column", paddingX: 1, children: wrappedLines.length === 0 ? /* @__PURE__ */ jsx18(Text11, { italic: true, color: "gray", children: "No diff content." }) : wrappedLines.slice(scrollIndex, scrollIndex + visibleHeight).map((line, i) => /* @__PURE__ */ jsx18(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__ */ jsx18(Text11, { color: canRespond ? "green" : "gray", children: "[Enter/y] Approve" }),
+                /* @__PURE__ */ jsx18(Text11, {}),
+                /* @__PURE__ */ jsx18(Text11, { color: canRespond ? "red" : "gray", children: "[Esc/n] Deny" }),
+                !canRespond && /* @__PURE__ */ jsx18(Text11, { color: "yellow", children: "(Wait 1s...)" })
+              ] }) : /* @__PURE__ */ jsx18(Box11, { flexGrow: 1, children: /* @__PURE__ */ jsx18(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 Box16, useInput as useInput7 } from "ink";
+import { Box as Box18, useInput as useInput10 } from "ink";
 import { Step, Stepper } from "ink-stepper";
-import { useState as useState13 } from "react";
+import { useState as useState17 } from "react";
 
 // utils/files/getEnvVarForProvider.ts
 function getEnvVarForProvider(provider) {
@@ -4338,17 +5175,17 @@ function updateEnvKeyForProvider(provider, key) {
 
 // ink/configurationWizard/ApiKeyStep.tsx
 import { PasswordInput } from "@inkjs/ui";
-import { Box as Box11, Text as Text11, useInput as useInput4 } from "ink";
+import { Box as Box12, Text as Text12, useInput as useInput6 } from "ink";
 import { useStepperInput } from "ink-stepper";
-import { useEffect as useEffect8 } from "react";
-import { jsx as jsx17, jsxs as jsxs10 } from "react/jsx-runtime";
+import { useEffect as useEffect9 } from "react";
+import { jsx as jsx19, jsxs as jsxs11 } from "react/jsx-runtime";
 function ApiKeyStep({ provider, onConfirm, onBack }) {
   const { disableNavigation, enableNavigation } = useStepperInput();
-  useEffect8(() => {
+  useEffect9(() => {
     disableNavigation();
     return () => enableNavigation();
   }, [disableNavigation, enableNavigation]);
-  useInput4((input, key) => {
+  useInput6((input, key) => {
     if (key.escape) {
       onBack();
     }
@@ -4359,14 +5196,14 @@ function ApiKeyStep({ provider, onConfirm, onBack }) {
     Google: "Get your key at: https://aistudio.google.com/app/apikey",
     Ollama: ""
   };
-  return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs10(Text11, { children: [
+  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs11(Text12, { children: [
       "Can you provide us with your ",
       provider,
       " API key?"
     ] }),
-    /* @__PURE__ */ jsx17(Text11, { dimColor: true, children: instructions[provider] }),
-    /* @__PURE__ */ jsx17(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx17(
+    /* @__PURE__ */ jsx19(Text12, { dimColor: true, children: instructions[provider] }),
+    /* @__PURE__ */ jsx19(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx19(
       PasswordInput,
       {
         onSubmit: (v) => {
@@ -4378,22 +5215,22 @@ function ApiKeyStep({ provider, onConfirm, onBack }) {
         }
       }
     ) }),
-    /* @__PURE__ */ jsx17(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx17(Text11, { dimColor: true, children: "Press ESC to go back" }) })
+    /* @__PURE__ */ jsx19(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx19(Text12, { dimColor: true, children: "Press ESC to go back" }) })
   ] });
 }
 
 // ink/configurationWizard/ApiUrlStep.tsx
-import { Box as Box12, Text as Text12, useInput as useInput5 } from "ink";
+import { Box as Box13, Text as Text13, useInput as useInput7 } from "ink";
 import { useStepperInput as useStepperInput2 } from "ink-stepper";
-import { useEffect as useEffect9 } from "react";
-import { jsx as jsx18, jsxs as jsxs11 } from "react/jsx-runtime";
+import { useEffect as useEffect10 } from "react";
+import { jsx as jsx20, jsxs as jsxs12 } from "react/jsx-runtime";
 function ApiUrlStep({ provider, onConfirm, onBack }) {
   const { disableNavigation, enableNavigation } = useStepperInput2();
-  useEffect9(() => {
+  useEffect10(() => {
     disableNavigation();
     return () => enableNavigation();
   }, [disableNavigation, enableNavigation]);
-  useInput5((input, key) => {
+  useInput7((input, key) => {
     if (key.escape) {
       onBack();
     }
@@ -4404,13 +5241,13 @@ function ApiUrlStep({ provider, onConfirm, onBack }) {
     Google: "",
     Ollama: "http://localhost:11434/api"
   };
-  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs11(Text12, { children: [
+  return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs12(Text13, { children: [
       "Where are you hosting ",
       provider,
       "?"
     ] }),
-    /* @__PURE__ */ jsx18(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx18(
+    /* @__PURE__ */ jsx20(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx20(
       BlinkingTextInput,
       {
         placeholder: defaultApi[provider] || "",
@@ -4423,7 +5260,84 @@ function ApiUrlStep({ provider, onConfirm, onBack }) {
         }
       }
     ) }),
-    /* @__PURE__ */ jsx18(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx18(Text12, { dimColor: true, children: "Press ESC to go back" }) })
+    /* @__PURE__ */ jsx20(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx20(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 jsx21, 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__ */ jsx21(Text14, { children: "Additional Settings (all enabled by default):" }),
+    /* @__PURE__ */ jsx21(
+      MultiSelect,
+      {
+        options,
+        defaultValue: defaultValues,
+        onSubmit: handleSubmit
+      }
+    ),
+    /* @__PURE__ */ jsxs13(Text14, { color: "gray", children: [
+      "Press ",
+      "<space>",
+      " to toggle, ",
+      "<enter>",
+      " to confirm."
+    ] })
   ] });
 }
 
@@ -4443,23 +5357,23 @@ var compactorModelsByProvider = {
 
 // ink/configurationWizard/ModelSelectionStep.tsx
 import { Select } from "@inkjs/ui";
-import { Box as Box13, Text as Text13, useInput as useInput6 } from "ink";
-import { useStepperInput as useStepperInput3 } from "ink-stepper";
-import { useEffect as useEffect10, useState as useState12 } from "react";
-import { jsx as jsx19, jsxs as jsxs12 } from "react/jsx-runtime";
+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 useState16 } from "react";
+import { jsx as jsx22, jsxs as jsxs14 } from "react/jsx-runtime";
 function ModelSelectionStep({
   title,
   models,
   onConfirm,
   onBack
 }) {
-  const { disableNavigation, enableNavigation } = useStepperInput3();
-  const [isCustom, setIsCustom] = useState12(false);
-  useEffect10(() => {
+  const { disableNavigation, enableNavigation } = useStepperInput4();
+  const [isCustom, setIsCustom] = useState16(false);
+  useEffect12(() => {
     disableNavigation();
     return () => enableNavigation();
   }, [isCustom, disableNavigation, enableNavigation]);
-  useInput6((input, key) => {
+  useInput9((input, key) => {
     if (key.escape) {
       if (isCustom) {
         setIsCustom(false);
@@ -4469,12 +5383,12 @@ function ModelSelectionStep({
     }
   });
   if (isCustom) {
-    return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs12(Text13, { children: [
+    return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs14(Text15, { children: [
         "Enter custom model name for: ",
         title
       ] }),
-      /* @__PURE__ */ jsx19(
+      /* @__PURE__ */ jsx22(
         BlinkingTextInput,
         {
           onSubmit: (v) => {
@@ -4486,12 +5400,12 @@ function ModelSelectionStep({
           }
         }
       ),
-      /* @__PURE__ */ jsx19(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx19(Text13, { dimColor: true, children: "Press ESC to go back to list" }) })
+      /* @__PURE__ */ jsx22(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx22(Text15, { dimColor: true, children: "Press ESC to go back to list" }) })
     ] });
   }
-  return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx19(Text13, { children: title }),
-    /* @__PURE__ */ jsx19(
+  return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx22(Text15, { children: title }),
+    /* @__PURE__ */ jsx22(
       Select,
       {
         options: [
@@ -4507,15 +5421,15 @@ function ModelSelectionStep({
         }
       }
     ),
-    /* @__PURE__ */ jsx19(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx19(Text13, { dimColor: true, children: "Press ESC to go back" }) })
+    /* @__PURE__ */ jsx22(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx22(Text15, { dimColor: true, children: "Press ESC to go back" }) })
   ] });
 }
 
 // ink/configurationWizard/ProviderStep.tsx
 import { Select as Select2 } from "@inkjs/ui";
-import { Box as Box14, Text as Text14 } from "ink";
-import { useStepperInput as useStepperInput4 } from "ink-stepper";
-import { useEffect as useEffect11 } from "react";
+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 = [
@@ -4526,16 +5440,16 @@ var providers = [
 ];
 
 // ink/configurationWizard/ProviderStep.tsx
-import { jsx as jsx20, jsxs as jsxs13 } from "react/jsx-runtime";
+import { jsx as jsx23, jsxs as jsxs15 } from "react/jsx-runtime";
 function ProviderStep({ onConfirm }) {
-  const { disableNavigation, enableNavigation } = useStepperInput4();
-  useEffect11(() => {
+  const { disableNavigation, enableNavigation } = useStepperInput5();
+  useEffect13(() => {
     disableNavigation();
     return () => enableNavigation();
   }, [disableNavigation, enableNavigation]);
-  return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx20(Text14, { children: "What model provider would you like to use today?" }),
-    /* @__PURE__ */ jsx20(
+  return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx23(Text16, { children: "What model provider would you like to use today?" }),
+    /* @__PURE__ */ jsx23(
       Select2,
       {
         options: providers,
@@ -4546,9 +5460,9 @@ function ProviderStep({ onConfirm }) {
 }
 
 // ink/configurationWizard/StepperProgress.tsx
-import { Box as Box15, Text as Text15 } from "ink";
-import { Fragment as Fragment2 } from "react";
-import { jsx as jsx21, jsxs as jsxs14 } from "react/jsx-runtime";
+import { Box as Box17, Text as Text17 } from "ink";
+import { Fragment as Fragment3 } from "react";
+import { jsx as jsx24, jsxs as jsxs16 } from "react/jsx-runtime";
 var markers = {
   completed: " \u2713 ",
   current: " \u25CF ",
@@ -4556,10 +5470,10 @@ var markers = {
 };
 var SEGMENT_WIDTH = 12;
 function StepperProgress({ steps, currentStep }) {
-  return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsx21(Box15, { children: steps.map((step) => {
-      return /* @__PURE__ */ jsx21(Box15, { width: SEGMENT_WIDTH, justifyContent: "center", children: /* @__PURE__ */ jsx21(
-        Text15,
+  return /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx24(Box17, { children: steps.map((step) => {
+      return /* @__PURE__ */ jsx24(Box17, { width: SEGMENT_WIDTH, justifyContent: "center", children: /* @__PURE__ */ jsx24(
+        Text17,
         {
           color: step.completed ? "green" : step.current ? "cyan" : "gray",
           bold: step.current,
@@ -4568,32 +5482,32 @@ function StepperProgress({ steps, currentStep }) {
         }
       ) }, step.name);
     }) }),
-    /* @__PURE__ */ jsx21(Box15, { children: steps.map((step, idx) => {
+    /* @__PURE__ */ jsx24(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__ */ jsxs14(Fragment2, { children: [
-        /* @__PURE__ */ jsx21(Text15, { color: beforeLineColor, children: "\u2501".repeat(SEGMENT_WIDTH / 2 - 2) }),
-        /* @__PURE__ */ jsx21(Text15, { color: markerColor, bold: step.current, children: marker }),
-        /* @__PURE__ */ jsx21(Text15, { color: afterLineColor, children: "\u2501".repeat(SEGMENT_WIDTH / 2 - 1) })
+      return /* @__PURE__ */ jsxs16(Fragment3, { children: [
+        /* @__PURE__ */ jsx24(Text17, { color: beforeLineColor, children: "\u2501".repeat(SEGMENT_WIDTH / 2 - 2) }),
+        /* @__PURE__ */ jsx24(Text17, { color: markerColor, bold: step.current, children: marker }),
+        /* @__PURE__ */ jsx24(Text17, { color: afterLineColor, children: "\u2501".repeat(SEGMENT_WIDTH / 2 - 1) })
       ] }, step.name);
     }) })
   ] });
 }
 
 // ink/configurationWizard/ConfigurationWizard.tsx
-import { jsx as jsx22, jsxs as jsxs15 } from "react/jsx-runtime";
+import { jsx as jsx25, jsxs as jsxs17 } from "react/jsx-runtime";
 function ConfigurationWizard({ onComplete }) {
-  const [provider, setProvider] = useState13("OpenAI");
-  useInput7((input, key) => {
+  const [provider, setProvider] = useState17("OpenAI");
+  useInput10((input, key) => {
     if (key.ctrl && input === "x") {
       emitToListeners("ExitUI", void 0);
     }
   });
   const models = modelsByProvider[provider];
   const compactorModels = compactorModelsByProvider[provider];
-  return /* @__PURE__ */ jsx22(Box16, { flexDirection: "column", padding: 1, minHeight: 10, children: /* @__PURE__ */ jsxs15(
+  return /* @__PURE__ */ jsx25(Box18, { flexDirection: "column", padding: 1, minHeight: 10, children: /* @__PURE__ */ jsxs17(
     Stepper,
     {
       onComplete,
@@ -4601,7 +5515,7 @@ function ConfigurationWizard({ onComplete }) {
       keyboardNav: true,
       renderProgress: StepperProgress,
       children: [
-        /* @__PURE__ */ jsx22(Step, { name: "AI Provider", children: ({ goNext }) => /* @__PURE__ */ jsx22(
+        /* @__PURE__ */ jsx25(Step, { name: "AI Provider", children: ({ goNext }) => /* @__PURE__ */ jsx25(
           ProviderStep,
           {
             onConfirm: (p) => {
@@ -4610,7 +5524,7 @@ function ConfigurationWizard({ onComplete }) {
             }
           }
         ) }),
-        /* @__PURE__ */ jsx22(Step, { name: provider !== "Ollama" ? "API Key" : "API", children: ({ goNext, goBack }) => provider !== "Ollama" ? /* @__PURE__ */ jsx22(
+        /* @__PURE__ */ jsx25(Step, { name: provider !== "Ollama" ? "API Key" : "API", children: ({ goNext, goBack }) => provider !== "Ollama" ? /* @__PURE__ */ jsx25(
           ApiKeyStep,
           {
             provider,
@@ -4620,7 +5534,7 @@ function ConfigurationWizard({ onComplete }) {
             },
             onBack: goBack
           }
-        ) : /* @__PURE__ */ jsx22(
+        ) : /* @__PURE__ */ jsx25(
           ApiUrlStep,
           {
             provider,
@@ -4631,7 +5545,7 @@ function ConfigurationWizard({ onComplete }) {
             onBack: goBack
           }
         ) }),
-        /* @__PURE__ */ jsx22(Step, { name: "Model", children: ({ goNext, goBack }) => /* @__PURE__ */ jsx22(
+        /* @__PURE__ */ jsx25(Step, { name: "Model", children: ({ goNext, goBack }) => /* @__PURE__ */ jsx25(
           ModelSelectionStep,
           {
             title: "What model would you like to use?",
@@ -4643,7 +5557,7 @@ function ConfigurationWizard({ onComplete }) {
             onBack: goBack
           }
         ) }),
-        /* @__PURE__ */ jsx22(Step, { name: "Compactor", children: ({ goNext, goBack }) => /* @__PURE__ */ jsx22(
+        /* @__PURE__ */ jsx25(Step, { name: "Compactor", children: ({ goNext, goBack }) => /* @__PURE__ */ jsx25(
           ModelSelectionStep,
           {
             title: "What model should we use for memory compaction?",
@@ -4654,6 +5568,15 @@ function ConfigurationWizard({ onComplete }) {
             },
             onBack: goBack
           }
+        ) }),
+        /* @__PURE__ */ jsx25(Step, { name: "Settings", children: ({ goNext, goBack }) => /* @__PURE__ */ jsx25(
+          EnvironmentSettingsStep,
+          {
+            onConfirm: () => {
+              goNext();
+            },
+            onBack: goBack
+          }
         ) })
       ]
     }
@@ -4661,22 +5584,25 @@ function ConfigurationWizard({ onComplete }) {
 }
 
 // ink/main.tsx
-import { jsx as jsx23 } from "react/jsx-runtime";
+import { jsx as jsx26, jsxs as jsxs18 } from "react/jsx-runtime";
 function bootstrapConfig(onComplete) {
-  render(/* @__PURE__ */ jsx23(MainConfig, { onComplete }));
+  render(/* @__PURE__ */ jsx26(MainConfig, { onComplete }));
 }
 function MainConfig({ onComplete }) {
   const { exit } = useApp();
   useListener("ExitUI", () => exit(), [exit]);
-  return /* @__PURE__ */ jsx23(ConfigurationWizard, { onComplete });
+  return /* @__PURE__ */ jsx26(ConfigurationWizard, { onComplete });
 }
 function bootstrapMain() {
-  render(/* @__PURE__ */ jsx23(MainChat, {}));
+  render(/* @__PURE__ */ jsx26(MainChat, {}));
 }
 function MainChat() {
   const { exit } = useApp();
   useListener("ExitUI", () => exit(), [exit]);
-  return /* @__PURE__ */ jsx23(CostProvider, { children: /* @__PURE__ */ jsx23(PlanProvider, { children: /* @__PURE__ */ jsx23(ActionsProvider, { children: /* @__PURE__ */ jsx23(SettingsProvider, { children: /* @__PURE__ */ jsx23(ChatProvider, { children: /* @__PURE__ */ jsx23(ChatContent, {}) }) }) }) }) });
+  return /* @__PURE__ */ jsx26(CostProvider, { children: /* @__PURE__ */ jsx26(PlanProvider, { children: /* @__PURE__ */ jsx26(ActionsProvider, { children: /* @__PURE__ */ jsx26(ApprovalProvider, { children: /* @__PURE__ */ jsx26(SettingsProvider, { children: /* @__PURE__ */ jsxs18(ChatProvider, { children: [
+    /* @__PURE__ */ jsx26(ChatContent, {}),
+    /* @__PURE__ */ jsx26(DiffApprovalView, {})
+  ] }) }) }) }) }) });
 }
 
 // lifecycle/parseArgs.ts
@@ -4687,12 +5613,12 @@ import chalk4 from "chalk";
 
 // utils/package/getOwnPackageJson.ts
 import { readFileSync as readFileSync6 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { fileURLToPath } from "url";
 var __dirname = fileURLToPath(new URL(".", import.meta.url));
 function getOwnPackageJson() {
   try {
-    const packageContents = readFileSync6(join9(__dirname, "../package.json"), "utf8");
+    const packageContents = readFileSync6(join10(__dirname, "../package.json"), "utf8");
     return JSON.parse(packageContents);
   } catch {
     return { name: "@harperfast/agent", version: "0.0.0" };
@@ -4775,7 +5701,8 @@ function parseArgs() {
       ["compactionModel", ["--compaction-model", "-c", "compaction-model"]],
       ["sessionPath", ["--session", "-s", "session"]],
       ["maxTurns", ["--max-turns"]],
-      ["maxCost", ["--max-cost"]]
+      ["maxCost", ["--max-cost"]],
+      ["rateLimitThreshold", ["--rate-limit-threshold"]]
     ];
     let handled = false;
     for (const [key, prefixes] of flagPairs) {
@@ -4783,7 +5710,7 @@ function parseArgs() {
         if (arg === prefix) {
           if (args[i + 1]) {
             const val = stripQuotes(args[++i]);
-            if (key === "maxTurns" || key === "maxCost") {
+            if (key === "maxTurns" || key === "maxCost" || key === "rateLimitThreshold") {
               trackedState[key] = parseFloat(val);
             } else {
               trackedState[key] = val;
@@ -4793,7 +5720,7 @@ function parseArgs() {
           break;
         } else if (arg.startsWith(`${prefix}=`)) {
           const val = stripQuotes(arg.slice(prefix.length + 1));
-          if (key === "maxTurns" || key === "maxCost") {
+          if (key === "maxTurns" || key === "maxCost" || key === "rateLimitThreshold") {
             trackedState[key] = parseFloat(val);
           } else {
             trackedState[key] = val;
@@ -4811,6 +5738,8 @@ function parseArgs() {
     }
     if (arg === "--flex-tier") {
       trackedState.useFlexTier = true;
+    } else if (arg === "--no-monitor-rate-limits") {
+      trackedState.monitorRateLimits = false;
     }
   }
   if (!trackedState.model && process.env.HARPER_AGENT_MODEL) {
@@ -4828,6 +5757,12 @@ function parseArgs() {
   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;
+  }
   const sp = trackedState.sessionPath;
   if (sp) {
     trackedState.sessionPath = sp && !sp.startsWith("~") && !path8.isAbsolute(sp) ? path8.resolve(process.cwd(), sp) : sp;
@@ -4835,6 +5770,15 @@ function parseArgs() {
   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 (!trackedState.model) {
     if (process.env.ANTHROPIC_API_KEY) {
       trackedState.model = "claude-3-7-sonnet-latest";
@@ -4865,6 +5809,159 @@ function parseArgs() {
   }
 }
 
+// utils/envLoader.ts
+import dotenv from "dotenv";
+import { existsSync as existsSync9 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join11 } from "path";
+function loadEnv() {
+  const topLevelEnvPath = join11(homedir4(), ".harper", "harper-agent-env");
+  const localEnvPath = join11(process.cwd(), ".env");
+  if (existsSync9(topLevelEnvPath)) {
+    dotenv.config({ path: topLevelEnvPath, quiet: true });
+  }
+  if (existsSync9(localEnvPath)) {
+    dotenv.config({ path: localEnvPath, override: true, quiet: true });
+  }
+}
+
+// utils/package/checkForUpdate.ts
+import { Select as Select3 } from "@inkjs/ui";
+import chalk5 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,
+      `${chalk5.yellow("Update available:")} ${chalk5.bold(packageName)} ${chalk5.dim(`v${currentVersion}`)} \u2192 ${chalk5.green(`v${latestVersion}`)}`
+    ),
+    React21.createElement(
+      Box19,
+      { marginTop: 1 },
+      React21.createElement(Select3, {
+        options,
+        onChange: (v) => onSelect(v)
+      })
+    )
+  );
+}
+
 // utils/shell/ensureApiKey.ts
 function ensureApiKey() {
   const models = [
@@ -4905,8 +6002,22 @@ async function getStdin() {
 
 // agent.ts
 (async function() {
+  setupGlobalErrorHandlers();
+  loadEnv();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (...args) => {
+    const response = await originalFetch(...args);
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    rateLimitTracker.updateFromHeaders(headers);
+    emitToListeners("SettingsUpdated", void 0);
+    return response;
+  };
   process.on("SIGINT", handleExit);
   process.on("SIGTERM", handleExit);
+  await checkForUpdate();
   parseArgs();
   if (!ensureApiKey()) {
     await new Promise((resolve2) => {
@@ -4915,7 +6026,7 @@ async function getStdin() {
     emitToListeners("ExitUI", void 0);
     parseArgs();
     if (!ensureApiKey()) {
-      console.log(chalk5.red("No key provided. Exiting."));
+      console.log(chalk6.red("No key provided. Exiting."));
       process.exit(1);
     }
   }