@harperfast/agent 0.13.7-ink → 0.13.8-ink

package/dist/agent.js

@@ -1,11 +1,5 @@
 #!/usr/bin/env node
 
-// agent.ts
-import chalk6 from "chalk";
-
-// agent/AgentManager.ts
-import { Agent as Agent3 } from "@openai/agents";
-
 // ink/emitters/listener.ts
 import React, { useCallback, useEffect } from "react";
 var listenersMap = {};
@@ -68,29 +62,215 @@ 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 { join } from "path";
+import path, { dirname, join } from "path";
+function findNearestHarperConfigDir(startDir) {
+  let dir = path.resolve(startDir);
+  let maxDepth = 10;
+  while (true) {
+    if (maxDepth-- <= 0) {
+      return null;
+    }
+    const candidate = join(dir, "config.yaml");
+    if (existsSync(candidate)) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+function resolveSessionPathConsideringHarper(raw, cwd, originalCwd) {
+  if (!raw) {
+    return null;
+  }
+  if (raw.startsWith("~") || path.isAbsolute(raw)) {
+    return raw;
+  }
+  const harperRoot = findNearestHarperConfigDir(cwd);
+  if (harperRoot) {
+    return path.resolve(harperRoot, raw);
+  }
+  return path.resolve(originalCwd, raw);
+}
 
 // lifecycle/trackedState.ts
 var trackedState = {
+  originalCwd: process.cwd(),
   cwd: process.cwd(),
   model: "",
   compactionModel: "",
-  sessionPath: null,
+  originalSessionPath: null,
+  get sessionPath() {
+    return resolveSessionPathConsideringHarper(trackedState.originalSessionPath, this.cwd, this.originalCwd);
+  },
+  set sessionPath(value) {
+    trackedState.originalSessionPath = value;
+  },
   useFlexTier: false,
+  currentTurn: 0,
   maxTurns: 30,
   maxCost: null,
   autoApproveCodeInterpreter: false,
   autoApprovePatches: false,
   autoApproveShell: false,
   monitorRateLimits: true,
-  rateLimitThreshold: 80
+  rateLimitThreshold: 80,
+  autonomous: false,
+  prompt: null
 };
 
 // lifecycle/defaultInstructions.ts
 function defaultInstructions() {
-  const harperAppExists = existsSync(join(trackedState.cwd, "config.yaml"));
+  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.`;
 }
@@ -102,8 +282,33 @@ import { openai } from "@ai-sdk/openai";
 import { aisdk } from "@openai/agents-extensions";
 import "@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-coder:30b";
+var defaultOllamaCompactionModel = "ollama-qwen2.5-coder";
+var defaultModels = [
+  defaultOpenAIModel,
+  defaultAnthropicModel,
+  defaultGoogleModel,
+  defaultOllamaModel
+];
+var defaultCompactionModels = [
+  defaultOpenAICompactionModel,
+  defaultAnthropicCompactionModel,
+  defaultGoogleCompactionModel,
+  defaultOllamaCompactionModel
+];
+
+// lifecycle/getModel.ts
 function isOpenAIModel(modelName) {
-  if (!modelName || modelName === "gpt-5.2") {
+  if (!modelName || modelName === defaultOpenAIModel) {
     return true;
   }
   return !modelName.startsWith("claude-") && !modelName.startsWith("gemini-") && !modelName.startsWith("ollama-");
@@ -154,13 +359,136 @@ function normalizeOllamaBaseUrl(baseUrl) {
   return urlObj.toString().replace(/\/$/, "");
 }
 
+// lifecycle/handleExit.ts
+import { getGlobalTraceProvider } from "@openai/agents";
+
+// utils/shell/harperProcess.ts
+import spawn from "cross-spawn";
+import { execSync } from "child_process";
+import { homedir } from "os";
+import { join as join3 } from "path";
+var HarperProcess = class {
+  childProcess = null;
+  externalPid = null;
+  logTailProcess = null;
+  logs = [];
+  httpPort = 9926;
+  get running() {
+    if (this.childProcess !== null) {
+      return true;
+    }
+    this.updateExternalStatus();
+    return this.externalPid !== null;
+  }
+  get startedInternally() {
+    return this.childProcess !== null;
+  }
+  updateExternalStatus() {
+    try {
+      const status = execSync("harper status", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+      if (status.includes("status: running")) {
+        const pidMatch = status.match(/pid: (\d+)/);
+        if (pidMatch?.[1]) {
+          this.externalPid = parseInt(pidMatch[1], 10);
+          if (!this.logTailProcess) {
+            this.startTailingLogs();
+          }
+          return;
+        }
+      }
+    } catch {
+    }
+    this.externalPid = null;
+    this.stopTailingLogs();
+  }
+  startTailingLogs() {
+    const logPath = join3(homedir(), "hdb", "log", "hdb.log");
+    this.logTailProcess = spawn("tail", ["-f", logPath], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.logTailProcess.stdout?.on("data", (data) => {
+      const string = data.toString();
+      this.updatePortFromLogs(string);
+      this.logs.push(string);
+    });
+    this.logTailProcess.stderr?.on("data", (data) => {
+      this.logs.push(data.toString());
+    });
+    this.logTailProcess.on("exit", () => {
+      this.logTailProcess = null;
+    });
+  }
+  stopTailingLogs() {
+    if (this.logTailProcess) {
+      this.logTailProcess.kill();
+      this.logTailProcess = null;
+    }
+  }
+  updatePortFromLogs(string) {
+    if (string.includes("REST:") && string.includes("HTTP:")) {
+      this.httpPort = parseInt(string.split("HTTP:").pop().split(",")[0], 10);
+    }
+  }
+  start(directoryName) {
+    if (this.running) {
+      throw new Error("Harper process is already running.");
+    }
+    this.logs = [];
+    this.childProcess = spawn("harperdb", ["dev", "."], {
+      cwd: directoryName,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.childProcess.stdout?.on("data", (data) => {
+      const string = data.toString();
+      this.updatePortFromLogs(string);
+      this.logs.push(string);
+    });
+    this.childProcess.stderr?.on("data", (data) => {
+      this.logs.push(data.toString());
+    });
+    this.childProcess.on("exit", () => {
+      this.childProcess = null;
+    });
+  }
+  stop() {
+    if (this.childProcess) {
+      this.childProcess.kill();
+      this.childProcess = null;
+    }
+    if (this.externalPid) {
+      try {
+        process.kill(this.externalPid);
+      } catch {
+      }
+      this.externalPid = null;
+    }
+    this.stopTailingLogs();
+  }
+  getAndClearLogs() {
+    const logs2 = this.logs;
+    this.logs = [];
+    return logs2.join("");
+  }
+};
+var harperProcess = new HarperProcess();
+
+// lifecycle/handleExit.ts
+async function handleExit() {
+  if (harperProcess.startedInternally) {
+    harperProcess.stop();
+  }
+  await getGlobalTraceProvider().forceFlush();
+  emitToListeners("ExitUI", void 0);
+  process.exit(0);
+}
+
 // lifecycle/readAgentsMD.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { join as join4 } from "path";
 function readAgentsMD() {
-  const agentsMdExists = existsSync2(join2(trackedState.cwd, "AGENTS.md"));
+  const agentsMdExists = existsSync3(join4(trackedState.cwd, "AGENTS.md"));
   if (agentsMdExists) {
-    return readFileSync(join2(trackedState.cwd, "AGENTS.md"), "utf8");
+    return readFileSync(join4(trackedState.cwd, "AGENTS.md"), "utf8");
   }
 }
 
@@ -460,14 +788,14 @@ function getEnv(newKey, oldKey) {
 import { tool as tool10 } from "@openai/agents";
 import { readdirSync, readFileSync as readFileSync2 } from "fs";
 import { createRequire } from "module";
-import { dirname, join as join3 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
 import { z as z10 } from "zod";
-var createHarper = dirname(createRequire(import.meta.url).resolve("create-harper"));
-var agentsMarkdown = join3(
+var createHarper = dirname2(createRequire(import.meta.url).resolve("create-harper"));
+var agentsMarkdown = join5(
   createHarper,
   "AGENTS.md"
 );
-var skillsDir = join3(
+var skillsDir = join5(
   createHarper,
   "template-vanilla",
   "skills"
@@ -504,7 +832,7 @@ async function execute10({ skill }) {
     return "No skills found.";
   }
   try {
-    const filePath = join3(skillsDir, `${skill}.md`);
+    const filePath = join5(skillsDir, `${skill}.md`);
     const content = readFileSync2(filePath, "utf8");
     agentManager.session?.addSkillRead?.(skill);
     return content;
@@ -515,9 +843,9 @@ async function execute10({ skill }) {
 
 // tools/files/workspaceEditor.ts
 import { applyDiff } from "@openai/agents";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
 import { mkdir, rm, writeFile } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 
 // utils/files/normalizeDiff.ts
 function normalizeDiff(diff) {
@@ -534,17 +862,17 @@ function normalizeDiff(diff) {
 }
 
 // utils/files/paths.ts
-import path2 from "path";
+import path3 from "path";
 
 // utils/files/aiignore.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import path from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import path2 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");
+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();
@@ -552,8 +880,8 @@ function logError(error) {
 
 `;
   try {
-    const dir = dirname2(ERROR_LOG_PATH);
-    if (!existsSync3(dir)) {
+    const dir = dirname3(ERROR_LOG_PATH);
+    if (!existsSync4(dir)) {
       mkdirSync(dir, { recursive: true });
     }
     appendFileSync(ERROR_LOG_PATH, logEntry, "utf8");
@@ -577,8 +905,8 @@ function setupGlobalErrorHandlers() {
 // utils/files/aiignore.ts
 var ignorePatterns = [];
 function loadAiIgnore() {
-  const ignorePath = path.join(trackedState.cwd, ".aiignore");
-  if (existsSync4(ignorePath)) {
+  const ignorePath = path2.join(trackedState.cwd, ".aiignore");
+  if (existsSync5(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);
@@ -592,39 +920,39 @@ function loadAiIgnore() {
   }
 }
 function isIgnored(filePath) {
-  const directParts = path.normalize(filePath).split(path.sep);
+  const directParts = path2.normalize(filePath).split(path2.sep);
   if (directParts.includes(".aiignore")) {
     return true;
   }
-  const absolutePath = path.resolve(trackedState.cwd, filePath);
-  const relativePath = path.relative(trackedState.cwd, absolutePath);
-  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+  const absolutePath = path2.resolve(trackedState.cwd, filePath);
+  const relativePath = path2.relative(trackedState.cwd, absolutePath);
+  if (relativePath.startsWith("..") || path2.isAbsolute(relativePath)) {
     return false;
   }
-  const normalizedPath2 = path.normalize(relativePath);
-  const parts = normalizedPath2.split(path.sep);
+  const normalizedPath2 = path2.normalize(relativePath);
+  const parts = normalizedPath2.split(path2.sep);
   loadAiIgnore();
   if (ignorePatterns.length === 0) {
     return false;
   }
   return ignorePatterns.some((pattern) => {
     if (pattern.startsWith("/")) {
-      const normalizedPattern = path.normalize(pattern.substring(1));
-      return normalizedPath2 === normalizedPattern || normalizedPath2.startsWith(normalizedPattern + path.sep);
+      const normalizedPattern = path2.normalize(pattern.substring(1));
+      return normalizedPath2 === normalizedPattern || normalizedPath2.startsWith(normalizedPattern + path2.sep);
     }
     return parts.some((part, index) => {
-      const subPath = parts.slice(index).join(path.sep);
-      const normalizedPattern = path.normalize(pattern);
-      return subPath === normalizedPattern || subPath.startsWith(normalizedPattern + path.sep);
+      const subPath = parts.slice(index).join(path2.sep);
+      const normalizedPattern = path2.normalize(pattern);
+      return subPath === normalizedPattern || subPath.startsWith(normalizedPattern + path2.sep);
     });
   });
 }
 
 // utils/files/paths.ts
 function resolvePath(root, relativePath) {
-  const resolved = path2.resolve(root, relativePath);
-  const relative = path2.relative(root, resolved);
-  if (relative.startsWith("..") || path2.isAbsolute(relative)) {
+  const resolved = path3.resolve(root, relativePath);
+  const relative = path3.relative(root, resolved);
+  if (relative.startsWith("..") || path3.isAbsolute(relative)) {
     throw new Error(`Operation outside workspace: ${relativePath}`);
   }
   if (isIgnored(resolved)) {
@@ -642,7 +970,7 @@ var WorkspaceEditor = class {
   async createFile(operation) {
     try {
       const targetPath = resolvePath(this.root(), operation.path);
-      await mkdir(path3.dirname(targetPath), { recursive: true });
+      await mkdir(path4.dirname(targetPath), { recursive: true });
       const normalizedDiff = normalizeDiff(operation.diff);
       const content = applyDiff("", normalizedDiff, "create");
       await writeFile(targetPath, content, "utf8");
@@ -654,7 +982,7 @@ var WorkspaceEditor = class {
   async updateFile(operation) {
     try {
       const targetPath = resolvePath(this.root(), operation.path);
-      if (!existsSync5(targetPath)) {
+      if (!existsSync6(targetPath)) {
         return { status: "failed", output: "Error: file not found at path " + targetPath };
       }
       const original = readFileSync4(targetPath, "utf8");
@@ -669,7 +997,7 @@ var WorkspaceEditor = class {
   async deleteFile(operation) {
     try {
       const targetPath = resolvePath(this.root(), operation.path);
-      if (!existsSync5(targetPath)) {
+      if (!existsSync6(targetPath)) {
         return { status: "failed", output: "Error: file not found at path " + targetPath };
       }
       await rm(targetPath, { force: true });
@@ -910,7 +1238,7 @@ var findTool = tool14({
 // tools/files/readDirTool.ts
 import { tool as tool15 } from "@openai/agents";
 import { readdir } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 import { z as z15 } from "zod";
 var ToolParameters14 = z15.object({
   directoryName: z15.string().describe("The name of the directory to read.")
@@ -923,7 +1251,7 @@ var readDirTool = tool15({
     try {
       const resolvedPath = resolvePath(trackedState.cwd, directoryName);
       const files = await readdir(resolvedPath, "utf8");
-      return files.filter((file) => !isIgnored(path4.join(resolvedPath, file)));
+      return files.filter((file) => !isIgnored(path5.join(resolvedPath, file)));
     } catch (error) {
       return `Error reading directory: ${error}`;
     }
@@ -979,7 +1307,7 @@ var readFileTool = tool16({
 import { tool as tool17 } from "@openai/agents";
 import { exec } from "child_process";
 import { unlink, writeFile as writeFile2 } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 import { promisify as promisify3 } from "util";
 import { z as z17 } from "zod";
 var execAsync = promisify3(exec);
@@ -1022,7 +1350,7 @@ async function needsApproval2(runContext, parameters, callId) {
 async function execute14({ code, language }) {
   const extension = language === "javascript" ? "js" : "py";
   const interpreter = language === "javascript" ? "node" : "python3";
-  const tempFile = path5.join(trackedState.cwd, `.temp_code_${Date.now()}.${extension}`);
+  const tempFile = path6.join(trackedState.cwd, `.temp_code_${Date.now()}.${extension}`);
   try {
     await writeFile2(tempFile, code, "utf8");
     const { stdout, stderr } = await execAsync(`${interpreter} ${tempFile}`);
@@ -1040,45 +1368,82 @@ STDERR: ${error.stderr || ""}`;
   }
 }
 
-// tools/general/setInterpreterAutoApproveTool.ts
+// tools/general/collectFeedbackTool.ts
 import { tool as tool18 } from "@openai/agents";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify4 } from "util";
 import { z as z18 } from "zod";
+var execAsync2 = promisify4(exec2);
+var ToolParameters16 = z18.object({
+  feedbackSummary: z18.string().describe("A brief summary of the feedback, used as the discussion title."),
+  feedbackDetails: z18.string().describe("Detailed feedback from the user or agent observation."),
+  recap: z18.string().describe(
+    "A sanitized recap of what the agent and user did together and if it was successful. No sensitive information."
+  )
+});
+async function execute15({ feedbackSummary, feedbackDetails, recap }) {
+  const title = feedbackSummary;
+  const body = `${feedbackDetails}
+
+${recap}`;
+  const encodedTitle = encodeURIComponent(title);
+  const encodedBody = encodeURIComponent(body);
+  const url = `https://github.com/HarperFast/harper-agent/discussions/new?category=usage-feedback&title=${encodedTitle}&body=${encodedBody}`;
+  try {
+    const command = process.platform === "win32" ? `start "" "${url.replace(/&/g, "^&")}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+    await execAsync2(command);
+    return `Successfully opened feedback URL: ${url}`;
+  } catch (error) {
+    return `Error opening feedback URL: ${error}`;
+  }
+}
+var collectFeedbackTool = tool18({
+  name: "collect_feedback",
+  description: "Collects feedback from the user by opening a pre-populated GitHub Discussion. Use this if the user lets us know we did something well, or if the user seems frustrated, or wants to report a bug. You MUST ask the user if they are willing to share these results before calling this tool.",
+  parameters: ToolParameters16,
+  execute: execute15
+});
+
+// tools/general/setInterpreterAutoApproveTool.ts
+import { tool as tool19 } from "@openai/agents";
+import { z as z19 } from "zod";
 
 // utils/files/updateEnv.ts
-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";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname4, join as join7 } from "path";
 function updateEnv(key, value) {
-  process.env[key] = value;
-  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)) {
+  const normalizedValue = key === "HARPER_AGENT_MODEL" && defaultModels.includes(value) ? defaultModelToken : key === "HARPER_AGENT_COMPACTION_MODEL" && defaultCompactionModels.includes(value) ? defaultModelToken : value;
+  process.env[key] = normalizedValue;
+  const topLevelEnvPath = join7(homedir3(), ".harper", "harper-agent-env");
+  const localEnvPath = join7(trackedState.cwd, ".env");
+  const envPath = existsSync7(topLevelEnvPath) || !existsSync7(localEnvPath) ? topLevelEnvPath : localEnvPath;
+  const dir = dirname4(envPath);
+  if (!existsSync7(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   let envContent = "";
-  if (existsSync6(envPath)) {
+  if (existsSync7(envPath)) {
     envContent = readFileSync5(envPath, "utf8");
   }
   const regex = new RegExp(`^${key}=.*`, "m");
   if (regex.test(envContent)) {
-    envContent = envContent.replace(regex, `${key}=${value}`);
+    envContent = envContent.replace(regex, `${key}=${normalizedValue}`);
   } else {
     if (envContent && !envContent.endsWith("\n")) {
       envContent += "\n";
     }
-    envContent += `${key}=${value}
+    envContent += `${key}=${normalizedValue}
 `;
   }
   writeFileSync(envPath, envContent);
 }
 
 // tools/general/setInterpreterAutoApproveTool.ts
-var SetInterpreterAutoApproveParameters = z18.object({
-  autoApprove: z18.boolean()
+var SetInterpreterAutoApproveParameters = z19.object({
+  autoApprove: z19.boolean()
 });
-var setInterpreterAutoApproveTool = tool18({
+var setInterpreterAutoApproveTool = tool19({
   name: "set_interpreter_auto_approve",
   description: "Enable or disable automatic approval for code interpreter by setting HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER=1 or 0 in .env and current process.",
   parameters: SetInterpreterAutoApproveParameters,
@@ -1103,12 +1468,12 @@ var setInterpreterAutoApproveTool = tool18({
 });
 
 // tools/general/setPatchAutoApproveTool.ts
-import { tool as tool19 } from "@openai/agents";
-import { z as z19 } from "zod";
-var SetPatchAutoApproveParameters = z19.object({
-  autoApprove: z19.boolean()
+import { tool as tool20 } from "@openai/agents";
+import { z as z20 } from "zod";
+var SetPatchAutoApproveParameters = z20.object({
+  autoApprove: z20.boolean()
 });
-var setPatchAutoApproveTool = tool19({
+var setPatchAutoApproveTool = tool20({
   name: "set_patch_auto_approve",
   description: "Enable or disable automatic approval for patch commands by setting HARPER_AGENT_AUTO_APPROVE_PATCHES=1 or 0 in .env and current process.",
   parameters: SetPatchAutoApproveParameters,
@@ -1133,12 +1498,12 @@ var setPatchAutoApproveTool = tool19({
 });
 
 // tools/general/setShellAutoApproveTool.ts
-import { tool as tool20 } from "@openai/agents";
-import { z as z20 } from "zod";
-var SetShellAutoApproveParameters = z20.object({
-  autoApprove: z20.boolean()
+import { tool as tool21 } from "@openai/agents";
+import { z as z21 } from "zod";
+var SetShellAutoApproveParameters = z21.object({
+  autoApprove: z21.boolean()
 });
-var setShellAutoApproveTool = tool20({
+var setShellAutoApproveTool = tool21({
   name: "set_shell_auto_approve",
   description: "Enable or disable automatic approval for shell commands by setting HARPER_AGENT_AUTO_APPROVE_SHELL=1 or 0 in .env and current process.",
   parameters: SetShellAutoApproveParameters,
@@ -1163,8 +1528,8 @@ var setShellAutoApproveTool = tool20({
 });
 
 // tools/general/shellTool.ts
-import { tool as tool21 } from "@openai/agents";
-import { z as z21 } from "zod";
+import { tool as tool22 } from "@openai/agents";
+import { z as z22 } from "zod";
 
 // utils/files/mentionsIgnoredPath.ts
 function mentionsIgnoredPath(command) {
@@ -1218,8 +1583,8 @@ function isRiskyCommand(command) {
 }
 
 // utils/shell/LocalShell.ts
-import { exec as exec2 } from "child_process";
-import { promisify as promisify4 } from "util";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify5 } from "util";
 
 // ink/contexts/ShellContext.tsx
 import { createContext, useContext, useMemo, useState } from "react";
@@ -1228,7 +1593,7 @@ var ShellContext = createContext(void 0);
 var commandId = 0;
 
 // utils/shell/LocalShell.ts
-var execAsync2 = promisify4(exec2);
+var execAsync3 = promisify5(exec3);
 var LocalShell = class {
   defaultTimeoutMs;
   constructor(options) {
@@ -1263,7 +1628,7 @@ var LocalShell = class {
         running: true
       });
       try {
-        const { stdout: localStdout, stderr: localStderr } = await execAsync2(
+        const { stdout: localStdout, stderr: localStderr } = await execAsync3(
           command,
           {
             cwd: trackedState.cwd,
@@ -1311,11 +1676,11 @@ var LocalShell = class {
 };
 
 // tools/general/shellTool.ts
-var ShellParameters = z21.object({
-  commands: z21.array(z21.string()).describe("The commands to execute.")
+var ShellParameters = z22.object({
+  commands: z22.array(z22.string()).describe("The commands to execute.")
 });
 var shell = new LocalShell();
-var shellTool = tool21({
+var shellTool = tool22({
   name: "shell",
   description: "Executes shell commands. Only use when we do not have a better tool.",
   parameters: ShellParameters,
@@ -1364,15 +1729,15 @@ TIMEOUT`;
 });
 
 // tools/git/gitAddTool.ts
-import { tool as tool22 } from "@openai/agents";
+import { tool as tool23 } from "@openai/agents";
 import { execFile as execFile3 } from "child_process";
-import { promisify as promisify5 } from "util";
-import { z as z22 } from "zod";
-var execFileAsync3 = promisify5(execFile3);
-var GitAddParameters = z22.object({
-  files: z22.array(z22.string()).describe("The files to add. If not provided, all changes will be added.")
+import { promisify as promisify6 } from "util";
+import { z as z23 } from "zod";
+var execFileAsync3 = promisify6(execFile3);
+var GitAddParameters = z23.object({
+  files: z23.array(z23.string()).describe("The files to add. If not provided, all changes will be added.")
 });
-var gitAddTool = tool22({
+var gitAddTool = tool23({
   name: "git_add",
   description: "Add file contents to the index.",
   parameters: GitAddParameters,
@@ -1393,16 +1758,16 @@ var gitAddTool = tool22({
 });
 
 // tools/git/gitBranchTool.ts
-import { tool as tool23 } from "@openai/agents";
+import { tool as tool24 } from "@openai/agents";
 import { execFile as execFile4 } from "child_process";
-import { promisify as promisify6 } from "util";
-import { z as z23 } from "zod";
-var execFileAsync4 = promisify6(execFile4);
-var GitBranchParameters = z23.object({
-  branchName: z23.string().describe("The name of the branch to create or switch to."),
-  create: z23.boolean().optional().default(false).describe("Whether to create a new branch.")
+import { promisify as promisify7 } from "util";
+import { z as z24 } from "zod";
+var execFileAsync4 = promisify7(execFile4);
+var GitBranchParameters = z24.object({
+  branchName: z24.string().describe("The name of the branch to create or switch to."),
+  create: z24.boolean().optional().default(false).describe("Whether to create a new branch.")
 });
-var gitBranchTool = tool23({
+var gitBranchTool = tool24({
   name: "git_branch",
   description: "Create or switch to a git branch.",
   parameters: GitBranchParameters,
@@ -1419,18 +1784,18 @@ var gitBranchTool = tool23({
 });
 
 // tools/git/gitCommitTool.ts
-import { tool as tool24 } from "@openai/agents";
+import { tool as tool25 } from "@openai/agents";
 import { execFile as execFile5 } from "child_process";
-import { promisify as promisify7 } from "util";
-import { z as z24 } from "zod";
-var execFileAsync5 = promisify7(execFile5);
-var GitCommitParameters = z24.object({
-  message: z24.string().describe("The commit message."),
-  addAll: z24.boolean().optional().default(false).describe(
+import { promisify as promisify8 } from "util";
+import { z as z25 } from "zod";
+var execFileAsync5 = promisify8(execFile5);
+var GitCommitParameters = z25.object({
+  message: z25.string().describe("The commit message."),
+  addAll: z25.boolean().optional().default(false).describe(
     "Whether to add all changes before committing (git commit -am)."
   )
 });
-var gitCommitTool = tool24({
+var gitCommitTool = tool25({
   name: "git_commit",
   description: "Commit changes to the repository.",
   parameters: GitCommitParameters,
@@ -1446,16 +1811,16 @@ var gitCommitTool = tool24({
 });
 
 // tools/git/gitLogTool.ts
-import { tool as tool25 } from "@openai/agents";
+import { tool as tool26 } from "@openai/agents";
 import { execFile as execFile6 } from "child_process";
-import { promisify as promisify8 } from "util";
-import { z as z25 } from "zod";
-var execFileAsync6 = promisify8(execFile6);
-var GitLogParameters = z25.object({
-  count: z25.number().optional().default(10).describe("Number of commits to show."),
-  oneline: z25.boolean().optional().default(true).describe("Whether to show log in oneline format.")
+import { promisify as promisify9 } from "util";
+import { z as z26 } from "zod";
+var execFileAsync6 = promisify9(execFile6);
+var GitLogParameters = z26.object({
+  count: z26.number().optional().default(10).describe("Number of commits to show."),
+  oneline: z26.boolean().optional().default(true).describe("Whether to show log in oneline format.")
 });
-var gitLogTool = tool25({
+var gitLogTool = tool26({
   name: "git_log",
   description: "Show commit logs.",
   parameters: GitLogParameters,
@@ -1474,17 +1839,17 @@ var gitLogTool = tool25({
 });
 
 // tools/git/gitStashTool.ts
-import { tool as tool26 } from "@openai/agents";
+import { tool as tool27 } from "@openai/agents";
 import { execFile as execFile7 } from "child_process";
-import { promisify as promisify9 } from "util";
-import { z as z26 } from "zod";
-var execFileAsync7 = promisify9(execFile7);
+import { promisify as promisify10 } from "util";
+import { z as z27 } from "zod";
+var execFileAsync7 = promisify10(execFile7);
 var allowedActions = ["push", "pop", "apply", "list"];
-var GitStashParameters = z26.object({
-  action: z26.string().describe("The stash action to perform: " + allowedActions.join(", ")),
-  message: z26.string().describe("A message for the stash change.")
+var GitStashParameters = z27.object({
+  action: z27.string().describe("The stash action to perform: " + allowedActions.join(", ")),
+  message: z27.string().describe("A message for the stash change.")
 });
-var gitStashTool = tool26({
+var gitStashTool = tool27({
   name: "git_stash",
   description: "Stash changes or apply a stash.",
   parameters: GitStashParameters,
@@ -1506,15 +1871,15 @@ var gitStashTool = tool26({
 });
 
 // tools/git/gitStatusTool.ts
-import { tool as tool27 } from "@openai/agents";
+import { tool as tool28 } from "@openai/agents";
 import { execFile as execFile8 } from "child_process";
-import { promisify as promisify10 } from "util";
-import { z as z27 } from "zod";
-var execFileAsync8 = promisify10(execFile8);
-var GitStatusParameters = z27.object({
-  short: z27.boolean().optional().default(false).describe("Whether to show the status in short format.")
+import { promisify as promisify11 } from "util";
+import { z as z28 } from "zod";
+var execFileAsync8 = promisify11(execFile8);
+var GitStatusParameters = z28.object({
+  short: z28.boolean().optional().default(false).describe("Whether to show the status in short format.")
 });
-var gitStatusTool = tool27({
+var gitStatusTool = tool28({
   name: "git_status",
   description: "Show the working tree status.",
   parameters: GitStatusParameters,
@@ -1533,17 +1898,17 @@ var gitStatusTool = tool27({
 });
 
 // tools/git/gitWorkspaceTool.ts
-import { tool as tool28 } from "@openai/agents";
+import { tool as tool29 } from "@openai/agents";
 import { execFile as execFile9 } from "child_process";
-import { promisify as promisify11 } from "util";
-import { z as z28 } from "zod";
-var execFileAsync9 = promisify11(execFile9);
-var GitWorkspaceParameters = z28.object({
-  path: z28.string().describe("The path where the new workspace (worktree) should be created."),
-  branchName: z28.string().describe("The name of the branch to use in the new workspace."),
-  createBranch: z28.boolean().optional().default(false).describe("Whether to create a new branch for this workspace.")
+import { promisify as promisify12 } from "util";
+import { z as z29 } from "zod";
+var execFileAsync9 = promisify12(execFile9);
+var GitWorkspaceParameters = z29.object({
+  path: z29.string().describe("The path where the new workspace (worktree) should be created."),
+  branchName: z29.string().describe("The name of the branch to use in the new workspace."),
+  createBranch: z29.boolean().optional().default(false).describe("Whether to create a new branch for this workspace.")
 });
-var gitWorkspaceTool = tool28({
+var gitWorkspaceTool = tool29({
   name: "git_workspace",
   description: "Create a new workspace (git worktree) for parallel work.",
   parameters: GitWorkspaceParameters,
@@ -1560,125 +1925,13 @@ var gitWorkspaceTool = tool28({
 });
 
 // tools/harper/checkHarperStatusTool.ts
-import { tool as tool29 } from "@openai/agents";
-import { z as z29 } from "zod";
-
-// utils/shell/harperProcess.ts
-import spawn from "cross-spawn";
-import { execSync } from "child_process";
-import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
-var HarperProcess = class {
-  childProcess = null;
-  externalPid = null;
-  logTailProcess = null;
-  logs = [];
-  httpPort = 9926;
-  get running() {
-    if (this.childProcess !== null) {
-      return true;
-    }
-    this.updateExternalStatus();
-    return this.externalPid !== null;
-  }
-  get startedInternally() {
-    return this.childProcess !== null;
-  }
-  updateExternalStatus() {
-    try {
-      const status = execSync("harper status", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-      if (status.includes("status: running")) {
-        const pidMatch = status.match(/pid: (\d+)/);
-        if (pidMatch?.[1]) {
-          this.externalPid = parseInt(pidMatch[1], 10);
-          if (!this.logTailProcess) {
-            this.startTailingLogs();
-          }
-          return;
-        }
-      }
-    } catch {
-    }
-    this.externalPid = null;
-    this.stopTailingLogs();
-  }
-  startTailingLogs() {
-    const logPath = join6(homedir3(), "hdb", "log", "hdb.log");
-    this.logTailProcess = spawn("tail", ["-f", logPath], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    this.logTailProcess.stdout?.on("data", (data) => {
-      const string = data.toString();
-      this.updatePortFromLogs(string);
-      this.logs.push(string);
-    });
-    this.logTailProcess.stderr?.on("data", (data) => {
-      this.logs.push(data.toString());
-    });
-    this.logTailProcess.on("exit", () => {
-      this.logTailProcess = null;
-    });
-  }
-  stopTailingLogs() {
-    if (this.logTailProcess) {
-      this.logTailProcess.kill();
-      this.logTailProcess = null;
-    }
-  }
-  updatePortFromLogs(string) {
-    if (string.includes("REST:") && string.includes("HTTP:")) {
-      this.httpPort = parseInt(string.split("HTTP:").pop().split(",")[0], 10);
-    }
-  }
-  start(directoryName) {
-    if (this.running) {
-      throw new Error("Harper process is already running.");
-    }
-    this.logs = [];
-    this.childProcess = spawn("harperdb", ["dev", "."], {
-      cwd: directoryName,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    this.childProcess.stdout?.on("data", (data) => {
-      const string = data.toString();
-      this.updatePortFromLogs(string);
-      this.logs.push(string);
-    });
-    this.childProcess.stderr?.on("data", (data) => {
-      this.logs.push(data.toString());
-    });
-    this.childProcess.on("exit", () => {
-      this.childProcess = null;
-    });
-  }
-  stop() {
-    if (this.childProcess) {
-      this.childProcess.kill();
-      this.childProcess = null;
-    }
-    if (this.externalPid) {
-      try {
-        process.kill(this.externalPid);
-      } catch {
-      }
-      this.externalPid = null;
-    }
-    this.stopTailingLogs();
-  }
-  getAndClearLogs() {
-    const logs2 = this.logs;
-    this.logs = [];
-    return logs2.join("");
-  }
-};
-var harperProcess = new HarperProcess();
-
-// tools/harper/checkHarperStatusTool.ts
-var ToolParameters16 = z29.object({});
-var checkHarperStatusTool = tool29({
+import { tool as tool30 } from "@openai/agents";
+import { z as z30 } from "zod";
+var ToolParameters17 = z30.object({});
+var checkHarperStatusTool = tool30({
   name: "check_harper_status",
   description: "Checks if a Harper application is currently running.",
-  parameters: ToolParameters16,
+  parameters: ToolParameters17,
   async execute() {
     if (harperProcess.running) {
       return "A Harper application is currently running.";
@@ -1689,10 +1942,10 @@ var checkHarperStatusTool = tool29({
 });
 
 // tools/harper/createNewHarperApplicationTool.ts
-import { tool as tool30 } from "@openai/agents";
+import { tool as tool31 } from "@openai/agents";
 import { execSync as execSync3 } from "child_process";
-import path6 from "path";
-import { z as z30 } from "zod";
+import path7 from "path";
+import { z as z31 } from "zod";
 
 // utils/package/buildHarperCreateCommand.ts
 function buildCreateCommand(pm, appName, template) {
@@ -1742,16 +1995,16 @@ var PM_DISPLAY = {
 };
 
 // tools/harper/createNewHarperApplicationTool.ts
-var ToolParameters17 = z30.object({
-  directoryName: z30.string().describe("The name of the directory to create the application in."),
-  template: z30.enum(["vanilla-ts", "vanilla", "react-ts", "react"]).optional().describe("The template to use for the new application. Defaults to vanilla-ts.").default("vanilla-ts")
+var ToolParameters18 = z31.object({
+  directoryName: z31.string().describe("The name of the directory to create the application in."),
+  template: z31.enum(["vanilla-ts", "vanilla", "react-ts", "react"]).optional().describe("The template to use for the new application. Defaults to vanilla-ts.").default("vanilla-ts")
 });
-async function execute15({ directoryName, template }) {
+async function execute16({ directoryName, template }) {
   const currentCwd = trackedState.cwd;
   const resolvedPath = resolvePath(currentCwd, directoryName);
   const isCurrentDir = resolvedPath === currentCwd;
-  const executionCwd = isCurrentDir ? resolvedPath : path6.dirname(resolvedPath);
-  const appName = isCurrentDir ? "." : path6.basename(resolvedPath);
+  const executionCwd = isCurrentDir ? resolvedPath : path7.dirname(resolvedPath);
+  const appName = isCurrentDir ? "." : path7.basename(resolvedPath);
   try {
     const pm = pickPreferredPackageManager();
     const { cmd, label } = buildCreateCommand(pm, appName, template);
@@ -1783,33 +2036,33 @@ ${error.stdout}`;
     return errorMsg;
   }
 }
-var createNewHarperApplicationTool = tool30({
+var createNewHarperApplicationTool = tool31({
   name: "create_new_harper_application",
   description: "Creates a new Harper application using the best available package manager (yarn/pnpm/bun/deno, falling back to npm).",
-  parameters: ToolParameters17,
-  execute: execute15
+  parameters: ToolParameters18,
+  execute: execute16
 });
 
 // tools/harper/getHarperConfigSchemaTool.ts
-import { tool as tool31 } from "@openai/agents";
+import { tool as tool32 } from "@openai/agents";
 import { readFile as readFile2 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
-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(
+import { dirname as dirname5, join as join8 } from "path";
+import { z as z32 } from "zod";
+var ToolParameters19 = z32.object({
+  schemaType: z32.enum(["app", "root"]).describe(
     'The type of configuration schema to retrieve: "app" for application configuration or "root" for root Harper configuration.'
   )
 });
-var getHarperConfigSchemaTool = tool31({
+var getHarperConfigSchemaTool = tool32({
   name: "get_harper_config_schema",
   description: "Returns the JSON schema for HarperDB configuration files (either app or root), which describes the config.yaml or harperdb-config.yaml files.",
-  parameters: ToolParameters18,
+  parameters: ToolParameters19,
   async execute({ schemaType }) {
     try {
       return await readFile2(
-        join7(
-          dirname4(createRequire2(import.meta.url).resolve("harperdb")),
+        join8(
+          dirname5(createRequire2(import.meta.url).resolve("harperdb")),
           `config-${schemaType}.schema.json`
         ),
         "utf8"
@@ -1821,13 +2074,13 @@ var getHarperConfigSchemaTool = tool31({
 });
 
 // tools/harper/getHarperResourceInterfaceTool.ts
-import { tool as tool32 } from "@openai/agents";
+import { tool as tool33 } from "@openai/agents";
 import { readFile as readFile3 } from "fs/promises";
 import { createRequire as createRequire3 } from "module";
-import { dirname as dirname5, join as join8 } from "path";
-import { z as z32 } from "zod";
-var ToolParameters19 = z32.object({
-  resourceFile: z32.enum([
+import { dirname as dirname6, join as join9 } from "path";
+import { z as z33 } from "zod";
+var ToolParameters20 = z33.object({
+  resourceFile: z33.enum([
     "ResourceInterfaceV2",
     "ResourceInterface",
     "Table",
@@ -1837,15 +2090,15 @@ var ToolParameters19 = z32.object({
     "The resource-related definition file to read. Defaults to ResourceInterfaceV2."
   ).default("ResourceInterfaceV2")
 });
-var getHarperResourceInterfaceTool = tool32({
+var getHarperResourceInterfaceTool = tool33({
   name: "get_harper_resource_interface",
   description: "Reads HarperDB resource interface and class definitions (like ResourceInterfaceV2.d.ts) to understand how resources and tables are structured.",
-  parameters: ToolParameters19,
+  parameters: ToolParameters20,
   async execute({ resourceFile }) {
     try {
       return await readFile3(
-        join8(
-          dirname5(createRequire3(import.meta.url).resolve("harperdb")),
+        join9(
+          dirname6(createRequire3(import.meta.url).resolve("harperdb")),
           "resources",
           `${resourceFile}.d.ts`
         ),
@@ -1858,21 +2111,21 @@ var getHarperResourceInterfaceTool = tool32({
 });
 
 // tools/harper/getHarperSchemaGraphQLTool.ts
-import { tool as tool33 } from "@openai/agents";
+import { tool as tool34 } from "@openai/agents";
 import { readFile as readFile4 } from "fs/promises";
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname6, join as join9 } from "path";
-import { z as z33 } from "zod";
-var ToolParameters20 = z33.object({});
-var getHarperSchemaGraphQLTool = tool33({
+import { dirname as dirname7, join as join10 } from "path";
+import { z as z34 } from "zod";
+var ToolParameters21 = z34.object({});
+var getHarperSchemaGraphQLTool = tool34({
   name: "get_harper_schema_graphql",
   description: "Returns the GraphQL schema for HarperDB schema files, which define the structure of HarperDB database tables.",
-  parameters: ToolParameters20,
+  parameters: ToolParameters21,
   async execute() {
     try {
       return await readFile4(
-        join9(
-          dirname6(createRequire4(import.meta.url).resolve("harperdb")),
+        join10(
+          dirname7(createRequire4(import.meta.url).resolve("harperdb")),
           `schema.graphql`
         ),
         "utf8"
@@ -1884,22 +2137,22 @@ var getHarperSchemaGraphQLTool = tool33({
 });
 
 // tools/harper/hitHarperAPITool.ts
-import { tool as tool34 } from "@openai/agents";
-import { z as z34 } from "zod";
-var ToolParameters21 = z34.object({
-  method: z34.enum(["POST", "GET", "PUT", "DELETE"]).optional().default("GET").describe(
+import { tool as tool35 } from "@openai/agents";
+import { z as z35 } from "zod";
+var ToolParameters22 = z35.object({
+  method: z35.enum(["POST", "GET", "PUT", "DELETE"]).optional().default("GET").describe(
     'The HTTP method to use, defaults to "get". Notably, POST and PUT require the full body be sent.'
   ),
-  path: z34.string().optional().default("/openapi").describe("The path to fetch from localhost (defaults to /openapi)."),
-  port: z34.number().optional().default(harperProcess.httpPort).describe(
+  path: z35.string().optional().default("/openapi").describe("The path to fetch from localhost (defaults to /openapi)."),
+  port: z35.number().optional().default(harperProcess.httpPort).describe(
     "The port to fetch from localhost (defaults to the running Harper port)."
   ),
-  body: z34.string().optional().default("").describe("An optional JSON string body to send along with the request.")
+  body: z35.string().optional().default("").describe("An optional JSON string body to send along with the request.")
 });
-var hitHarperAPITool = tool34({
+var hitHarperAPITool = tool35({
   name: "hit_harper_api",
   description: "Performs a request against the running Harper API. Use /openapi to look up Harper APIs.",
-  parameters: ToolParameters21,
+  parameters: ToolParameters22,
   needsApproval: async (runContext, input, callId) => {
     if (callId && runContext.isToolApproved({ toolName: "hit_harper_api", callId })) {
       return false;
@@ -1937,13 +2190,13 @@ var hitHarperAPITool = tool34({
 });
 
 // tools/harper/readHarperLogsTool.ts
-import { tool as tool35 } from "@openai/agents";
-import { z as z35 } from "zod";
-var ToolParameters22 = z35.object({});
-var readHarperLogsTool = tool35({
+import { tool as tool36 } from "@openai/agents";
+import { z as z36 } from "zod";
+var ToolParameters23 = z36.object({});
+var readHarperLogsTool = tool36({
   name: "read_harper_logs",
   description: "Reads the most recent console logs of a started Harper app and clears them so that subsequent reads will only show new logs.",
-  parameters: ToolParameters22,
+  parameters: ToolParameters23,
   async execute() {
     if (!harperProcess.running) {
       return `Error: No Harper application is currently running.`;
@@ -1958,10 +2211,10 @@ var readHarperLogsTool = tool35({
 });
 
 // tools/harper/startHarperTool.ts
-import { tool as tool36 } from "@openai/agents";
-import { existsSync as existsSync7 } from "fs";
+import { tool as tool37 } from "@openai/agents";
+import { existsSync as existsSync8 } from "fs";
 import { basename, resolve } from "path";
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 
 // utils/promises/sleep.ts
 function sleep(ms) {
@@ -1969,13 +2222,13 @@ function sleep(ms) {
 }
 
 // tools/harper/startHarperTool.ts
-var ToolParameters23 = z36.object({
-  directoryName: z36.string().describe("The name of the directory that the Harper app is in.")
+var ToolParameters24 = z37.object({
+  directoryName: z37.string().describe("The name of the directory that the Harper app is in.")
 });
-var startHarperTool = tool36({
+var startHarperTool = tool37({
   name: "start_harper",
   description: "Starts a Harper app background process, allowing you to observe the app in action (by readHarperLogsTool, hitHarperAPITool, etc).",
-  parameters: ToolParameters23,
+  parameters: ToolParameters24,
   async execute({ directoryName }) {
     if (isIgnored(directoryName)) {
       return `Error: Target directory ${directoryName} is restricted by .aiignore`;
@@ -1986,7 +2239,7 @@ var startHarperTool = tool36({
     try {
       let effectiveDirectory = directoryName;
       const candidatePath = resolve(process.cwd(), directoryName);
-      if (!existsSync7(candidatePath)) {
+      if (!existsSync8(candidatePath)) {
         const cwd = process.cwd();
         if (basename(cwd) === directoryName) {
           effectiveDirectory = cwd;
@@ -2004,13 +2257,13 @@ ${logs2}`;
 });
 
 // tools/harper/stopHarperTool.ts
-import { tool as tool37 } from "@openai/agents";
-import { z as z37 } from "zod";
-var ToolParameters24 = z37.object({});
-var stopHarperTool = tool37({
+import { tool as tool38 } from "@openai/agents";
+import { z as z38 } from "zod";
+var ToolParameters25 = z38.object({});
+var stopHarperTool = tool38({
   name: "stop_harper",
   description: "Stops all previously started Harper app background process.",
-  parameters: ToolParameters24,
+  parameters: ToolParameters25,
   async execute() {
     if (!harperProcess.running) {
       return `Error: No Harper application is currently running.`;
@@ -2025,21 +2278,12 @@ 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.")
+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 = tool38({
+var addPlanItemTool = tool39({
   name: "add_plan_item",
   description: "Add a new item to the plan.",
   parameters: AddPlanItemParameters,
@@ -2058,12 +2302,12 @@ var addPlanItemTool = tool38({
 });
 
 // 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.")
+import { tool as tool40 } from "@openai/agents";
+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 = tool39({
+var setPlanDescriptionTool = tool40({
   name: "set_plan_description",
   description: "Set the high-level description for the current plan.",
   parameters: SetPlanDescriptionParameters,
@@ -2074,12 +2318,12 @@ var setPlanDescriptionTool = tool39({
 });
 
 // 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.")
+import { tool as tool41 } from "@openai/agents";
+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 = tool40({
+var setPlanItemsTool = tool41({
   name: "set_plan_items",
   description: "Set multiple plan items at once, replacing any existing items.",
   parameters: SetPlanItemsParameters,
@@ -2095,16 +2339,16 @@ var setPlanItemsTool = tool40({
 });
 
 // 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(
+import { tool as tool42 } from "@openai/agents";
+import { z as z42 } from "zod";
+var UpdatePlanItemParameters = z42.object({
+  id: z42.number().describe("The ID of the plan item to update."),
+  text: z42.string().describe("The new description of the task."),
+  status: z42.enum(["unchanged", "todo", "in-progress", "done", "not-needed"]).describe(
     "The new status of the task."
   )
 });
-var updatePlanItemTool = tool41({
+var updatePlanItemTool = tool42({
   name: "update_plan_item",
   description: "Update an existing plan item.",
   parameters: UpdatePlanItemParameters,
@@ -2143,6 +2387,7 @@ function createTools() {
     addPlanItemTool,
     changeCwdTool,
     checkHarperStatusTool,
+    collectFeedbackTool,
     codeInterpreterTool,
     createApplyPatchTool(),
     createNewHarperApplicationTool,
@@ -2185,6 +2430,7 @@ function trackCompaction(session) {
     try {
       return await originalRunCompaction(args);
     } catch (error) {
+      logError(error);
       const err = error ?? {};
       const name = err.name || "Error";
       const message = err.message || String(err);
@@ -2255,16 +2501,15 @@ Stack: ${String(err.stack).split("\n").slice(0, 8).join("\n")}` : "";
         text: `${name}:${code}${statusStr} ${message}${hint}${compactionCtx}${argsSnippet}${responseDataSnippet}${stack}`,
         version: 1
       }]);
-      return void 0;
     }
   };
 }
 
 // utils/sessions/DiskSession.ts
 import { MemorySession } from "@openai/agents";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { mkdir as mkdir2, readFile as readFile5, rename, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname7 } from "path";
+import { dirname as dirname8 } from "path";
 var DiskSession = class extends MemorySession {
   filePath;
   ready;
@@ -2277,9 +2522,23 @@ var DiskSession = class extends MemorySession {
     const storage = await this.loadStorage();
     let sessionId = this.sessionId;
     if (!options?.sessionId) {
-      const sessionIds = Object.keys(storage.sessions);
+      let candidate;
+      const sessionIds = Object.keys(storage.sessions ?? {});
       if (sessionIds.length > 0) {
-        sessionId = sessionIds[0];
+        candidate = sessionIds[0];
+      } else {
+        const planIds = Object.keys(storage.plan ?? {});
+        if (planIds.length > 0) {
+          candidate = planIds[0];
+        } else {
+          const skillsIds = Object.keys(storage.skillsRead ?? {});
+          if (skillsIds.length > 0) {
+            candidate = skillsIds[0];
+          }
+        }
+      }
+      if (candidate) {
+        sessionId = candidate;
         this.sessionId = sessionId;
       }
     }
@@ -2299,24 +2558,25 @@ var DiskSession = class extends MemorySession {
     }
   }
   async loadStorage() {
-    if (existsSync8(this.filePath)) {
+    if (existsSync9(this.filePath)) {
       try {
         const data = await readFile5(this.filePath, "utf-8");
         const parsed = JSON.parse(data);
         parsed.sessions = parsed.sessions || {};
         parsed.skillsRead = parsed.skillsRead || {};
+        parsed.plan = parsed.plan || {};
         return parsed;
       } catch (e) {
         console.error(`Failed to read session file ${this.filePath}:`, e);
       }
     }
-    return { sessions: {}, skillsRead: {} };
+    return { sessions: {}, skillsRead: {}, plan: {} };
   }
   async updateStorage(update) {
     const storage = await this.loadStorage();
     update(storage);
-    const dir = dirname7(this.filePath);
-    if (!existsSync8(dir)) {
+    const dir = dirname8(this.filePath);
+    if (!existsSync9(dir)) {
       await mkdir2(dir, { recursive: true });
     }
     const data = JSON.stringify(storage, null, 2);
@@ -2365,6 +2625,9 @@ var DiskSession = class extends MemorySession {
       if (storage.skillsRead) {
         delete storage.skillsRead[sessionId];
       }
+      if (storage.plan) {
+        delete storage.plan[sessionId];
+      }
     });
   }
   async addSkillRead(skill) {
@@ -2386,6 +2649,28 @@ var DiskSession = class extends MemorySession {
     const storage = await this.loadStorage();
     return storage.skillsRead?.[sessionId] ?? [];
   }
+  async getPlanState() {
+    await this.ready;
+    const sessionId = await this.getSessionId();
+    const storage = await this.loadStorage();
+    return storage.plan?.[sessionId] ?? null;
+  }
+  async setPlanState(state) {
+    await this.ready;
+    const sessionId = await this.getSessionId();
+    await this.updateStorage((storage) => {
+      if (!storage.plan) {
+        storage.plan = {};
+      }
+      const existing = storage.plan[sessionId] ?? { planDescription: "", planItems: [], progress: 0 };
+      storage.plan[sessionId] = {
+        ...existing,
+        ...state,
+        // Ensure arrays/objects are properly merged for planItems
+        planItems: Array.isArray(state.planItems) ? state.planItems : existing.planItems
+      };
+    });
+  }
 };
 
 // utils/sessions/MemoryCompactionSession.ts
@@ -2421,8 +2706,17 @@ function getModelSettings(modelName) {
 
 // utils/sessions/compactConversation.ts
 async function compactConversation(items) {
-  const recentItems = items.slice(-3);
-  const itemsToCompact = items.slice(0, -3);
+  let splitIndex = Math.max(0, items.length - 3);
+  while (splitIndex > 0 && splitIndex < items.length) {
+    const itemAtSplit = items[splitIndex];
+    if (itemAtSplit.type === "function_call_result") {
+      splitIndex--;
+    } else {
+      break;
+    }
+  }
+  const recentItems = items.slice(splitIndex);
+  const itemsToCompact = items.slice(0, splitIndex);
   let noticeContent = "... conversation history compacted ...";
   if (trackedState.compactionModel && itemsToCompact.length > 0) {
     try {
@@ -2430,17 +2724,17 @@ async function compactConversation(items) {
         name: "History Compactor",
         model: isOpenAIModel(trackedState.compactionModel) ? trackedState.compactionModel : getModel(trackedState.compactionModel),
         modelSettings: getModelSettings(trackedState.compactionModel),
-        instructions: "Compact the provided conversation history into key observations. Focus on what seems likely to be needed later. Be concise and avoid repeating information."
+        instructions: "Compact the provided conversation history.\n- Focus on what is NOT completed and needs to be remembered for later.\n- Do NOT include file content or patches, it is available on the filesystem already. \n- Be concise."
       });
+      emitToListeners("SetCompacting", true);
       const result = await run(
         agent,
         itemsToCompact
       );
       const summary = result.finalOutput;
       if (summary && summary.trim().length > 0) {
-        const s = summary.replace(/\s+/g, " ").trim();
         noticeContent = `Key observations from earlier:
-${s}`;
+${summary.trim()}`;
       }
     } catch (err) {
       const msg = String(err?.message || err || "");
@@ -2448,6 +2742,8 @@ ${s}`;
       if (!isNoTrace) {
         console.warn("Compaction summarization failed:", msg);
       }
+    } finally {
+      emitToListeners("SetCompacting", false);
     }
   }
   const itemsToAdd = [system(noticeContent), ...recentItems].filter(excludeFalsy);
@@ -2469,7 +2765,10 @@ function getModelContextLimit(modelName) {
   if (name.startsWith("claude-3.5") || name.startsWith("claude-3")) {
     return 2e5;
   }
-  if (name.startsWith("gemini-1.5")) {
+  if (name.startsWith("claude-4.6") || name.startsWith("claude-4.5")) {
+    return 1e6;
+  }
+  if (name.startsWith("gemini-1.5") || name.startsWith("gemini-3")) {
     return 1e6;
   }
   if (name.startsWith("gemini-")) {
@@ -2493,6 +2792,7 @@ var MemoryCompactionSession = class {
   triggerTokens;
   itemsAddedSinceLastCompaction = 0;
   skillsReadLocal = /* @__PURE__ */ new Set();
+  planStateLocal;
   constructor(options) {
     this.underlyingSession = options.underlyingSession ?? new MemorySession2();
     if (trackedState.compactionModel) {
@@ -2522,11 +2822,68 @@ var MemoryCompactionSession = class {
     const merged = /* @__PURE__ */ new Set([...base, ...this.skillsReadLocal]);
     return Array.from(merged);
   }
+  async getPlanState() {
+    const u = this.underlyingSession;
+    let base = null;
+    if (u && typeof u.getPlanState === "function") {
+      try {
+        base = await Promise.resolve(u.getPlanState());
+      } catch {
+      }
+    }
+    if (this.planStateLocal) {
+      const existing = base ?? { planDescription: "", planItems: [], progress: 0 };
+      const merged = {
+        ...existing,
+        ...this.planStateLocal,
+        planItems: Array.isArray(this.planStateLocal.planItems) ? this.planStateLocal.planItems : existing.planItems
+      };
+      return merged;
+    }
+    return base;
+  }
+  async setPlanState(state) {
+    const u = this.underlyingSession;
+    if (u && typeof u.setPlanState === "function") {
+      try {
+        return await Promise.resolve(u.setPlanState(state));
+      } catch {
+      }
+    }
+    const existing = this.planStateLocal ?? { planDescription: "", planItems: [], progress: 0 };
+    this.planStateLocal = {
+      ...existing,
+      ...state,
+      planItems: Array.isArray(state.planItems) ? state.planItems : existing.planItems
+    };
+  }
   async getItems(limit) {
-    return this.underlyingSession.getItems(limit);
+    const items = await this.underlyingSession.getItems(limit);
+    return items.map((it) => sanitizeItem(it));
+  }
+  /**
+   * Returns the provider-stamped timestamp of the latest-added item, or null when unavailable.
+   * Uses the underlying session directly to access our providerData without sanitation.
+   */
+  async getLatestAddedTimestamp() {
+    const items = await this.underlyingSession.getItems();
+    if (!Array.isArray(items) || items.length === 0) {
+      return null;
+    }
+    const last = items[items.length - 1];
+    const ts = last?.providerData?.harper?.addedAtMs;
+    return typeof ts === "number" && Number.isFinite(ts) ? ts : null;
   }
   async addItems(items) {
-    await this.underlyingSession.addItems(items);
+    const now = Date.now();
+    const stamped = items.map((it) => {
+      const pd = { ...it?.providerData };
+      const ours = { ...pd["harper"] };
+      ours.addedAtMs = now;
+      pd["harper"] = ours;
+      return { ...it, providerData: pd };
+    });
+    await this.underlyingSession.addItems(stamped);
     this.itemsAddedSinceLastCompaction += items.length;
     await this.runCompaction({ reason: "post-add-check", mode: "auto" });
   }
@@ -2552,7 +2909,7 @@ var MemoryCompactionSession = class {
    *   summarized by the model), and retains the last 3 recent items.
    */
   async runCompaction(args) {
-    const items = await this.underlyingSession.getItems();
+    const items = await this.getItems();
     if (items.length <= 1) {
       return null;
     }
@@ -2573,6 +2930,37 @@ var MemoryCompactionSession = class {
     return null;
   }
 };
+function sanitizeItem(it) {
+  if (!it || typeof it !== "object") {
+    return it;
+  }
+  const out = { ...it };
+  if ("harper" in out) {
+    try {
+      delete out.harper;
+    } catch {
+    }
+  }
+  const pd = out.providerData && typeof out.providerData === "object" ? { ...out.providerData } : void 0;
+  if (pd) {
+    if ("harper" in pd) {
+      try {
+        delete pd.harper;
+      } catch {
+      }
+    }
+    if (Object.keys(pd).length === 0) {
+      try {
+        delete out.providerData;
+      } catch {
+        out.providerData = void 0;
+      }
+    } else {
+      out.providerData = pd;
+    }
+  }
+  return out;
+}
 function estimateTokens(items) {
   let chars = 0;
   for (const it of items) {
@@ -2657,54 +3045,48 @@ var ActionsProvider = ({ children }) => {
   return /* @__PURE__ */ jsx2(ActionsContext.Provider, { value, children });
 };
 
-// lifecycle/handleExit.ts
-import { getGlobalTraceProvider } from "@openai/agents";
-async function handleExit() {
-  if (harperProcess.startedInternally) {
-    harperProcess.stop();
-  }
-  await getGlobalTraceProvider().forceFlush();
-  emitToListeners("ExitUI", void 0);
-  process.exit(0);
-}
-
 // utils/sessions/cost.ts
 import chalk2 from "chalk";
 var FLEX_PRICES = {
-  "gpt-5.2": { input: 0.875 / 1e6, cachedInput: 0.0875 / 1e6, output: 7 / 1e6 },
-  "gpt-5.1": { input: 0.625 / 1e6, cachedInput: 0.0625 / 1e6, output: 5 / 1e6 },
   "gpt-5": { input: 0.625 / 1e6, cachedInput: 0.0625 / 1e6, output: 5 / 1e6 },
   "gpt-5-mini": { input: 0.125 / 1e6, cachedInput: 0.0125 / 1e6, output: 1 / 1e6 },
   "gpt-5-nano": { input: 0.025 / 1e6, cachedInput: 25e-4 / 1e6, output: 0.2 / 1e6 },
+  "gpt-5.1": { input: 0.625 / 1e6, cachedInput: 0.0625 / 1e6, output: 5 / 1e6 },
+  "gpt-5.2": { input: 0.875 / 1e6, cachedInput: 0.0875 / 1e6, output: 7 / 1e6 },
   "o3": { input: 1 / 1e6, cachedInput: 0.25 / 1e6, output: 4 / 1e6 },
   "o4-mini": { input: 0.55 / 1e6, cachedInput: 0.138 / 1e6, output: 2.2 / 1e6 }
 };
 var STANDARD_PRICES = {
-  "gpt-5.2": { input: 1.75 / 1e6, cachedInput: 0.175 / 1e6, output: 14 / 1e6 },
-  "gpt-5.1": { input: 1.25 / 1e6, cachedInput: 0.125 / 1e6, output: 10 / 1e6 },
+  "gpt-4o": { input: 2.5 / 1e6, cachedInput: 1.25 / 1e6, output: 10 / 1e6 },
+  "gpt-4o-2024-05-13": { input: 5 / 1e6, cachedInput: 5 / 1e6, output: 15 / 1e6 },
+  "gpt-4o-mini": { input: 0.15 / 1e6, cachedInput: 0.075 / 1e6, output: 0.6 / 1e6 },
   "gpt-5": { input: 1.25 / 1e6, cachedInput: 0.125 / 1e6, output: 10 / 1e6 },
+  "gpt-5-chat-latest": { input: 1.25 / 1e6, cachedInput: 0.125 / 1e6, output: 10 / 1e6 },
+  "gpt-5-codex": { input: 1.25 / 1e6, cachedInput: 0.125 / 1e6, output: 10 / 1e6 },
   "gpt-5-mini": { input: 0.25 / 1e6, cachedInput: 0.025 / 1e6, output: 2 / 1e6 },
   "gpt-5-nano": { input: 0.05 / 1e6, cachedInput: 5e-3 / 1e6, output: 0.4 / 1e6 },
-  "gpt-5.2-chat-latest": { input: 1.75 / 1e6, cachedInput: 0.175 / 1e6, output: 14 / 1e6 },
-  "gpt-5.1-chat-latest": { input: 1.25 / 1e6, cachedInput: 0.125 / 1e6, output: 10 / 1e6 },
-  "gpt-5-chat-latest": { input: 1.25 / 1e6, cachedInput: 0.125 / 1e6, output: 10 / 1e6 },
-  "gpt-5.2-pro": { input: 21 / 1e6, cachedInput: 21 / 1e6, output: 168 / 1e6 },
   "gpt-5-pro": { input: 15 / 1e6, cachedInput: 15 / 1e6, output: 120 / 1e6 },
   "gpt-4.1": { input: 2 / 1e6, cachedInput: 0.5 / 1e6, output: 8 / 1e6 },
   "gpt-4.1-mini": { input: 0.4 / 1e6, cachedInput: 0.1 / 1e6, output: 1.6 / 1e6 },
   "gpt-4.1-nano": { input: 0.1 / 1e6, cachedInput: 0.025 / 1e6, output: 0.4 / 1e6 },
-  "gpt-4o": { input: 2.5 / 1e6, cachedInput: 1.25 / 1e6, output: 10 / 1e6 },
-  "gpt-4o-2024-05-13": { input: 5 / 1e6, cachedInput: 5 / 1e6, output: 15 / 1e6 },
-  "gpt-4o-mini": { input: 0.15 / 1e6, cachedInput: 0.075 / 1e6, output: 0.6 / 1e6 },
+  "gpt-5.1": { input: 1.25 / 1e6, cachedInput: 0.125 / 1e6, output: 10 / 1e6 },
+  "gpt-5.1-chat-latest": { input: 1.25 / 1e6, cachedInput: 0.125 / 1e6, output: 10 / 1e6 },
+  "gpt-5.1-codex": { input: 1.25 / 1e6, cachedInput: 0.125 / 1e6, output: 10 / 1e6 },
+  "gpt-5.1-codex-max": { input: 1.25 / 1e6, cachedInput: 0.125 / 1e6, output: 10 / 1e6 },
+  "gpt-5.2": { input: 1.75 / 1e6, cachedInput: 0.175 / 1e6, output: 14 / 1e6 },
+  "gpt-5.2-chat-latest": { input: 1.75 / 1e6, cachedInput: 0.175 / 1e6, output: 14 / 1e6 },
+  "gpt-5.2-codex": { input: 1.75 / 1e6, cachedInput: 0.175 / 1e6, output: 14 / 1e6 },
+  "gpt-5.2-pro": { input: 21 / 1e6, cachedInput: 21 / 1e6, output: 168 / 1e6 },
+  "gpt-5.3-codex": { input: 1.75 / 1e6, cachedInput: 0.175 / 1e6, output: 14 / 1e6 },
   "o1": { input: 15 / 1e6, cachedInput: 7.5 / 1e6, output: 60 / 1e6 },
+  "o1-mini": { input: 1.1 / 1e6, cachedInput: 0.55 / 1e6, output: 4.4 / 1e6 },
   "o1-pro": { input: 150 / 1e6, cachedInput: 150 / 1e6, output: 600 / 1e6 },
-  "o3-pro": { input: 20 / 1e6, cachedInput: 20 / 1e6, output: 80 / 1e6 },
   "o3": { input: 2 / 1e6, cachedInput: 0.5 / 1e6, output: 8 / 1e6 },
   "o3-deep-research": { input: 10 / 1e6, cachedInput: 2.5 / 1e6, output: 40 / 1e6 },
-  "o4-mini": { input: 1.1 / 1e6, cachedInput: 0.275 / 1e6, output: 4.4 / 1e6 },
-  "o4-mini-deep-research": { input: 2 / 1e6, cachedInput: 0.5 / 1e6, output: 8 / 1e6 },
   "o3-mini": { input: 1.1 / 1e6, cachedInput: 0.55 / 1e6, output: 4.4 / 1e6 },
-  "o1-mini": { input: 1.1 / 1e6, cachedInput: 0.55 / 1e6, output: 4.4 / 1e6 }
+  "o3-pro": { input: 20 / 1e6, cachedInput: 20 / 1e6, output: 80 / 1e6 },
+  "o4-mini": { input: 1.1 / 1e6, cachedInput: 0.275 / 1e6, output: 4.4 / 1e6 },
+  "o4-mini-deep-research": { input: 2 / 1e6, cachedInput: 0.5 / 1e6, output: 8 / 1e6 }
 };
 var MODEL_PRICES = {
   flex: FLEX_PRICES,
@@ -2842,64 +3224,6 @@ 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) {
@@ -2948,7 +3272,7 @@ Last tool call: ${lastToolCallInfo}` : "";
 }
 
 // agent/runAgentForOnePass.ts
-async function runAgentForOnePass(agent, session, input, controller) {
+async function runAgentForOnePass(agent, session, input, controller, isPrompt) {
   let lastToolCallInfo = null;
   const toolInfoMap = /* @__PURE__ */ new Map();
   const removeToolListener = addListener("RegisterToolInfo", (info) => {
@@ -2958,9 +3282,9 @@ async function runAgentForOnePass(agent, session, input, controller) {
     let hasStartedResponse = false;
     let adjustedInput = input;
     const noPlanYet = globalPlanContext.planItems.length === 0 && (!globalPlanContext.planDescription || globalPlanContext.planDescription.trim().length === 0);
-    if (noPlanYet && (typeof input === "string" || Array.isArray(input))) {
+    if (noPlanYet && typeof input === "string") {
       const planningInstruction = [
-        "If there is no current plan, first establish one and keep it updated:",
+        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:",
         "- Use the tools to manage the plan:",
         "  \u2022 set_plan_description(description)",
         "  \u2022 set_plan_items(items: string[])",
@@ -2969,14 +3293,10 @@ async function runAgentForOnePass(agent, session, input, controller) {
         "- 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];
-      }
+      adjustedInput = [
+        system2(planningInstruction),
+        { type: "message", role: "user", content: input }
+      ];
     }
     const stream = await run2(agent, adjustedInput, {
       session,
@@ -2984,6 +3304,49 @@ async function runAgentForOnePass(agent, session, input, controller) {
       signal: controller.signal,
       maxTurns: trackedState.maxTurns
     });
+    const pushNewItemsIntoSession = async () => {
+      const newItems = stream.newItems.filter((item) => {
+        if ("status" in item) {
+          return item.status === "completed";
+        }
+        return true;
+      }).map((item) => {
+        const json = typeof item.toJSON === "function" ? item.toJSON() : item;
+        if (json && typeof json === "object" && "rawItem" in json) {
+          return json.rawItem;
+        }
+        return json;
+      });
+      const itemsToPush = [];
+      const callIds = /* @__PURE__ */ new Set();
+      const resultIds = /* @__PURE__ */ new Set();
+      for (const item of newItems) {
+        if (item.type === "function_call") {
+          callIds.add(item.callId);
+        } else if (item.type === "function_call_result") {
+          resultIds.add(item.callId);
+        }
+      }
+      const existingItems = await session.getItems();
+      for (const item of existingItems) {
+        if (item.type === "function_call") {
+          callIds.add(item.callId);
+        } else if (item.type === "function_call_result") {
+          resultIds.add(item.callId);
+        }
+      }
+      for (const item of newItems) {
+        if (item.type === "function_call" || item.type === "function_call_result") {
+          if (!callIds.has(item.callId) || !resultIds.has(item.callId)) {
+            continue;
+          }
+        }
+        itemsToPush.push(item);
+      }
+      if (itemsToPush.length > 0) {
+        await session.addItems(itemsToPush);
+      }
+    };
     for await (const event of stream) {
       if (trackedState.monitorRateLimits) {
         const { requests, tokens } = rateLimitTracker.isApproachingLimit(trackedState.rateLimitThreshold);
@@ -3015,9 +3378,8 @@ async function runAgentForOnePass(agent, session, input, controller) {
               text: "Operation canceled due to rate limits.",
               version: 1
             }]);
-            if (controller) {
-              controller.abort();
-            }
+            await pushNewItemsIntoSession();
+            controller.abort();
             process.exitCode = 1;
             await handleExit();
           }
@@ -3089,6 +3451,21 @@ async function runAgentForOnePass(agent, session, input, controller) {
             cachedInputTokens: sessionStats2.cachedInputTokens + costTracker.extractCachedTokens(stream.state.usage.inputTokensDetails),
             hasUnknownPrices: sessionStats2.hasUnknownPrices
           });
+          if (trackedState.currentTurn !== stream.state._currentTurn || trackedState.maxTurns !== stream.state._maxTurns) {
+            trackedState.currentTurn = stream.state._currentTurn;
+            trackedState.maxTurns = stream.state._maxTurns;
+            emitToListeners("SettingsUpdated", void 0);
+            if (trackedState.currentTurn + 1 >= trackedState.maxTurns) {
+              await pushNewItemsIntoSession();
+              emitToListeners("PushNewMessages", [{
+                type: "interrupted",
+                text: `- max turns reached${trackedState.autonomous ? ", thinking for a moment" : ""} -`,
+                version: 1
+              }]);
+              controller.abort();
+              return null;
+            }
+          }
           break;
         case "run_item_stream_event":
           if (event.name === "tool_called") {
@@ -3124,8 +3501,8 @@ async function runAgentForOnePass(agent, session, input, controller) {
       if (trackedState.maxCost !== null) {
         const estimatedTotalCost2 = costTracker.getEstimatedTotalCost(
           stream.state.usage,
-          trackedState.model || "gpt-5.2",
-          trackedState.compactionModel || "gpt-4o-mini"
+          trackedState.model,
+          trackedState.compactionModel
         );
         if (estimatedTotalCost2 > trackedState.maxCost) {
           emitToListeners("SetInputMode", "denied");
@@ -3136,9 +3513,8 @@ async function runAgentForOnePass(agent, session, input, controller) {
             text: `Cost limit exceeded: $${estimatedTotalCost2.toFixed(4)} > $${trackedState.maxCost.toFixed(4)}`,
             version: 1
           }]);
-          if (controller) {
-            controller.abort();
-          }
+          await pushNewItemsIntoSession();
+          controller.abort();
           process.exitCode = 1;
           await handleExit();
         }
@@ -3157,6 +3533,9 @@ async function runAgentForOnePass(agent, session, input, controller) {
       cachedInputTokens: sessionStats.cachedInputTokens + costTracker.extractCachedTokens(stream.state.usage.inputTokensDetails),
       hasUnknownPrices: sessionStats.hasUnknownPrices
     });
+    trackedState.currentTurn = stream.state._currentTurn;
+    trackedState.maxTurns = stream.state._maxTurns;
+    emitToListeners("SettingsUpdated", void 0);
     if (stream.interruptions?.length) {
       emitToListeners("SetThinking", false);
       emitToListeners("SetInputMode", "approving");
@@ -3237,6 +3616,22 @@ async function runAgentForOnePass(agent, session, input, controller) {
     removeToolListener();
     return null;
   } catch (error) {
+    if (error?.name?.includes("MaxTurnsExceededError")) {
+      emitToListeners("PushNewMessages", [{
+        type: "interrupted",
+        text: `Max turns exceeded. Please ask me to continue or pivot.`,
+        version: 1
+      }]);
+      return null;
+    }
+    if (error?.name?.includes("rate_limit_exceeded")) {
+      emitToListeners("PushNewMessages", [{
+        type: "interrupted",
+        text: `Rate limit reached. Please ask me to continue in a few minutes.`,
+        version: 1
+      }]);
+      return null;
+    }
     showErrorToUser(error, lastToolCallInfo);
     return null;
   }
@@ -3247,6 +3642,7 @@ var AgentManager = class {
   isInitialized = false;
   controller = null;
   queuedUserInputs = [];
+  resumeState = null;
   agent = null;
   session = null;
   initialMessages = [];
@@ -3254,14 +3650,55 @@ var AgentManager = class {
     if (this.isInitialized) {
       return;
     }
-    this.agent = new Agent3({
-      name: "Harper Agent",
-      model: isOpenAIModel(trackedState.model) ? trackedState.model : getModel(trackedState.model),
-      modelSettings: getModelSettings(trackedState.model),
-      instructions: readAgentsMD() || defaultInstructions(),
-      tools: createTools()
-    });
-    this.session = createSession(trackedState.sessionPath);
+    this.agent = new Agent3({
+      name: "Harper Agent",
+      model: isOpenAIModel(trackedState.model) ? trackedState.model : getModel(trackedState.model),
+      modelSettings: getModelSettings(trackedState.model),
+      instructions: readAgentsMD() || defaultInstructions(),
+      tools: createTools()
+    });
+    this.session = createSession(trackedState.sessionPath);
+    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) {
@@ -3329,12 +3766,54 @@ var AgentManager = class {
       this.queuedUserInputs.push(text);
     }
   }
-  async runTask(task) {
+  async runTask(task, isPrompt) {
     this.controller = new AbortController();
+    await this.runCompactionIfWeWereIdle();
     emitToListeners("SetThinking", true);
     let taskOrState = task;
+    const lowerTask = task.toLowerCase();
+    if (this.resumeState && (lowerTask.includes("continue") || lowerTask.includes("keep going") || lowerTask.includes("more") || lowerTask === "y" || lowerTask === "yes")) {
+      taskOrState = this.resumeState;
+      this.resumeState = null;
+    } else {
+      this.resumeState = null;
+    }
     while (taskOrState) {
-      taskOrState = await runAgentForOnePass(this.agent, this.session, taskOrState, this.controller);
+      taskOrState = await runAgentForOnePass(this.agent, this.session, taskOrState, this.controller, isPrompt);
+      if (taskOrState && !trackedState.autonomous) {
+        if (taskOrState.getInterruptions().length === 0) {
+          this.resumeState = taskOrState;
+          emitToListeners("SetThinking", false);
+          emitToListeners("PushNewMessages", [{
+            type: "interrupted",
+            text: `Would you like me to continue?`,
+            version: 1
+          }]);
+          break;
+        }
+      }
+      if (trackedState.autonomous && !this.resumeState) {
+        const planItems = globalPlanContext.planItems;
+        const hasPlan = planItems.length > 0;
+        const allDone = hasPlan && planItems.every((item) => item.status === "done" || item.status === "not-needed");
+        if (allDone) {
+          emitToListeners("SetThinking", false);
+          emitToListeners("PushNewMessages", [{
+            type: "agent",
+            text: "Plan 100% accomplished. Exiting autonomous mode.",
+            version: 1
+          }]);
+          await sleep(1e3);
+          await handleExit();
+        } else {
+          await sleep(1e3);
+          await this.session?.runCompaction({ force: true });
+          trackedState.currentTurn = 0;
+          this.resumeState = null;
+          this.controller = new AbortController();
+          taskOrState = "Keep going";
+        }
+      }
     }
     emitToListeners("SetThinking", false);
     if (this.queuedUserInputs.length > 0) {
@@ -3342,6 +3821,22 @@ var AgentManager = class {
       void this.runTask(batched);
     }
   }
+  async runCompactionIfWeWereIdle() {
+    if (this.session) {
+      const lastTs = await this.session.getLatestAddedTimestamp();
+      if (typeof lastTs === "number" && Number.isFinite(lastTs)) {
+        const ONE_HOUR_MS = 60 * 60 * 1e3;
+        const idleMs = Date.now() - lastTs;
+        if (idleMs > ONE_HOUR_MS) {
+          try {
+            await this.session.runCompaction({ force: true });
+          } catch (err) {
+            logError(err);
+          }
+        }
+      }
+    }
+  }
   interrupt() {
     if (this.controller) {
       this.controller.abort();
@@ -3357,7 +3852,7 @@ 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 useCallback4, useEffect as useEffect8, useMemo as useMemo10, useRef as useRef2, useState as useState13 } from "react";
+import React11, { useCallback as useCallback5, useEffect as useEffect8, useMemo as useMemo11, useRef as useRef2, useState as useState14 } from "react";
 
 // ink/contexts/ChatContext.tsx
 import { createContext as createContext3, useContext as useContext3, useMemo as useMemo3, useState as useState3 } from "react";
@@ -3392,6 +3887,7 @@ var ChatProvider = ({
   const [messages, setMessages] = useState3(getInitialMessages());
   const [userInputMode, setUserInputMode] = useState3("waiting");
   const [isThinking, setIsThinking] = useState3(false);
+  const [isCompacting, setIsCompacting] = useState3(false);
   const [focusedArea, setFocusedArea] = useState3("input");
   useListener("PushNewMessages", (messages2) => {
     setMessages((prev) => {
@@ -3406,6 +3902,9 @@ var ChatProvider = ({
   useListener("SetThinking", (value2) => {
     setIsThinking(Boolean(value2));
   }, []);
+  useListener("SetCompacting", (value2) => {
+    setIsCompacting(Boolean(value2));
+  }, []);
   useListener("InterruptThought", () => {
     setIsThinking(false);
   }, []);
@@ -3433,9 +3932,10 @@ var ChatProvider = ({
     messages,
     userInputMode,
     isThinking,
+    isCompacting,
     focusedArea,
     setFocusedArea
-  }), [messages, userInputMode, isThinking, focusedArea]);
+  }), [messages, userInputMode, isThinking, isCompacting, focusedArea]);
   return /* @__PURE__ */ jsx3(ChatContext.Provider, { value, children });
 };
 
@@ -3447,7 +3947,6 @@ function useMessageListener() {
     agentManager.interrupt();
     emitToListeners("PushNewMessages", [
       {
-        id: Date.now(),
         type: "interrupted",
         text: "- thought interrupted -",
         version: 1
@@ -3456,7 +3955,7 @@ function useMessageListener() {
   }, []);
   useListener("PushNewMessages", async (messages) => {
     for (const message of messages) {
-      if (message.type === "user" && message.text) {
+      if ((message.type === "user" || message.type === "prompt") && message.text) {
         const lowerText = message.text.toLowerCase();
         if (lowerText === "exit" || lowerText === "bye") {
           await handleExit();
@@ -3473,7 +3972,7 @@ function useMessageListener() {
           agentManager.enqueueUserInput(message.text);
           message.handled = true;
         } else if (!message.handled) {
-          void agentManager.runTask(message.text);
+          void agentManager.runTask(message.text, message.type === "prompt");
         }
       }
     }
@@ -3483,12 +3982,102 @@ function useMessageListener() {
 // ink/constants/footerHeight.ts
 var footerHeight = 2;
 
+// ink/contexts/ApprovalContext.tsx
+import { createContext as createContext4, useCallback as useCallback2, useContext as useContext4, useMemo as useMemo4, useState as useState4 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var ApprovalContext = createContext4(void 0);
+var useApproval = () => {
+  const context = useContext4(ApprovalContext);
+  if (!context) {
+    throw new Error("useApproval must be used within an ApprovalProvider");
+  }
+  return context;
+};
+var ApprovalProvider = ({ children }) => {
+  const [payload, setPayload] = useState4(null);
+  const [toolInfos] = useState4(/* @__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("RegisterToolInfo", (info) => {
+    registerToolInfo(info);
+  }, [registerToolInfo]);
+  useListener("CloseApprovalViewer", () => {
+    setPayload(null);
+  }, []);
+  const value = useMemo4(() => ({
+    payload,
+    setPayload,
+    registerToolInfo
+  }), [payload, registerToolInfo]);
+  return /* @__PURE__ */ jsx4(ApprovalContext.Provider, { value, children });
+};
+
+// ink/contexts/PlanContext.tsx
+import { createContext as createContext5, useContext as useContext5, useMemo as useMemo5, useState as useState5 } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var PlanContext = createContext5(globalPlanContext);
+var usePlan = () => {
+  const context = useContext5(PlanContext);
+  if (!context) {
+    throw new Error("usePlan must be used within a PlanProvider");
+  }
+  return context;
+};
+var PlanProvider = ({
+  children
+}) => {
+  const [planDescription, setPlanDescription] = useState5(globalPlanContext.planDescription);
+  const [planItems, setPlanItems] = useState5(globalPlanContext.planItems);
+  const [progress, setProgress] = useState5(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 = useMemo5(() => ({
+    progress,
+    planDescription,
+    planItems
+  }), [progress, planDescription, planItems]);
+  return /* @__PURE__ */ jsx5(PlanContext.Provider, { value, children });
+};
+
 // ink/library/useTerminalSize.ts
 import { useStdout } from "ink";
-import { useEffect as useEffect3, useState as useState4 } from "react";
+import { useEffect as useEffect3, useState as useState6 } from "react";
 function useTerminalSize() {
   const { stdout } = useStdout();
-  const [size, setSize] = useState4({
+  const [size, setSize] = useState6({
     rows: stdout?.rows ?? 24,
     columns: stdout?.columns ?? 80
   });
@@ -3559,18 +4148,18 @@ function wrapText(text, width) {
 
 // ink/components/ActionsView.tsx
 import { Box as Box3, Text as Text3, useInput } from "ink";
-import { useCallback as useCallback2, useEffect as useEffect5, useState as useState6 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect5, useState as useState8 } from "react";
 
 // ink/components/ActionItemRow.tsx
 import { Spinner } from "@inkjs/ui";
 import { Box, Text } from "ink";
 import { memo } from "react";
-import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+import { jsx as jsx6, 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__ */ jsx4(Text, { color: isSelected ? selectionColor : "gray", bold: isSelected, children: isSelected ? "\u2503  " : "\u2502  " });
+    const pipe = /* @__PURE__ */ jsx6(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;
@@ -3588,24 +4177,24 @@ var ActionItemRow = memo(
     return /* @__PURE__ */ jsxs(Box, { children: [
       pipe,
       /* @__PURE__ */ jsxs(Box, { flexGrow: 1, children: [
-        /* @__PURE__ */ jsx4(Text, { color: statusColor, bold: true, children: item.title }),
+        /* @__PURE__ */ jsx6(Text, { color: statusColor, bold: true, children: item.title }),
         /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
           " ",
           displayedDetail
         ] })
       ] }),
-      /* @__PURE__ */ jsx4(Box, { children: item.running ? /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx4(Text, { color: "yellow" }),
-        /* @__PURE__ */ jsx4(Spinner, { type: "dots" })
-      ] }) : /* @__PURE__ */ jsx4(Text, { color: statusColor, bold: true, children: statusLabel }) })
+      /* @__PURE__ */ jsx6(Box, { children: item.running ? /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx6(Text, { color: "yellow" }),
+        /* @__PURE__ */ jsx6(Spinner, { type: "dots" })
+      ] }) : /* @__PURE__ */ jsx6(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 useMemo4, useRef, useState as useState5 } from "react";
-import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+import { forwardRef, useEffect as useEffect4, useImperativeHandle, useMemo as useMemo6, useRef, useState as useState7 } from "react";
+import { jsx as jsx7, 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")) {
@@ -3635,7 +4224,7 @@ var VirtualListInner = (props, ref) => {
     onViewportChange
   } = props;
   const { rows: terminalRows } = useTerminalSize();
-  const resolvedHeight = useMemo4(() => {
+  const resolvedHeight = useMemo6(() => {
     if (typeof propHeight === "number") {
       return propHeight;
     }
@@ -3645,7 +4234,7 @@ var VirtualListInner = (props, ref) => {
     }
     return Math.max(1, terminalRows - reservedLines);
   }, [propHeight, terminalRows, reservedLines]);
-  const getItemHeight = useMemo4(() => {
+  const getItemHeight = useMemo6(() => {
     if (getItemHeightProp) {
       return getItemHeightProp;
     }
@@ -3656,14 +4245,14 @@ var VirtualListInner = (props, ref) => {
   }, [getItemHeightProp, fixedItemHeight]);
   const indicatorLines = showOverflowIndicators ? 2 : 0;
   const availableHeight = Math.max(0, resolvedHeight - indicatorLines);
-  const [viewportOffset, setViewportOffset] = useState5(0);
+  const [viewportOffset, setViewportOffset] = useState7(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 } = useMemo4(() => {
+  const { visibleCount, visibleItems } = useMemo6(() => {
     if (availableHeight <= 0) {
       return { visibleCount: 0, visibleItems: [] };
     }
@@ -3728,7 +4317,7 @@ var VirtualListInner = (props, ref) => {
       }
     }
   }, [clampedSelectedIndex, items, availableHeight, getItemHeight, visibleCount]);
-  const viewport = useMemo4(
+  const viewport = useMemo6(
     () => ({
       offset: viewportOffset,
       visibleCount,
@@ -3860,7 +4449,7 @@ var VirtualListInner = (props, ref) => {
     if (count < overflowIndicatorThreshold) {
       return null;
     }
-    return /* @__PURE__ */ jsx5(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+    return /* @__PURE__ */ jsx7(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
       "\u25B2 ",
       count,
       " more"
@@ -3870,7 +4459,7 @@ var VirtualListInner = (props, ref) => {
     if (count < overflowIndicatorThreshold) {
       return null;
     }
-    return /* @__PURE__ */ jsx5(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+    return /* @__PURE__ */ jsx7(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
       "\u25BC ",
       count,
       " more"
@@ -3879,7 +4468,7 @@ var VirtualListInner = (props, ref) => {
   const topIndicator = renderOverflowTop ?? defaultOverflowTop;
   const bottomIndicator = renderOverflowBottom ?? defaultOverflowBottom;
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", height: resolvedHeight, children: [
-    showOverflowIndicators && /* @__PURE__ */ jsx5(Box2, { height: 1, children: topIndicator(overflowTop) }),
+    showOverflowIndicators && /* @__PURE__ */ jsx7(Box2, { height: 1, children: topIndicator(overflowTop) }),
     /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexGrow: 1, children: [
       visibleItems.map((item, idx) => {
         const actualIndex = viewportOffset + idx;
@@ -3889,20 +4478,20 @@ var VirtualListInner = (props, ref) => {
           index: actualIndex,
           isSelected: actualIndex === clampedSelectedIndex
         };
-        return /* @__PURE__ */ jsx5(Box2, { height: getItemHeight(item, actualIndex), overflow: "hidden", children: renderItem(itemProps) }, key);
+        return /* @__PURE__ */ jsx7(Box2, { height: getItemHeight(item, actualIndex), overflow: "hidden", children: renderItem(itemProps) }, key);
       }),
-      renderFiller && hSum < availableHeight && /* @__PURE__ */ jsx5(Box2, { flexDirection: "column", flexGrow: 1, children: renderFiller(availableHeight - hSum) })
+      renderFiller && hSum < availableHeight && /* @__PURE__ */ jsx7(Box2, { flexDirection: "column", flexGrow: 1, children: renderFiller(availableHeight - hSum) })
     ] }),
-    showOverflowIndicators && /* @__PURE__ */ jsx5(Box2, { height: 1, children: bottomIndicator(overflowBottom) })
+    showOverflowIndicators && /* @__PURE__ */ jsx7(Box2, { height: 1, children: bottomIndicator(overflowBottom) })
   ] });
 };
 var VirtualList = forwardRef(VirtualListInner);
 
 // ink/components/ActionsView.tsx
-import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs3 } from "react/jsx-runtime";
 function ActionsView({ height, isFocused }) {
   const { actions } = useActions();
-  const [selectedIndex, setSelectedIndex] = useState6(0);
+  const [selectedIndex, setSelectedIndex] = useState8(0);
   const size = useTerminalSize();
   const timelineWidth = Math.floor(size.columns * 0.65);
   const statusWidth = size.columns - timelineWidth;
@@ -3935,8 +4524,8 @@ function ActionsView({ height, isFocused }) {
       }
     }
   });
-  const renderOverflowTop = useCallback2((count) => /* @__PURE__ */ jsxs3(Box3, { children: [
-    /* @__PURE__ */ jsx6(Text3, { color: "gray", dimColor: true, children: "\u2502" }),
+  const renderOverflowTop = useCallback3((count) => /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx8(Text3, { color: "gray", dimColor: true, children: "\u2502" }),
     count > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
       " ",
       "\u25B2 ",
@@ -3944,8 +4533,8 @@ function ActionsView({ height, isFocused }) {
       " more"
     ] })
   ] }), []);
-  const renderOverflowBottom = useCallback2((count) => /* @__PURE__ */ jsxs3(Box3, { children: [
-    /* @__PURE__ */ jsx6(Text3, { color: "gray", dimColor: true, children: "\u2502" }),
+  const renderOverflowBottom = useCallback3((count) => /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx8(Text3, { color: "gray", dimColor: true, children: "\u2502" }),
     count > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
       " ",
       "\u25BC ",
@@ -3953,15 +4542,15 @@ function ActionsView({ height, isFocused }) {
       " more"
     ] })
   ] }), []);
-  const renderFiller = useCallback2((h) => /* @__PURE__ */ jsx6(Box3, { flexDirection: "column", children: Array.from({ length: h }).map((_, i) => /* @__PURE__ */ jsx6(Box3, { children: /* @__PURE__ */ jsx6(Text3, { color: "gray", dimColor: true, children: "\u2502" }) }, i)) }), []);
-  const getItemHeight = useCallback2((_item) => 1, []);
+  const renderFiller = useCallback3((h) => /* @__PURE__ */ jsx8(Box3, { flexDirection: "column", children: Array.from({ length: h }).map((_, i) => /* @__PURE__ */ jsx8(Box3, { children: /* @__PURE__ */ jsx8(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__ */ jsx6(Box3, { children: /* @__PURE__ */ jsx6(Text3, { italic: true, color: "gray", children: "No actions yet." }) }),
-      Array.from({ length: height - 1 }).map((_, i) => /* @__PURE__ */ jsx6(Box3, { children: /* @__PURE__ */ jsx6(Text3, {}) }, i))
+      /* @__PURE__ */ jsx8(Box3, { children: /* @__PURE__ */ jsx8(Text3, { italic: true, color: "gray", children: "No actions yet." }) }),
+      Array.from({ length: height - 1 }).map((_, i) => /* @__PURE__ */ jsx8(Box3, { children: /* @__PURE__ */ jsx8(Text3, {}) }, i))
     ] });
   }
-  return /* @__PURE__ */ jsx6(Box3, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsx8(Box3, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx8(
     VirtualList,
     {
       items: actions,
@@ -3971,7 +4560,7 @@ function ActionsView({ height, isFocused }) {
       renderOverflowTop,
       renderOverflowBottom,
       renderFiller,
-      renderItem: ({ item, isSelected }) => /* @__PURE__ */ jsx6(ActionItemRow, { item, isSelected, isFocused, width: statusWidth - 2 })
+      renderItem: ({ item, isSelected }) => /* @__PURE__ */ jsx8(ActionItemRow, { item, isSelected, isFocused, width: statusWidth - 2 })
     }
   ) });
 }
@@ -3981,11 +4570,11 @@ import { Box as Box4, Text as Text4 } from "ink";
 import "react";
 
 // ink/contexts/CostContext.tsx
-import { createContext as createContext4, useContext as useContext4, useMemo as useMemo5, useState as useState7 } from "react";
-import { jsx as jsx7 } from "react/jsx-runtime";
-var CostContext = createContext4(void 0);
+import { createContext as createContext6, useContext as useContext6, useMemo as useMemo7, useState as useState9 } from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var CostContext = createContext6(void 0);
 var useCost = () => {
-  const context = useContext4(CostContext);
+  const context = useContext6(CostContext);
   if (!context) {
     throw new Error("useCost must be used within a CostProvider");
   }
@@ -3994,7 +4583,7 @@ var useCost = () => {
 var CostProvider = ({
   children
 }) => {
-  const [cost, setCost] = useState7({
+  const [cost, setCost] = useState9({
     totalCost: 0,
     inputTokens: 0,
     outputTokens: 0,
@@ -4004,37 +4593,37 @@ var CostProvider = ({
   useListener("UpdateCost", (newCost) => {
     setCost(newCost);
   }, []);
-  const value = useMemo5(() => ({
+  const value = useMemo7(() => ({
     cost
   }), [cost]);
-  return /* @__PURE__ */ jsx7(CostContext.Provider, { value, children });
+  return /* @__PURE__ */ jsx9(CostContext.Provider, { value, children });
 };
 
 // ink/components/CostView.tsx
-import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx10, 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__ */ jsx8(Box4, { marginBottom: isDense ? 0 : 1, children: /* @__PURE__ */ jsx8(Text4, { bold: true, underline: true, color: "cyan", children: "Session Cost Breakdown" }) }),
+    /* @__PURE__ */ jsx10(Box4, { marginBottom: isDense ? 0 : 1, children: /* @__PURE__ */ jsx10(Text4, { bold: true, underline: true, color: "cyan", children: "Session Cost Breakdown" }) }),
     /* @__PURE__ */ jsxs4(Box4, { children: [
-      /* @__PURE__ */ jsx8(Box4, { width: 20, children: /* @__PURE__ */ jsx8(Text4, { children: "Total Cost:" }) }),
+      /* @__PURE__ */ jsx10(Box4, { width: 20, children: /* @__PURE__ */ jsx10(Text4, { children: "Total Cost:" }) }),
       /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
         "$",
         cost.totalCost.toFixed(4)
       ] }),
-      cost.hasUnknownPrices && /* @__PURE__ */ jsx8(Text4, { color: "yellow", children: "(est.)" })
+      cost.hasUnknownPrices && /* @__PURE__ */ jsx10(Text4, { color: "yellow", children: "(est.)" })
     ] }),
     /* @__PURE__ */ jsxs4(Box4, { children: [
-      /* @__PURE__ */ jsx8(Box4, { width: 20, children: /* @__PURE__ */ jsx8(Text4, { children: "Input Tokens:" }) }),
-      /* @__PURE__ */ jsx8(Text4, { children: cost.inputTokens.toLocaleString() })
+      /* @__PURE__ */ jsx10(Box4, { width: 20, children: /* @__PURE__ */ jsx10(Text4, { children: "Input Tokens:" }) }),
+      /* @__PURE__ */ jsx10(Text4, { children: cost.inputTokens.toLocaleString() })
     ] }),
     /* @__PURE__ */ jsxs4(Box4, { children: [
-      /* @__PURE__ */ jsx8(Box4, { width: 20, children: /* @__PURE__ */ jsx8(Text4, { children: "Cached Tokens:" }) }),
-      /* @__PURE__ */ jsx8(Text4, { color: "gray", children: cost.cachedInputTokens.toLocaleString() })
+      /* @__PURE__ */ jsx10(Box4, { width: 20, children: /* @__PURE__ */ jsx10(Text4, { children: "Cached Tokens:" }) }),
+      /* @__PURE__ */ jsx10(Text4, { color: "gray", children: cost.cachedInputTokens.toLocaleString() })
     ] }),
     /* @__PURE__ */ jsxs4(Box4, { children: [
-      /* @__PURE__ */ jsx8(Box4, { width: 20, children: /* @__PURE__ */ jsx8(Text4, { children: "Output Tokens:" }) }),
-      /* @__PURE__ */ jsx8(Text4, { children: cost.outputTokens.toLocaleString() })
+      /* @__PURE__ */ jsx10(Box4, { width: 20, children: /* @__PURE__ */ jsx10(Text4, { children: "Output Tokens:" }) }),
+      /* @__PURE__ */ jsx10(Text4, { children: cost.outputTokens.toLocaleString() })
     ] })
   ] });
 }
@@ -4042,7 +4631,7 @@ function CostView({ isDense = false }) {
 // ink/components/MessageLineItem.tsx
 import { Box as Box5, Text as Text5 } from "ink";
 import { memo as memo2 } from "react";
-import { Fragment, jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx11, jsxs as jsxs5 } from "react/jsx-runtime";
 var MessageLineItem = memo2(
   ({
     item,
@@ -4054,22 +4643,23 @@ var MessageLineItem = memo2(
     const label = item.type === "interrupted" ? "" : item.type.toUpperCase();
     const selectionColor = isFocused ? "cyan" : "gray";
     return /* @__PURE__ */ jsxs5(Box5, { children: [
-      /* @__PURE__ */ jsx9(Text5, { color: isSelected ? selectionColor : "gray", dimColor: !isSelected, bold: isSelected, children: isSelected ? "\u2503  " : "\u2502  " }),
-      /* @__PURE__ */ jsx9(Box5, { paddingLeft: indent, children: item.isFirstLine ? /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx11(Text5, { color: isSelected ? selectionColor : "gray", dimColor: !isSelected, bold: isSelected, children: isSelected ? "\u2503  " : "\u2502  " }),
+      /* @__PURE__ */ jsx11(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__ */ jsx9(Text5, { children: item.text.startsWith(item.toolName) ? /* @__PURE__ */ jsxs5(Fragment, { children: [
-          /* @__PURE__ */ jsx9(Text5, { color: "white", bold: true, children: item.toolName }),
-          /* @__PURE__ */ jsx9(Text5, { dimColor: true, italic: true, children: item.text.slice(item.toolName.length) })
-        ] }) : /* @__PURE__ */ jsx9(Text5, { dimColor: true, italic: true, children: item.text.startsWith(" ") ? item.text : ` ${item.text}` }) }) : /* @__PURE__ */ jsx9(Text5, { dimColor: !!item.isArgsLine, italic: !!item.isArgsLine, children: item.text })
-      ] }) : /* @__PURE__ */ jsx9(Text5, { children: item.type === "tool" && item.toolName ? /* @__PURE__ */ jsx9(Text5, { dimColor: true, italic: true, children: item.text }) : /* @__PURE__ */ jsx9(Text5, { dimColor: !!item.isArgsLine, italic: !!item.isArgsLine, children: item.text }) }) })
+        item.type === "tool" && item.toolName ? /* @__PURE__ */ jsx11(Text5, { children: item.text.startsWith(item.toolName) ? /* @__PURE__ */ jsxs5(Fragment, { children: [
+          /* @__PURE__ */ jsx11(Text5, { color: "white", bold: true, children: item.toolName }),
+          /* @__PURE__ */ jsx11(Text5, { dimColor: true, italic: true, children: item.text.slice(item.toolName.length) })
+        ] }) : /* @__PURE__ */ jsx11(Text5, { dimColor: true, italic: true, children: item.text.startsWith(" ") ? item.text : ` ${item.text}` }) }) : /* @__PURE__ */ jsx11(Text5, { dimColor: !!item.isArgsLine, italic: !!item.isArgsLine, children: item.text })
+      ] }) : /* @__PURE__ */ jsx11(Text5, { children: item.type === "tool" && item.toolName ? /* @__PURE__ */ jsx11(Text5, { dimColor: true, italic: true, children: item.text }) : /* @__PURE__ */ jsx11(Text5, { dimColor: !!item.isArgsLine, italic: !!item.isArgsLine, children: item.text }) }) })
     ] });
   }
 );
 function messageTypeToColor(type) {
   switch (type) {
+    case "prompt":
     case "user":
       return "green";
     case "agent":
@@ -4085,51 +4675,12 @@ function messageTypeToColor(type) {
 import { ProgressBar } from "@inkjs/ui";
 import { Box as Box6, Text as Text6 } from "ink";
 import "react";
-
-// ink/contexts/PlanContext.tsx
-import { createContext as createContext5, useContext as useContext5, useMemo as useMemo6, useState as useState8 } from "react";
-import { jsx as jsx10 } from "react/jsx-runtime";
-var PlanContext = createContext5(globalPlanContext);
-var usePlan = () => {
-  const context = useContext5(PlanContext);
-  if (!context) {
-    throw new Error("usePlan must be used within a PlanProvider");
-  }
-  return context;
-};
-var PlanProvider = ({
-  children
-}) => {
-  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.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 = useMemo6(() => ({
-    progress,
-    planDescription,
-    planItems
-  }), [progress, planDescription, planItems]);
-  return /* @__PURE__ */ jsx10(PlanContext.Provider, { value, children });
-};
-
-// ink/components/PlanView.tsx
-import { jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx12, 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(
+    /* @__PURE__ */ jsx12(Box6, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx12(Text6, { italic: true, children: planDescription }) }),
+    /* @__PURE__ */ jsx12(Box6, { flexDirection: "column", flexGrow: 1, children: planItems.map((planItem) => /* @__PURE__ */ jsx12(Box6, { children: /* @__PURE__ */ jsxs6(
       Text6,
       {
         color: planItem.status === "done" ? "green" : planItem.status === "in-progress" ? "yellow" : planItem.status === "not-needed" ? "gray" : "white",
@@ -4146,22 +4697,22 @@ function PlanView() {
         progress,
         "%"
       ] }),
-      /* @__PURE__ */ jsx11(ProgressBar, { value: progress })
+      /* @__PURE__ */ jsx12(ProgressBar, { value: progress })
     ] })
   ] });
 }
 
 // ink/components/SettingsView.tsx
 import { Box as Box7, Text as Text7, useInput as useInput2 } from "ink";
-import path7 from "path";
-import { useEffect as useEffect6, useMemo as useMemo8, useState as useState10 } from "react";
+import path8 from "path";
+import { useEffect as useEffect6, useMemo as useMemo9, useState as useState11 } 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);
+import { createContext as createContext7, useContext as useContext7, useMemo as useMemo8, useState as useState10 } from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var SettingsContext = createContext7(void 0);
 var useSettings = () => {
-  const context = useContext6(SettingsContext);
+  const context = useContext7(SettingsContext);
   if (!context) {
     throw new Error("useSettings must be used within a SettingsProvider");
   }
@@ -4170,17 +4721,18 @@ var useSettings = () => {
 var SettingsProvider = ({
   children
 }) => {
-  const [version, setVersion] = useState9(0);
+  const [version, setVersion] = useState10(0);
   useListener("SettingsUpdated", () => {
     setVersion((v) => v + 1);
   }, []);
-  const value = useMemo7(() => ({
+  const value = useMemo8(() => ({
     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,
@@ -4190,11 +4742,11 @@ var SettingsProvider = ({
     rateLimitThreshold: trackedState.rateLimitThreshold,
     rateLimitStatus: rateLimitTracker.getStatus()
   }), [version]);
-  return /* @__PURE__ */ jsx12(SettingsContext.Provider, { value, children });
+  return /* @__PURE__ */ jsx13(SettingsContext.Provider, { value, children });
 };
 
 // ink/components/SettingsView.tsx
-import { jsx as jsx13, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx14, jsxs as jsxs7 } from "react/jsx-runtime";
 function SettingsView({ isDense = false }) {
   const {
     model,
@@ -4202,6 +4754,7 @@ function SettingsView({ isDense = false }) {
     sessionPath,
     cwd,
     useFlexTier,
+    currentTurn,
     maxTurns,
     maxCost,
     autoApproveCodeInterpreter: initialAutoApproveCodeInterpreter,
@@ -4212,10 +4765,10 @@ function SettingsView({ isDense = false }) {
     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);
+  const [autoApproveCodeInterpreter, setAutoApproveCodeInterpreter] = useState11(initialAutoApproveCodeInterpreter);
+  const [autoApprovePatches, setAutoApprovePatches] = useState11(initialAutoApprovePatches);
+  const [autoApproveShell, setAutoApproveShell] = useState11(initialAutoApproveShell);
+  const [monitorRateLimits, setMonitorRateLimits] = useState11(initialMonitorRateLimits);
   useEffect6(() => {
     setAutoApproveCodeInterpreter(initialAutoApproveCodeInterpreter);
   }, [initialAutoApproveCodeInterpreter]);
@@ -4228,8 +4781,8 @@ function SettingsView({ isDense = false }) {
   useEffect6(() => {
     setMonitorRateLimits(initialMonitorRateLimits);
   }, [initialMonitorRateLimits]);
-  const [selectedIndex, setSelectedIndex] = useState10(0);
-  const selectableOptions = useMemo8(() => [
+  const [selectedIndex, setSelectedIndex] = useState11(0);
+  const selectableOptions = useMemo9(() => [
     {
       label: "Code Interpreter",
       value: autoApproveCodeInterpreter,
@@ -4292,83 +4845,95 @@ function SettingsView({ isDense = false }) {
       }
     }
   });
-  const displayPath = useMemo8(() => {
+  const displayPath = useMemo9(() => {
     if (!sessionPath) {
       return null;
     }
-    const relative = path7.relative(cwd, sessionPath);
-    if (!relative.startsWith("..") && !path7.isAbsolute(relative)) {
+    const relative = path8.relative(cwd, sessionPath);
+    if (!relative.startsWith("..") && !path8.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__ */ jsx14(Box7, { marginBottom, children: /* @__PURE__ */ jsx14(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__ */ jsx14(Box7, { width: 20, children: /* @__PURE__ */ jsx14(Text7, { children: "Model:" }) }),
+      /* @__PURE__ */ jsx14(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 })
+      /* @__PURE__ */ jsx14(Box7, { width: 20, children: /* @__PURE__ */ jsx14(Text7, { children: "Compaction Model:" }) }),
+      /* @__PURE__ */ jsx14(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__ */ jsx14(Box7, { width: 20, children: /* @__PURE__ */ jsx14(Text7, { children: "Session Path:" }) }),
+      /* @__PURE__ */ jsx14(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__ */ jsx14(Box7, { width: 20, children: /* @__PURE__ */ jsx14(Text7, { children: "Flex Tier:" }) }),
+      /* @__PURE__ */ jsx14(Text7, { children: useFlexTier ? "Yes" : "No" })
     ] }),
     /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
-      /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "Max Turns:" }) }),
-      /* @__PURE__ */ jsx13(Text7, { children: maxTurns })
+      /* @__PURE__ */ jsx14(Box7, { width: 20, children: /* @__PURE__ */ jsx14(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 Threshold:" }) }),
+      /* @__PURE__ */ jsx14(Box7, { width: 20, children: /* @__PURE__ */ jsx14(Text7, { children: "Rate Limit @:" }) }),
       /* @__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:" }) }),
+    rateLimitStatus && /* @__PURE__ */ jsxs7(Box7, { marginBottom, flexDirection: "column", children: [
+      rateLimitStatus.retryAfter !== null && /* @__PURE__ */ jsxs7(Box7, { children: [
+        /* @__PURE__ */ jsx14(Box7, { width: 20, children: /* @__PURE__ */ jsx14(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__ */ jsx14(Box7, { width: 20, children: /* @__PURE__ */ jsx14(Text7, { children: "RPM Limit:" }) }),
         /* @__PURE__ */ jsxs7(Text7, { children: [
-          rateLimitStatus.remainingRequests,
+          rateLimitStatus.remainingRequests ?? "?",
           " / ",
-          rateLimitStatus.limitRequests,
+          rateLimitStatus.limitRequests ?? "?",
           " (Reset:",
           " ",
-          rateLimitStatus.resetRequests,
+          rateLimitStatus.resetRequests ?? "?",
           ")"
         ] })
       ] }),
-      /* @__PURE__ */ jsxs7(Box7, { children: [
-        /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "TPM Limit:" }) }),
+      rateLimitStatus.remainingTokens !== null && /* @__PURE__ */ jsxs7(Box7, { children: [
+        /* @__PURE__ */ jsx14(Box7, { width: 20, children: /* @__PURE__ */ jsx14(Text7, { children: "TPM Limit:" }) }),
         /* @__PURE__ */ jsxs7(Text7, { children: [
-          rateLimitStatus.remainingTokens,
+          rateLimitStatus.remainingTokens ?? "?",
           " / ",
-          rateLimitStatus.limitTokens,
-          " (Reset: ",
-          rateLimitStatus.resetTokens,
+          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__ */ jsx14(Box7, { width: 20, children: /* @__PURE__ */ jsx14(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):" }),
+      /* @__PURE__ */ jsx14(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: [
+        return /* @__PURE__ */ jsx14(Box7, { children: /* @__PURE__ */ jsxs7(Text7, { color: isSelected ? "cyan" : "white", children: [
           isSelected ? "> " : "  ",
           option.label,
           "isAction" in option ? "" : `: ${option.value ? "ON" : "OFF"}`
@@ -4380,13 +4945,13 @@ function SettingsView({ isDense = false }) {
 
 // ink/components/UserInput.tsx
 import { Box as Box9, Text as Text9 } from "ink";
-import { useCallback as useCallback3, useState as useState12 } from "react";
+import { useCallback as useCallback4, useState as useState13 } 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";
+import { useEffect as useEffect7, useMemo as useMemo10, useReducer, useState as useState12 } from "react";
+import { jsx as jsx15 } from "react/jsx-runtime";
 var reducer = (state, action) => {
   switch (action.type) {
     case "move-cursor-left":
@@ -4439,7 +5004,7 @@ function BlinkingTextInput({
     previousValue: defaultValue,
     cursorOffset: defaultValue.length
   });
-  const [isCursorVisible, setIsCursorVisible] = useState11(true);
+  const [isCursorVisible, setIsCursorVisible] = useState12(true);
   useEffect7(() => {
     if (isDisabled) {
       setIsCursorVisible(false);
@@ -4455,7 +5020,7 @@ function BlinkingTextInput({
       onChange?.(state.value);
     }
   }, [state.value, state.previousValue, onChange]);
-  const suggestion = useMemo9(() => {
+  const suggestion = useMemo10(() => {
     if (state.value.length === 0) {
       return "";
     }
@@ -4491,10 +5056,10 @@ function BlinkingTextInput({
     },
     { isActive: !isDisabled }
   );
-  const renderedValue = useMemo9(() => {
+  const renderedValue = useMemo10(() => {
     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)) });
+      return /* @__PURE__ */ jsx15(Box8, { flexDirection: "column", children: lines2.map((line, i) => /* @__PURE__ */ jsx15(Box8, { children: /* @__PURE__ */ jsx15(Text8, { children: line }) }, i)) });
     }
     if (state.value.length === 0) {
       let displayContent = "";
@@ -4503,7 +5068,7 @@ function BlinkingTextInput({
       } else {
         displayContent = isCursorVisible ? chalk3.inverse(" ") : " ";
       }
-      return /* @__PURE__ */ jsx14(Box8, { flexGrow: 1, minWidth: 1, children: /* @__PURE__ */ jsx14(Text8, { wrap: "end", children: displayContent }) });
+      return /* @__PURE__ */ jsx15(Box8, { flexGrow: 1, minWidth: 1, children: /* @__PURE__ */ jsx15(Text8, { wrap: "end", children: displayContent }) });
     }
     const lines = state.value.split("\n");
     const result = [];
@@ -4529,19 +5094,19 @@ function BlinkingTextInput({
         lineContent += chalk3.dim(suggestion);
       }
       result.push(
-        /* @__PURE__ */ jsx14(Box8, { flexGrow: 1, children: /* @__PURE__ */ jsx14(Text8, { wrap: "end", children: lineContent }) }, lineIndex)
+        /* @__PURE__ */ jsx15(Box8, { flexGrow: 1, children: /* @__PURE__ */ jsx15(Text8, { wrap: "end", children: lineContent }) }, lineIndex)
       );
       if (lineIndex < lines.length - 1) {
         totalOffset++;
       }
     });
-    return /* @__PURE__ */ jsx14(Box8, { flexDirection: "column", flexGrow: 1, children: result });
+    return /* @__PURE__ */ jsx15(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 });
+  return /* @__PURE__ */ jsx15(Box8, { flexGrow: 1, minWidth: 1, children: renderedValue });
 }
 
 // ink/components/UserInput.tsx
-import { jsx as jsx15, jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsx as jsx16, jsxs as jsxs8 } from "react/jsx-runtime";
 var modeSuggestion = {
   approved: [],
   approving: ["yes", "approve", "no", "deny"],
@@ -4550,14 +5115,14 @@ var modeSuggestion = {
 };
 function UserInput() {
   const { userInputMode, focusedArea } = useChat();
-  const [resetKey, setResetKey] = useState12(0);
-  const [, setBlankLines] = useState12(0);
+  const [resetKey, setResetKey] = useState13(0);
+  const [, setBlankLines] = useState13(0);
   useListener("ClearUserInput", () => {
     setResetKey((prev) => prev + 1);
   }, []);
   const borderColor = focusedArea === "input" ? "cyan" : "gray";
   const placeholder = calculatePlaceholder(userInputMode);
-  const onSubmitResetKey = useCallback3((value) => {
+  const onSubmitResetKey = useCallback4((value) => {
     if (value.length) {
       setResetKey((prev) => prev + 1);
       emitToListeners("PushNewMessages", [{ type: "user", text: value.trim(), version: 1 }]);
@@ -4583,8 +5148,8 @@ function UserInput() {
       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(
+        /* @__PURE__ */ jsx16(Box9, { marginLeft: 1, height: 1, children: /* @__PURE__ */ jsx16(Text9, { bold: true, color: borderColor, children: "\u276F" }) }),
+        /* @__PURE__ */ jsx16(Box9, { flexGrow: 1, children: /* @__PURE__ */ jsx16(
           BlinkingTextInput,
           {
             placeholder,
@@ -4613,13 +5178,24 @@ function calculatePlaceholder(mode) {
 }
 
 // ink/components/ChatContent.tsx
-import { jsx as jsx16, jsxs as jsxs9 } from "react/jsx-runtime";
+import { jsx as jsx17, jsxs as jsxs9 } from "react/jsx-runtime";
 function ChatContent() {
-  const { messages, isThinking, focusedArea, setFocusedArea } = useChat();
+  const { messages, isThinking, isCompacting, focusedArea, setFocusedArea } = useChat();
+  const { payload } = useApproval();
   const size = useTerminalSize();
   useMessageListener();
-  const [activeTab, setActiveTab] = useState13("settings");
-  const [selectedIndex, setSelectedIndex] = useState13(0);
+  const [activeTab, setActiveTab] = useState14("settings");
+  const [userHasSwitchedTab, setUserHasSwitchedTab] = useState14(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] = useState14(0);
   const wrapCache = useRef2(
     /* @__PURE__ */ new Map()
   );
@@ -4663,27 +5239,34 @@ function ChatContent() {
         const currentIndex = tabNames.indexOf(activeTab);
         if (key.leftArrow) {
           const nextIndex = (currentIndex - 1 + tabNames.length) % tabNames.length;
-          setActiveTab(tabNames[nextIndex]);
+          const newTab = tabNames[nextIndex];
+          setActiveTab(newTab);
+          setUserHasSwitchedTab(true);
         } else {
           const nextIndex = (currentIndex + 1) % tabNames.length;
-          setActiveTab(tabNames[nextIndex]);
+          const newTab = tabNames[nextIndex];
+          setActiveTab(newTab);
+          setUserHasSwitchedTab(true);
         }
       }
     }
     if (key.ctrl && input === "x") {
       void handleExit();
     }
-    if (key.escape && isThinking) {
+    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 = useCallback4((type) => {
+  const labelWidthFor = useCallback5((type) => {
     if (type === "agent") {
       return 7;
     }
+    if (type === "prompt") {
+      return 7;
+    }
     if (type === "user") {
       return 6;
     }
@@ -4693,7 +5276,7 @@ function ChatContent() {
     return 6;
   }, []);
   const availableTextWidth = timelineWidth - 4;
-  const lineItems = useMemo10(() => {
+  const lineItems = useMemo11(() => {
     const acc = [];
     for (const msg of messages) {
       const labelWidth = labelWidthFor(msg.type);
@@ -4772,14 +5355,15 @@ function ChatContent() {
       setSelectedIndex(lineItems.length - 1);
     }
   }, [size.rows, size.columns]);
-  const tabs = useMemo10(() => [
+  const tabs = useMemo11(() => [
     { name: "settings", label: "SETTINGS" },
     { name: "planDescription", label: "PLAN" },
     { name: "actions", label: "ACTIONS" }
   ], []);
   const timelineTitle = "TIMELINE:";
   const timelineHeaderWidth = timelineWidth - 1;
-  const timelineDashes = timelineHeaderWidth - timelineTitle.length - (isThinking ? 5 : 0);
+  const showSpinner = isCompacting || isThinking;
+  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";
@@ -4790,16 +5374,16 @@ function ChatContent() {
   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 = useCallback4((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)) }), []);
+  const timelinePipeFiller = useCallback5((count) => /* @__PURE__ */ jsx17(Box10, { flexDirection: "column", children: Array.from({ length: count }).map((_, i) => /* @__PURE__ */ jsx17(Box10, { children: /* @__PURE__ */ jsx17(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 }),
-      isThinking && /* @__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" }),
+      /* @__PURE__ */ jsx17(Text10, { color: timelineColor, children: "\u256D" }),
+      /* @__PURE__ */ jsx17(Text10, { bold: true, color: timelineColor, children: timelineTitle }),
+      showSpinner && /* @__PURE__ */ jsx17(Box10, { paddingLeft: 2, paddingRight: 1, children: /* @__PURE__ */ jsx17(Spinner2, { type: "clock" }) }),
+      /* @__PURE__ */ jsx17(Text10, { color: timelineColor, children: "\u2500".repeat(Math.max(0, timelineDashes)) }),
+      /* @__PURE__ */ jsx17(Text10, { color: dividerColor, children: "\u252C" }),
       tabs.map((tab, i) => /* @__PURE__ */ jsxs9(React11.Fragment, { children: [
-        /* @__PURE__ */ jsx16(
+        /* @__PURE__ */ jsx17(
           Text10,
           {
             color: activeTab === tab.name ? "black" : statusColor,
@@ -4808,7 +5392,7 @@ function ChatContent() {
             children: ` ${tab.label} `
           }
         ),
-        i < tabs.length - 1 && /* @__PURE__ */ jsx16(Text10, { color: statusColor, children: "|" })
+        i < tabs.length - 1 && /* @__PURE__ */ jsx17(Text10, { color: statusColor, children: "|" })
       ] }, tab.name)),
       /* @__PURE__ */ jsxs9(Text10, { color: statusColor, children: [
         "\u2500".repeat(statusDashes),
@@ -4816,22 +5400,22 @@ function ChatContent() {
       ] })
     ] }),
     /* @__PURE__ */ jsxs9(Box10, { flexDirection: "row", height: contentHeight - 2, children: [
-      /* @__PURE__ */ jsx16(
+      /* @__PURE__ */ jsx17(
         Box10,
         {
           flexDirection: "column",
           width: timelineWidth,
           paddingLeft: 0,
           paddingRight: 1,
-          children: /* @__PURE__ */ jsx16(Box10, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx16(
+          children: /* @__PURE__ */ jsx17(Box10, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx17(
             VirtualList,
             {
               items: lineItems,
               itemHeight: 1,
               height: contentHeight - 2,
               selectedIndex,
-              renderOverflowTop: useCallback4((count) => /* @__PURE__ */ jsxs9(Box10, { children: [
-                /* @__PURE__ */ jsx16(Text10, { color: "gray", dimColor: true, children: "\u2502" }),
+              renderOverflowTop: useCallback5((count) => /* @__PURE__ */ jsxs9(Box10, { children: [
+                /* @__PURE__ */ jsx17(Text10, { color: "gray", dimColor: true, children: "\u2502" }),
                 count > 0 && /* @__PURE__ */ jsxs9(Text10, { dimColor: true, children: [
                   " ",
                   "\u25B2 ",
@@ -4839,8 +5423,8 @@ function ChatContent() {
                   " more"
                 ] })
               ] }), []),
-              renderOverflowBottom: useCallback4((count) => /* @__PURE__ */ jsxs9(Box10, { children: [
-                /* @__PURE__ */ jsx16(Text10, { color: "gray", dimColor: true, children: "\u2502" }),
+              renderOverflowBottom: useCallback5((count) => /* @__PURE__ */ jsxs9(Box10, { children: [
+                /* @__PURE__ */ jsx17(Text10, { color: "gray", dimColor: true, children: "\u2502" }),
                 count > 0 && /* @__PURE__ */ jsxs9(Text10, { dimColor: true, children: [
                   " ",
                   "\u25BC ",
@@ -4850,8 +5434,8 @@ function ChatContent() {
               ] }), []),
               renderFiller: timelinePipeFiller,
               keyExtractor: (it) => it.key,
-              renderItem: useCallback4(
-                ({ item, isSelected }) => /* @__PURE__ */ jsx16(
+              renderItem: useCallback5(
+                ({ item, isSelected }) => /* @__PURE__ */ jsx17(
                   MessageLineItem,
                   {
                     item,
@@ -4866,7 +5450,7 @@ function ChatContent() {
           ) })
         }
       ),
-      activeTab !== "shell" && activeTab !== "actions" && /* @__PURE__ */ jsx16(
+      activeTab !== "shell" && activeTab !== "actions" && /* @__PURE__ */ jsx17(
         Box10,
         {
           flexDirection: "column",
@@ -4878,7 +5462,7 @@ function ChatContent() {
           borderRight: false
         }
       ),
-      /* @__PURE__ */ jsx16(
+      /* @__PURE__ */ jsx17(
         Box10,
         {
           flexDirection: "column",
@@ -4892,84 +5476,29 @@ function ChatContent() {
           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 }) })
+              /* @__PURE__ */ jsx17(CostView, { isDense: true }),
+              /* @__PURE__ */ jsx17(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx17(SettingsView, { isDense: true }) })
             ] }),
-            activeTab === "planDescription" && /* @__PURE__ */ jsx16(PlanView, {}),
-            activeTab === "actions" && /* @__PURE__ */ jsx16(ActionsView, { height: contentHeight - 2, isFocused: focusedArea === "status" })
+            activeTab === "planDescription" && /* @__PURE__ */ jsx17(PlanView, {}),
+            activeTab === "actions" && /* @__PURE__ */ jsx17(ActionsView, { height: contentHeight - 2, isFocused: focusedArea === "status" })
           ] })
         }
       )
     ] }),
     /* @__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__ */ jsx17(Text10, { color: junctionLeftColor, children: "\u2522" }),
+      /* @__PURE__ */ jsx17(Text10, { color: timelineBottomColor, children: "\u2501".repeat(timelineWidth - 1) }),
+      /* @__PURE__ */ jsx17(Text10, { color: junctionMiddleColor, children: "\u2537" }),
+      /* @__PURE__ */ jsx17(Text10, { color: statusBottomColor, children: "\u2501".repeat(Math.max(0, statusWidth - 2)) }),
+      /* @__PURE__ */ jsx17(Text10, { color: junctionRightColor, children: "\u252A" })
     ] }),
-    /* @__PURE__ */ jsx16(UserInput, {})
+    /* @__PURE__ */ jsx17(UserInput, {})
   ] });
 }
 
 // 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();
@@ -5343,10 +5872,10 @@ function EnvironmentSettingsStep({ onConfirm, onBack }) {
 
 // ink/configurationWizard/modelsByProvider.ts
 var modelsByProvider = {
-  OpenAI: ["gpt-5.2", "gpt-5.0", "gpt-4o-mini"],
-  Anthropic: ["claude-4-6-opus-latest", "claude-4-5-sonnet-latest", "claude-4-5-haiku-latest"],
-  Google: ["gemini-3-pro", "gemini-3-flash", "gemini-2.5-flash", "gemini-2.5-flash-lite"],
-  Ollama: ["qwen3-coder:30b", "mistral", "codellama"]
+  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, "mistral", defaultOllamaCompactionModel]
 };
 var compactorModelsByProvider = {
   OpenAI: modelsByProvider.OpenAI.slice().reverse(),
@@ -5605,20 +6134,48 @@ function MainChat() {
   ] }) }) }) }) }) });
 }
 
-// lifecycle/parseArgs.ts
-import path8 from "path";
+// 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 chalk4 from "chalk";
+import chalk5 from "chalk";
 
 // utils/package/getOwnPackageJson.ts
 import { readFileSync as readFileSync6 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { fileURLToPath } from "url";
 var __dirname = fileURLToPath(new URL(".", import.meta.url));
 function getOwnPackageJson() {
   try {
-    const packageContents = readFileSync6(join10(__dirname, "../package.json"), "utf8");
+    const packageContents = readFileSync6(join11(__dirname, "../package.json"), "utf8");
     return JSON.parse(packageContents);
   } catch {
     return { name: "@harperfast/agent", version: "0.0.0" };
@@ -5636,24 +6193,23 @@ function isVersionRequest(args) {
 }
 function handleHelp() {
   console.log(`
-${chalk4.bold("harper-agent")} - AI to help you with Harper app management
+${chalk5.bold("harper-agent")} - AI to help you with Harper app creation and modification
 
-${chalk4.bold("USAGE")}
+${chalk5.bold("USAGE")}
   $ harper-agent [options]
   $ harper-agent [command]
 
-${chalk4.bold("OPTIONS")}
+${chalk5.bold("OPTIONS")}
   -h, --help              Show help information
   -v, --version           Show version information
-  -m, --model             Specify the model to use (e.g., gpt-4o, claude-3-5-sonnet, ollama-llama3)
+  -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., ollama-llama3).
-  -c, --compaction-model  Specify the compaction model to use (defaults to gpt-4o-mini).
+                          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.
-                          In task-driven mode, this defaults to unlimited.
                           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.
@@ -5661,12 +6217,13 @@ ${chalk4.bold("OPTIONS")}
   --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.
 
-${chalk4.bold("COMMANDS")}
+${chalk5.bold("COMMANDS")}
   --help           Show help information
   --version        Show version information
 
-${chalk4.bold("EXAMPLES")}
+${chalk5.bold("EXAMPLES")}
   $ harper-agent --help
   $ harper-agent --version
   $ harper-agent
@@ -5702,7 +6259,8 @@ function parseArgs() {
       ["sessionPath", ["--session", "-s", "session"]],
       ["maxTurns", ["--max-turns"]],
       ["maxCost", ["--max-cost"]],
-      ["rateLimitThreshold", ["--rate-limit-threshold"]]
+      ["rateLimitThreshold", ["--rate-limit-threshold"]],
+      ["prompt", ["--prompt", "-p"]]
     ];
     let handled = false;
     for (const [key, prefixes] of flagPairs) {
@@ -5740,6 +6298,8 @@ function parseArgs() {
       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) {
@@ -5763,10 +6323,6 @@ function parseArgs() {
   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;
-  }
   if (!trackedState.useFlexTier && isTrue(process.env.HARPER_AGENT_FLEX_TIER)) {
     trackedState.useFlexTier = true;
   }
@@ -5779,55 +6335,67 @@ function parseArgs() {
   if (isTrue(process.env.HARPER_AGENT_AUTO_APPROVE_SHELL)) {
     trackedState.autoApproveShell = true;
   }
-  if (!trackedState.model) {
+  if (isTrue(process.env.HARPER_AGENT_AUTONOMOUS)) {
+    trackedState.autonomous = true;
+  }
+  if (!trackedState.model || trackedState.model === defaultModelToken) {
     if (process.env.ANTHROPIC_API_KEY) {
-      trackedState.model = "claude-3-7-sonnet-latest";
+      trackedState.model = defaultAnthropicModel;
     } else if (process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
-      trackedState.model = "gemini-2.0-flash";
-    } else if (process.env.OPENAI_API_KEY) {
-      trackedState.model = "gpt-5.2";
+      trackedState.model = defaultGoogleModel;
     } else if (process.env.OLLAMA_BASE_URL) {
-      trackedState.model = "ollama-qwen3-coder:30b";
+      trackedState.model = defaultOllamaModel;
     } else {
-      trackedState.model = "gpt-5.2";
+      trackedState.model = defaultOpenAIModel;
     }
   }
-  if (!trackedState.compactionModel) {
+  if (!trackedState.compactionModel || trackedState.compactionModel === defaultModelToken) {
     const m = trackedState.model;
     if (m.startsWith("claude-")) {
-      trackedState.compactionModel = "claude-3-5-haiku-latest";
+      trackedState.compactionModel = defaultAnthropicCompactionModel;
     } else if (m.startsWith("gemini-")) {
-      trackedState.compactionModel = "gemini-1.5-flash";
+      trackedState.compactionModel = defaultGoogleCompactionModel;
     } else if (m.startsWith("ollama-")) {
-      trackedState.compactionModel = "ollama-qwen2.5-coder";
+      trackedState.compactionModel = defaultOllamaCompactionModel;
     } else {
-      trackedState.compactionModel = "gpt-4o-mini";
+      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 existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function loadEnv() {
-  const topLevelEnvPath = join11(homedir4(), ".harper", "harper-agent-env");
-  const localEnvPath = join11(process.cwd(), ".env");
-  if (existsSync9(topLevelEnvPath)) {
+  const topLevelEnvPath = join12(homedir4(), ".harper", "harper-agent-env");
+  const localEnvPath = join12(process.cwd(), ".env");
+  if (existsSync10(topLevelEnvPath)) {
     dotenv.config({ path: topLevelEnvPath, quiet: true });
   }
-  if (existsSync9(localEnvPath)) {
+  if (existsSync10(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 chalk6 from "chalk";
 import spawn2 from "cross-spawn";
 import { Box as Box19, render as render2, Text as Text18 } from "ink";
 import React21 from "react";
@@ -5949,7 +6517,7 @@ function UpdatePrompt({ packageName, currentVersion, latestVersion, onSelect })
     React21.createElement(
       Text18,
       null,
-      `${chalk5.yellow("Update available:")} ${chalk5.bold(packageName)} ${chalk5.dim(`v${currentVersion}`)} \u2192 ${chalk5.green(`v${latestVersion}`)}`
+      `${chalk6.yellow("Update available:")} ${chalk6.bold(packageName)} ${chalk6.dim(`v${currentVersion}`)} \u2192 ${chalk6.green(`v${latestVersion}`)}`
     ),
     React21.createElement(
       Box19,
@@ -5987,34 +6555,10 @@ function ensureApiKey() {
   return true;
 }
 
-// utils/shell/getStdin.ts
-async function getStdin() {
-  if (process.stdin.isTTY) {
-    return "";
-  }
-  let result = "";
-  process.stdin.setEncoding("utf8");
-  for await (const chunk of process.stdin) {
-    result += chunk;
-  }
-  return result.trim();
-}
-
 // 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();
@@ -6026,17 +6570,16 @@ async function getStdin() {
     emitToListeners("ExitUI", void 0);
     parseArgs();
     if (!ensureApiKey()) {
-      console.log(chalk6.red("No key provided. Exiting."));
+      console.log(chalk7.red("No key provided. Exiting."));
       process.exit(1);
     }
   }
   await agentManager.initialize();
   bootstrapMain();
-  getStdin().then((stdinPrompt) => {
-    if (stdinPrompt?.trim?.()?.length) {
-      emitToListeners("PushNewMessages", [
-        { type: "user", text: stdinPrompt.trim(), version: 1 }
-      ]);
-    }
-  });
+  if (trackedState.prompt?.trim?.()?.length) {
+    trackedState.autonomous = true;
+    emitToListeners("PushNewMessages", [
+      { type: "prompt", text: trackedState.prompt.trim(), version: 1 }
+    ]);
+  }
 })();