@harperfast/agent 0.10.6

package/dist/agent.js

@@ -0,0 +1,2917 @@
+#!/usr/bin/env node
+
+// agent.ts
+import "dotenv/config";
+import { Agent as Agent3, run as run2 } from "@openai/agents";
+import chalk13 from "chalk";
+
+// lifecycle/cleanUpAndSayBye.ts
+import { getGlobalTraceProvider } from "@openai/agents";
+
+// utils/sessions/cost.ts
+import chalk 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 },
+  "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-5": { 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 },
+  "o1": { input: 15 / 1e6, cachedInput: 7.5 / 1e6, output: 60 / 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 }
+};
+var MODEL_PRICES = {
+  flex: FLEX_PRICES,
+  standard: STANDARD_PRICES
+};
+function hasKnownPrices(model, tier = "flex") {
+  return !!model && model in MODEL_PRICES[tier];
+}
+function extractCachedTokens(inputTokenDetails) {
+  let cachedInputTokens = 0;
+  if (inputTokenDetails) {
+    const details = Array.isArray(inputTokenDetails) ? inputTokenDetails : [inputTokenDetails];
+    for (const inputTokenDetail of details) {
+      if (inputTokenDetail["cached_tokens"]) {
+        cachedInputTokens += inputTokenDetail["cached_tokens"];
+      }
+    }
+  }
+  return cachedInputTokens;
+}
+function calculateCost(model, inputTokens, outputTokens, inputTokenDetails, tier = "flex") {
+  if (!model) {
+    return 0;
+  }
+  const prices = MODEL_PRICES[tier][model];
+  if (!prices) {
+    return 0;
+  }
+  const cachedInputTokens = extractCachedTokens(inputTokenDetails);
+  const fullRateInputTokens = inputTokens - cachedInputTokens;
+  return fullRateInputTokens * prices.input + cachedInputTokens * prices.cachedInput + outputTokens * prices.output;
+}
+var CostTracker = class {
+  totalInputTokens = 0;
+  totalCachedInputTokens = 0;
+  totalOutputTokens = 0;
+  totalCost = 0;
+  totalCompactionCost = 0;
+  hasUnknownPrices = false;
+  reset() {
+    this.totalInputTokens = 0;
+    this.totalCachedInputTokens = 0;
+    this.totalOutputTokens = 0;
+    this.totalCost = 0;
+    this.totalCompactionCost = 0;
+    this.hasUnknownPrices = false;
+  }
+  recordTurn(model, usage, compactionModel) {
+    const { turnCost, compactionCost, unknownPrices } = this.calculateUsageCosts(model, usage, compactionModel);
+    this.totalInputTokens += usage.inputTokens;
+    this.totalCachedInputTokens += extractCachedTokens(usage.inputTokensDetails);
+    this.totalOutputTokens += usage.outputTokens;
+    this.totalCost += turnCost;
+    this.totalCompactionCost += compactionCost;
+    if (unknownPrices) {
+      this.hasUnknownPrices = true;
+    }
+    return turnCost + compactionCost;
+  }
+  calculateUsageCosts(model, usage, compactionModel) {
+    let turnCost = 0;
+    let compactionCost = 0;
+    let unknownPrices = !hasKnownPrices(model, "flex");
+    if (usage?.requestUsageEntries && usage.requestUsageEntries.length > 0) {
+      for (const entry of usage.requestUsageEntries) {
+        const isCompaction = entry.endpoint === "responses.compact";
+        let tier = isCompaction ? "standard" : "flex";
+        const entryActualTier = entry.serviceTier;
+        if (entryActualTier === "flex") {
+          tier = "flex";
+        } else if (entryActualTier === "scale" || entryActualTier === "standard") {
+          tier = "standard";
+        }
+        const entryModel = isCompaction ? compactionModel : model;
+        if (!hasKnownPrices(entryModel, tier)) {
+          unknownPrices = true;
+        }
+        const entryCost = calculateCost(
+          entryModel,
+          entry.inputTokens,
+          entry.outputTokens,
+          entry.inputTokensDetails,
+          tier
+        );
+        if (isCompaction) {
+          compactionCost += entryCost;
+        } else {
+          turnCost += entryCost;
+        }
+      }
+    } else if (usage) {
+      const usageActualTier = usage.serviceTier;
+      const tier = usageActualTier === "scale" || usageActualTier === "standard" ? "standard" : "flex";
+      turnCost = calculateCost(model, usage.inputTokens, usage.outputTokens, usage.inputTokensDetails, tier);
+    }
+    return { turnCost, compactionCost, unknownPrices };
+  }
+  getStatusString(currentTurnUsage, model, compactionModel) {
+    const { turnCost, compactionCost, unknownPrices } = this.calculateUsageCosts(
+      model,
+      currentTurnUsage,
+      compactionModel
+    );
+    if (this.hasUnknownPrices || unknownPrices) {
+      return "";
+    }
+    const totalTurnCost = turnCost + compactionCost;
+    return chalk.dim(
+      `[~${chalk.cyan("$" + (this.totalCost + this.totalCompactionCost + totalTurnCost).toFixed(4))}]`
+    );
+  }
+  logFinalStats() {
+    if (this.totalInputTokens > 0 || this.totalOutputTokens > 0) {
+      const fmt = (n) => new Intl.NumberFormat().format(n);
+      const cachedStr = this.totalCachedInputTokens > 0 ? ` (${chalk.cyan(fmt(this.totalCachedInputTokens))} cached)` : "";
+      const showCost = !this.hasUnknownPrices;
+      const totalCost = this.totalCost + this.totalCompactionCost;
+      let statsStr = chalk.dim(
+        `Final session usage: ${chalk.cyan(fmt(this.totalInputTokens))} input${cachedStr}, ${chalk.cyan(fmt(this.totalOutputTokens))} output tokens.`
+      );
+      if (showCost) {
+        statsStr += chalk.dim(` Total cost: ~${chalk.cyan("$" + totalCost.toFixed(4))}`);
+        if (this.totalCompactionCost > 0) {
+          statsStr += chalk.dim(
+            ` (Compaction: ${chalk.cyan("$" + this.totalCompactionCost.toFixed(4))})`
+          );
+        }
+      }
+      console.log(statsStr);
+    }
+  }
+};
+var costTracker = new CostTracker();
+
+// utils/shell/harperProcess.ts
+import spawn from "cross-spawn";
+import { execSync } from "child_process";
+import { homedir } from "os";
+import { join } 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 = join(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 logs = this.logs;
+    this.logs = [];
+    return logs.join("");
+  }
+};
+var harperProcess = new HarperProcess();
+
+// utils/shell/harperResponse.ts
+import chalk2 from "chalk";
+function harperResponse(text) {
+  if (text) {
+    console.log(`${chalk2.bold("Harper:")} ${chalk2.cyan(text)}
+`);
+  }
+}
+
+// utils/shell/spinner.ts
+import process2 from "process";
+
+// lifecycle/trackedState.ts
+import "@openai/agents";
+var trackedState = {
+  agent: null,
+  cwd: process.cwd(),
+  atStartOfLine: true,
+  emptyLines: 0,
+  approvalState: null,
+  controller: null,
+  model: "",
+  compactionModel: "",
+  sessionPath: null,
+  useFlexTier: false,
+  disableSpinner: false,
+  enableInterruptions: true
+};
+
+// utils/shell/spinner.ts
+var Spinner = class {
+  interval = null;
+  chars = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  i = 0;
+  message;
+  status = "";
+  onData = null;
+  constructor(message = "Thinking...") {
+    this.message = message;
+  }
+  get isSpinning() {
+    return this.interval !== null;
+  }
+  start() {
+    const disabled = trackedState.disableSpinner || process2.env.HARPER_AGENT_NO_SPINNER === "true" || process2.env.HARPER_AGENT_NO_SPINNER === "1" || process2.env.HARPER_AGENT_DISABLE_SPINNER === "true" || process2.env.HARPER_AGENT_DISABLE_SPINNER === "1";
+    if (this.interval) {
+      return;
+    }
+    if (trackedState.enableInterruptions) {
+      this.onData = (data) => {
+        const str = data.toString();
+        if (str.includes("\n") || str.includes("\r")) {
+          this.interrupt();
+        }
+      };
+      process2.stdin.on("data", this.onData);
+      if (process2.stdin.isTTY) {
+        process2.stdin.resume();
+      }
+    }
+    if (disabled) {
+      this.interval = null;
+      console.log("Thinking...");
+      return;
+    }
+    this.i = 0;
+    process2.stdout.write(`${this.chars[this.i]} ${this.message}${this.status ? " " + this.status : ""}\x1B[K`);
+    this.interval = setInterval(() => {
+      this.i = (this.i + 1) % this.chars.length;
+      process2.stdout.write(`\r${this.chars[this.i]} ${this.message}${this.status ? " " + this.status : ""}\x1B[K`);
+    }, 80);
+  }
+  interrupt() {
+    if (!trackedState.enableInterruptions) {
+      return;
+    }
+    if (trackedState.controller) {
+      this.stop();
+      trackedState.controller.abort();
+      harperResponse("<thought interrupted>");
+      trackedState.atStartOfLine = true;
+    }
+  }
+  stop() {
+    if (this.onData) {
+      process2.stdin.removeListener("data", this.onData);
+      this.onData = null;
+    }
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+      this.status = "";
+      process2.stdout.write("\r\x1B[K");
+    } else {
+      this.status = "";
+    }
+  }
+};
+var spinner = new Spinner();
+
+// lifecycle/cleanUpAndSayBye.ts
+async function cleanUpAndSayBye() {
+  spinner.stop();
+  costTracker.logFinalStats();
+  if (harperProcess.startedInternally) {
+    harperProcess.stop();
+  }
+  console.log("");
+  harperResponse("See you later!");
+  await getGlobalTraceProvider().forceFlush();
+}
+
+// lifecycle/defaultInstructions.ts
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+function defaultInstructions() {
+  const harperAppExists = existsSync(join2(trackedState.cwd, "config.yaml"));
+  const vibing = harperAppExists ? "updating" : "creating";
+  return `You are working on ${vibing} a harper app with the user.`;
+}
+
+// lifecycle/getModel.ts
+import { anthropic } from "@ai-sdk/anthropic";
+import { google } from "@ai-sdk/google";
+import { openai } from "@ai-sdk/openai";
+import { aisdk } from "@openai/agents-extensions";
+import "@openai/agents-extensions/ai-sdk";
+import { createOllama, ollama } from "ollama-ai-provider-v2";
+function isOpenAIModel(modelName) {
+  if (!modelName || modelName === "gpt-5.2") {
+    return true;
+  }
+  return !modelName.startsWith("claude-") && !modelName.startsWith("gemini-") && !modelName.startsWith("ollama-");
+}
+function getModel(modelName) {
+  if (modelName.startsWith("claude-")) {
+    return aisdk(anthropic(modelName));
+  }
+  if (modelName.startsWith("gemini-")) {
+    return aisdk(google(modelName));
+  }
+  if (modelName.startsWith("ollama-")) {
+    const ollamaBaseUrl = process.env.OLLAMA_BASE_URL ? normalizeOllamaBaseUrl(process.env.OLLAMA_BASE_URL) : void 0;
+    const ollamaProvider = ollamaBaseUrl ? createOllama({ baseURL: ollamaBaseUrl }) : ollama;
+    return aisdk(ollamaProvider(getModelName(modelName)));
+  }
+  return aisdk(openai(modelName));
+}
+function getModelName(modelName) {
+  if (modelName.startsWith("claude-")) {
+    return modelName;
+  }
+  if (modelName.startsWith("gemini-")) {
+    return modelName;
+  }
+  if (modelName.startsWith("ollama-")) {
+    return modelName.replace("ollama-", "");
+  }
+  return modelName;
+}
+function normalizeOllamaBaseUrl(baseUrl) {
+  let url = baseUrl.trim();
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    url = `http://${url}`;
+  }
+  const urlObj = new URL(url);
+  if (!urlObj.port) {
+    urlObj.port = "11434";
+  }
+  let pathname = urlObj.pathname;
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  if (!pathname.endsWith("/api")) {
+    pathname += "/api";
+  }
+  urlObj.pathname = pathname;
+  return urlObj.toString().replace(/\/$/, "");
+}
+
+// utils/shell/cli.ts
+import chalk3 from "chalk";
+
+// utils/package/getOwnPackageJson.ts
+import { readFileSync } from "fs";
+import { join as join3 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = fileURLToPath(new URL(".", import.meta.url));
+function getOwnPackageJson() {
+  try {
+    const packageContents = readFileSync(join3(__dirname, "../package.json"), "utf8");
+    return JSON.parse(packageContents);
+  } catch {
+    return { name: "@harperfast/agent", version: "0.0.0" };
+  }
+}
+
+// utils/shell/cli.ts
+function isHelpRequest(args) {
+  const helpVariants = ["--help", "-h", "help"];
+  return args.some((arg) => helpVariants.includes(arg.toLowerCase()));
+}
+function isVersionRequest(args) {
+  const versionVariants = ["--version", "-v", "version"];
+  return args.some((arg) => versionVariants.includes(arg.toLowerCase()));
+}
+function handleHelp() {
+  console.log(`
+${chalk3.bold("harper-agent")} - AI to help you with Harper app management
+
+${chalk3.bold("USAGE")}
+  $ harper-agent [options]
+  $ harper-agent [command]
+
+${chalk3.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)
+                          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).
+                          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.
+  --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.
+  --no-spinner            Disable the thinking spinner (also: --disable-spinner)
+                          Can also be set via HARPER_AGENT_NO_SPINNER=1 or HARPER_AGENT_DISABLE_SPINNER=1.
+  --no-interruptions      Disable stdin-based interruption logic
+                          Aliases: --no-interrupt, --no-interrupts, --disable-interrupt,
+                                   --disable-interrupts, --disable-interruptions
+                          Env: set HARPER_AGENT_DISABLE_INTERRUPTION=1 or HARPER_AGENT_DISABLE_INTERRUPTIONS=1
+                               (default interruptions are enabled). You can also set
+                               HARPER_AGENT_ENABLE_INTERRUPTION=0 or HARPER_AGENT_ENABLE_INTERRUPTIONS=0.
+
+${chalk3.bold("COMMANDS")}
+  --help           Show help information
+  --version        Show version information
+
+${chalk3.bold("EXAMPLES")}
+  $ harper-agent --help
+  $ harper-agent --version
+  $ harper-agent
+`);
+  process.exit(0);
+}
+function handleVersion() {
+  const pkg = getOwnPackageJson();
+  console.log(pkg.version);
+  process.exit(0);
+}
+
+// utils/strings/isFalse.ts
+function isFalse(v) {
+  if (v === void 0) {
+    return false;
+  }
+  const val = v.trim().toLowerCase();
+  return val === "false" || val === "0" || val === "no" || val === "off";
+}
+
+// utils/strings/isTrue.ts
+function isTrue(v) {
+  if (v === void 0) {
+    return false;
+  }
+  const val = v.trim().toLowerCase();
+  return val === "true" || val === "1" || val === "yes" || val === "on";
+}
+
+// lifecycle/parseArgs.ts
+function stripQuotes(str) {
+  if (str.startsWith('"') && str.endsWith('"') || str.startsWith("'") && str.endsWith("'")) {
+    return str.slice(1, -1);
+  }
+  return str;
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  if (isHelpRequest(args)) {
+    handleHelp();
+  }
+  if (isVersionRequest(args)) {
+    handleVersion();
+  }
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const flagPairs = [
+      ["model", ["--model", "-m", "model"]],
+      ["compactionModel", ["--compaction-model", "-c", "compaction-model"]],
+      ["sessionPath", ["--session", "-s", "session"]]
+    ];
+    let handled = false;
+    for (const [key, prefixes] of flagPairs) {
+      for (const prefix of prefixes) {
+        if (arg === prefix) {
+          if (args[i + 1]) {
+            trackedState[key] = stripQuotes(args[++i]);
+          }
+          handled = true;
+          break;
+        } else if (arg.startsWith(`${prefix}=`)) {
+          trackedState[key] = stripQuotes(arg.slice(prefix.length + 1));
+          handled = true;
+          break;
+        }
+      }
+      if (handled) {
+        break;
+      }
+    }
+    if (handled) {
+      continue;
+    }
+    if (arg === "--flex-tier") {
+      trackedState.useFlexTier = true;
+    } else if (arg === "--no-spinner" || arg === "--disable-spinner") {
+      trackedState.disableSpinner = true;
+    } else if ([
+      "--no-interrupt",
+      "--no-interrupts",
+      "--no-interruptions",
+      "--disable-interrupt",
+      "--disable-interrupts",
+      "--disable-interruptions"
+    ].includes(arg)) {
+      trackedState.enableInterruptions = false;
+    }
+  }
+  if (!trackedState.model && process.env.HARPER_AGENT_MODEL) {
+    trackedState.model = process.env.HARPER_AGENT_MODEL;
+  }
+  if (!trackedState.compactionModel && process.env.HARPER_AGENT_COMPACTION_MODEL) {
+    trackedState.compactionModel = process.env.HARPER_AGENT_COMPACTION_MODEL;
+  }
+  if (!trackedState.sessionPath && process.env.HARPER_AGENT_SESSION) {
+    trackedState.sessionPath = process.env.HARPER_AGENT_SESSION;
+  }
+  if (!trackedState.useFlexTier && isTrue(process.env.HARPER_AGENT_FLEX_TIER)) {
+    trackedState.useFlexTier = true;
+  }
+  if (!trackedState.disableSpinner && (isTrue(process.env.HARPER_AGENT_NO_SPINNER) || isTrue(process.env.HARPER_AGENT_DISABLE_SPINNER))) {
+    trackedState.disableSpinner = true;
+  }
+  if (isTrue(process.env.HARPER_AGENT_DISABLE_INTERRUPTION) || isTrue(process.env.HARPER_AGENT_DISABLE_INTERRUPTIONS) || isFalse(process.env.HARPER_AGENT_ENABLE_INTERRUPTION) || isFalse(process.env.HARPER_AGENT_ENABLE_INTERRUPTIONS)) {
+    trackedState.enableInterruptions = false;
+  }
+  if (!trackedState.model) {
+    if (process.env.ANTHROPIC_API_KEY) {
+      trackedState.model = "claude-3-7-sonnet-latest";
+    } 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";
+    } else if (process.env.OLLAMA_BASE_URL) {
+      trackedState.model = "ollama-qwen3-coder:30b";
+    } else {
+      trackedState.model = "gpt-5.2";
+    }
+  }
+  if (!trackedState.compactionModel) {
+    const m = trackedState.model;
+    if (m.startsWith("claude-")) {
+      trackedState.compactionModel = "claude-3-5-haiku-latest";
+    } else if (m.startsWith("gemini-")) {
+      trackedState.compactionModel = "gemini-1.5-flash";
+    } else if (m.startsWith("ollama-")) {
+      trackedState.compactionModel = "ollama-qwen2.5-coder";
+    } else {
+      trackedState.compactionModel = "gpt-4o-mini";
+    }
+  }
+  if (!isOpenAIModel(trackedState.model)) {
+    process.env.OPENAI_AGENTS_DISABLE_TRACING = process.env.OPENAI_AGENTS_DISABLE_TRACING || "1";
+  }
+}
+
+// lifecycle/readAgentsMD.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
+function readAgentsMD() {
+  const agentsMdExists = existsSync2(join4(trackedState.cwd, "AGENTS.md"));
+  if (agentsMdExists) {
+    return readFileSync2(join4(trackedState.cwd, "AGENTS.md"), "utf8");
+  }
+}
+
+// lifecycle/sayHi.ts
+import chalk4 from "chalk";
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+function sayHi() {
+  const harperAppExists = existsSync3(join5(trackedState.cwd, "config.yaml"));
+  console.log(chalk4.dim(`Working directory: ${chalk4.cyan(trackedState.cwd)}`));
+  console.log(chalk4.dim(`Harper app detected: ${chalk4.cyan(harperAppExists ? "Yes" : "No")}`));
+  console.log(chalk4.dim(`Press Ctrl+C or hit enter twice to exit.
+`));
+  harperResponse(
+    harperAppExists ? "What do you want to do together today?" : "What kind of Harper app do you want to make together?"
+  );
+}
+
+// tools/files/applyPatchTool.ts
+import { tool } from "@openai/agents";
+import chalk7 from "chalk";
+import { z } from "zod";
+
+// utils/files/printDiff.ts
+import chalk5 from "chalk";
+function printDiff(diff) {
+  const lines = diff.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("+")) {
+      console.log(chalk5.green(line));
+    } else if (line.startsWith("-")) {
+      console.log(chalk5.red(line));
+    } else {
+      console.log(chalk5.dim(line));
+    }
+  }
+}
+
+// utils/getEnv.ts
+import chalk6 from "chalk";
+var warnedKeys = /* @__PURE__ */ new Set();
+function getEnv(newKey, oldKey) {
+  const newValue = process.env[newKey];
+  if (newValue !== void 0) {
+    return newValue;
+  }
+  const oldValue = process.env[oldKey];
+  if (oldValue !== void 0) {
+    if (!warnedKeys.has(oldKey)) {
+      console.warn(
+        chalk6.yellow(
+          `[DEPRECATION NOTICE] The environment variable ${oldKey} is deprecated and will be removed in a future version. Please use ${newKey} instead.`
+        )
+      );
+      warnedKeys.add(oldKey);
+    }
+    return oldValue;
+  }
+  return void 0;
+}
+
+// tools/files/workspaceEditor.ts
+import { applyDiff } from "@openai/agents";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { mkdir, rm, writeFile } from "fs/promises";
+import path3 from "path";
+
+// utils/files/normalizeDiff.ts
+function normalizeDiff(diff) {
+  return diff.split(/\r?\n/).filter((line) => {
+    const l = line.trim();
+    if (l.startsWith("*** Begin Patch") || l.startsWith("*** End Patch") || l.startsWith("*** Add File:") || l.startsWith("*** Update File:") || l.startsWith("*** Delete File:") || l.startsWith("*** End of File")) {
+      return false;
+    }
+    if (l.startsWith("update_file:") || l.startsWith("create_file:") || l.startsWith("delete_file:")) {
+      return false;
+    }
+    return true;
+  }).join("\n").trim();
+}
+
+// utils/files/paths.ts
+import path2 from "path";
+
+// utils/files/aiignore.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import path from "path";
+var ignorePatterns = [];
+function loadAiIgnore() {
+  const ignorePath = path.join(trackedState.cwd, ".aiignore");
+  if (existsSync4(ignorePath)) {
+    try {
+      const content = readFileSync3(ignorePath, "utf8");
+      ignorePatterns = content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((pattern) => pattern.endsWith("/") || pattern.endsWith("\\") ? pattern.slice(0, -1) : pattern);
+    } catch (error) {
+      console.error(`Error reading .aiignore: ${error}`);
+      ignorePatterns = [];
+    }
+  } else {
+    ignorePatterns = [];
+  }
+}
+function isIgnored(filePath) {
+  const directParts = path.normalize(filePath).split(path.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)) {
+    return false;
+  }
+  const normalizedPath = path.normalize(relativePath);
+  const parts = normalizedPath.split(path.sep);
+  loadAiIgnore();
+  if (ignorePatterns.length === 0) {
+    return false;
+  }
+  return ignorePatterns.some((pattern) => {
+    if (pattern.startsWith("/")) {
+      const normalizedPattern = path.normalize(pattern.substring(1));
+      return normalizedPath === normalizedPattern || normalizedPath.startsWith(normalizedPattern + path.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);
+    });
+  });
+}
+
+// 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)) {
+    throw new Error(`Operation outside workspace: ${relativePath}`);
+  }
+  if (isIgnored(resolved)) {
+    throw new Error(`Operation restricted by .aiignore: ${relativePath}`);
+  }
+  return resolved;
+}
+
+// tools/files/workspaceEditor.ts
+var WorkspaceEditor = class {
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  async createFile(operation) {
+    try {
+      const targetPath = resolvePath(this.root(), operation.path);
+      await mkdir(path3.dirname(targetPath), { recursive: true });
+      const normalizedDiff = normalizeDiff(operation.diff);
+      const content = applyDiff("", normalizedDiff, "create");
+      await writeFile(targetPath, content, "utf8");
+      return { status: "completed", output: `Created ${operation.path}` };
+    } catch (err) {
+      return { status: "failed", output: `Error creating ${operation.path}: ${String(err)}` };
+    }
+  }
+  async updateFile(operation) {
+    try {
+      const targetPath = resolvePath(this.root(), operation.path);
+      if (!existsSync5(targetPath)) {
+        return { status: "failed", output: "Error: file not found at path " + targetPath };
+      }
+      const original = readFileSync4(targetPath, "utf8");
+      const normalizedDiff = normalizeDiff(operation.diff);
+      const patched = applyDiff(original, normalizedDiff);
+      await writeFile(targetPath, patched, "utf8");
+      return { status: "completed", output: `Updated ${operation.path}` };
+    } catch (err) {
+      return { status: "failed", output: `Error updating ${operation.path}: ${String(err)}` };
+    }
+  }
+  async deleteFile(operation) {
+    try {
+      const targetPath = resolvePath(this.root(), operation.path);
+      if (!existsSync5(targetPath)) {
+        return { status: "failed", output: "Error: file not found at path " + targetPath };
+      }
+      await rm(targetPath, { force: true });
+      return { status: "completed", output: `Deleted ${operation.path}` };
+    } catch (err) {
+      return { status: "failed", output: `Error deleting ${operation.path}: ${String(err)}` };
+    }
+  }
+};
+
+// tools/files/applyPatchTool.ts
+var ApplyPatchParameters = z.object({
+  type: z.enum(["create_file", "update_file", "delete_file"]).describe("The type of operation to perform."),
+  path: z.string().describe("The path to the file to operate on."),
+  diff: z.string().optional().default("").describe(
+    'The diff to apply. For create_file, every line must start with "+". For update_file, use a headerless unified diff format (start sections with "@@", and use "+", "-", or " " for lines). Do not include markers like "*** Begin Patch" or "*** Add File:".'
+  )
+});
+function createApplyPatchTool() {
+  const editor = new WorkspaceEditor(() => trackedState.cwd);
+  return tool({
+    name: "apply_patch",
+    description: "Applies a patch (create, update, or delete a file) to the workspace.",
+    parameters: ApplyPatchParameters,
+    needsApproval: async (runContext, operation, callId) => {
+      try {
+        if (callId && runContext.isToolApproved({ toolName: "apply_patch", callId })) {
+          return false;
+        }
+        const autoApproved = getEnv("HARPER_AGENT_AUTO_APPROVE_PATCHES", "APPLY_PATCH_AUTO_APPROVE") === "1";
+        spinner.stop();
+        if (autoApproved) {
+          console.log(`
+${chalk7.bold.bgGreen.black(" Apply patch (auto-approved): ")}`);
+        } else {
+          console.log(`
+${chalk7.bold.bgYellow.black(" Apply patch approval required: ")}`);
+        }
+        console.log(`${chalk7.bold(operation.type)}: ${operation.path}`);
+        if (operation.diff) {
+          printDiff(operation.diff);
+        }
+        if (autoApproved) {
+          spinner.start();
+        }
+        return !autoApproved;
+      } catch (err) {
+        console.error("apply_patch approval step failed:", err);
+        return false;
+      }
+    },
+    execute: async (operation) => {
+      try {
+        switch (operation.type) {
+          case "create_file":
+            if (!operation.diff) {
+              return { status: "failed", output: "Error: diff is required for create_file" };
+            }
+            return await editor.createFile(operation);
+          case "update_file":
+            if (!operation.diff) {
+              return { status: "failed", output: "Error: diff is required for update_file" };
+            }
+            return await editor.updateFile(operation);
+          case "delete_file":
+            return await editor.deleteFile(operation);
+          default:
+            return { status: "failed", output: `Error: Unknown operation type: ${operation.type}` };
+        }
+      } catch (err) {
+        console.error("hit unexpected error in apply patch tool", err);
+        return { status: "failed", output: `apply_patch threw: ${String(err)}` };
+      }
+    }
+  });
+}
+
+// tools/files/changeCwdTool.ts
+import { tool as tool2 } from "@openai/agents";
+import { statSync } from "fs";
+import { z as z2 } from "zod";
+var ToolParameters = z2.object({
+  path: z2.string().describe("Directory to switch into. Can be absolute or relative to current workspace.")
+});
+async function execute({ path: path7 }) {
+  try {
+    const target = resolvePath(trackedState.cwd, path7);
+    const stat = statSync(target);
+    if (!stat.isDirectory()) {
+      console.log(`Path is not a directory: ${target}`);
+      return `Path is not a directory: ${target}`;
+    }
+    process.chdir(target);
+    trackedState.cwd = process.cwd();
+    console.log(`Switched current working directory to ${trackedState.cwd}`);
+    const agentsMDContents = readAgentsMD();
+    if (agentsMDContents) {
+      if (trackedState.agent) {
+        trackedState.agent.instructions = agentsMDContents;
+      }
+      return `Switched current working directory to ${trackedState.cwd}, with a AGENTS.md file containing:
+${agentsMDContents}`;
+    }
+    return `Switched current working directory to ${trackedState.cwd}`;
+  } catch (err) {
+    console.log(`Failed to change directory: ${err.message}`);
+    return `Failed to change directory: ${err.message}`;
+  }
+}
+var changeCwdTool = tool2({
+  name: "changeCwd",
+  description: "Changes the current working directory for subsequent tools. Accepts absolute or relative paths.",
+  parameters: ToolParameters,
+  execute
+});
+
+// tools/files/egrepTool.ts
+import { tool as tool3 } from "@openai/agents";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { z as z3 } from "zod";
+var execFileAsync = promisify(execFile);
+var ToolParameters2 = z3.object({
+  path: z3.string().describe("The path to start the search from."),
+  pattern: z3.string().describe("The pattern to search")
+});
+var egrepTool = tool3({
+  name: "egrep",
+  description: "File pattern searcher.",
+  parameters: ToolParameters2,
+  async execute({ path: searchPath, pattern }) {
+    try {
+      const resolvedPath = resolvePath(trackedState.cwd, searchPath);
+      const { stdout } = await execFileAsync("grep", ["-Eir", pattern, resolvedPath]);
+      return stdout.split("\n").filter((line) => {
+        if (line.trim() === "") {
+          return false;
+        }
+        const colonIndex = line.indexOf(":");
+        if (colonIndex !== -1) {
+          const filePath = line.substring(0, colonIndex);
+          return !isIgnored(filePath);
+        }
+        return true;
+      }).join("\n");
+    } catch (error) {
+      if (error.code === 1) {
+        return "";
+      }
+      return `Error executing egrep command: ${error.stderr || error.message}`;
+    }
+  }
+});
+
+// tools/files/findTool.ts
+import { tool as tool4 } from "@openai/agents";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { z as z4 } from "zod";
+var execFileAsync2 = promisify2(execFile2);
+var ToolParameters3 = z4.object({
+  path: z4.string().describe("The path to start the search from."),
+  iname: z4.string().describe(
+    "Case insensitive, true if the last component of the pathname being examined matches pattern.  Special shell pattern matching characters (\u201C[\u201D, \u201C]\u201D, \u201C*\u201D, and \u201C?\u201D) may be used as part of pattern.  These characters may be matched explicitly by escaping them with a backslash (\u201C\\\u201D)."
+  )
+});
+var findTool = tool4({
+  name: "find",
+  description: "Walk a file hierarchy.",
+  parameters: ToolParameters3,
+  async execute({ path: searchPath, iname }) {
+    try {
+      const resolvedPath = resolvePath(trackedState.cwd, searchPath);
+      const { stdout } = await execFileAsync2("find", [resolvedPath, "-iname", iname]);
+      return stdout.split("\n").filter((line) => line.trim() !== "" && !isIgnored(line)).join("\n");
+    } catch (error) {
+      return `Error executing find command: ${error.stderr || error.message}`;
+    }
+  }
+});
+
+// tools/files/readDirTool.ts
+import { tool as tool5 } from "@openai/agents";
+import { readdir } from "fs/promises";
+import path4 from "path";
+import { z as z5 } from "zod";
+var ToolParameters4 = z5.object({
+  directoryName: z5.string().describe("The name of the directory to read.")
+});
+var readDirTool = tool5({
+  name: "readDir",
+  description: "Lists the files in a directory.",
+  parameters: ToolParameters4,
+  async execute({ directoryName }) {
+    try {
+      const resolvedPath = resolvePath(trackedState.cwd, directoryName);
+      const files = await readdir(resolvedPath, "utf8");
+      return files.filter((file) => !isIgnored(path4.join(resolvedPath, file)));
+    } catch (error) {
+      return `Error reading directory: ${error}`;
+    }
+  }
+});
+
+// tools/files/readFileTool.ts
+import { tool as tool6 } from "@openai/agents";
+import { readFile } from "fs/promises";
+import { z as z6 } from "zod";
+var ToolParameters5 = z6.object({
+  fileName: z6.string().describe("The name of the file to read.")
+});
+var readFileTool = tool6({
+  name: "readFile",
+  description: "Reads the contents of a specified file.",
+  parameters: ToolParameters5,
+  async execute({ fileName }) {
+    try {
+      const resolvedPath = resolvePath(trackedState.cwd, fileName);
+      return readFile(resolvedPath, "utf8");
+    } catch (error) {
+      return `Error reading file: ${error}`;
+    }
+  }
+});
+
+// tools/general/codeInterpreterTool.ts
+import { tool as tool7 } from "@openai/agents";
+import chalk8 from "chalk";
+import { exec } from "child_process";
+import { unlink, writeFile as writeFile2 } from "fs/promises";
+import path5 from "path";
+import { promisify as promisify3 } from "util";
+import { z as z7 } from "zod";
+var execAsync = promisify3(exec);
+var CodeInterpreterParameters = z7.object({
+  code: z7.string().describe("The code to execute."),
+  language: z7.enum(["python", "javascript"]).optional().default("python").describe(
+    "The programming language of the code."
+  )
+});
+var codeInterpreterTool = tool7({
+  name: "code_interpreter",
+  description: "Executes Python or JavaScript code in a local environment. This is useful for data analysis, complex calculations, and more. All code will be executed in the current workspace.",
+  parameters: CodeInterpreterParameters,
+  execute: execute2,
+  needsApproval
+});
+async function needsApproval(runContext, { code, language }, callId) {
+  if (callId && runContext.isToolApproved({ toolName: "code_interpreter", callId })) {
+    return false;
+  }
+  const autoApproved = getEnv("HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER", "CODE_INTERPRETER_AUTO_APPROVE") === "1";
+  spinner.stop();
+  if (autoApproved) {
+    console.log(`
+${chalk8.bold.bgGreen.black(` Code interpreter (${language}, auto-approved): `)}`);
+  } else {
+    console.log(`
+${chalk8.bold.bgYellow.black(` Code interpreter (${language}) approval required: `)}`);
+  }
+  console.log(chalk8.dim(code));
+  if (autoApproved) {
+    spinner.start();
+  }
+  return !autoApproved;
+}
+async function execute2({ 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}`);
+  try {
+    await writeFile2(tempFile, code, "utf8");
+    const { stdout, stderr } = await execAsync(`${interpreter} ${tempFile}`);
+    return `STDOUT:
+${stdout}
+STDERR:
+${stderr}`;
+  } catch (error) {
+    return `Error executing code: ${error.message}
+STDOUT: ${error.stdout || ""}
+STDERR: ${error.stderr || ""}`;
+  } finally {
+    await unlink(tempFile).catch(() => {
+    });
+  }
+}
+
+// tools/general/setInterpreterAutoApproveTool.ts
+import { tool as tool8 } from "@openai/agents";
+import { z as z8 } from "zod";
+
+// utils/files/updateEnv.ts
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { join as join6 } from "path";
+async function updateEnv(key, value) {
+  process.env[key] = value;
+  const envPath = join6(trackedState.cwd, ".env");
+  let envContent = "";
+  if (existsSync6(envPath)) {
+    envContent = await readFile2(envPath, "utf8");
+  }
+  const regex = new RegExp(`^${key}=.*`, "m");
+  if (regex.test(envContent)) {
+    envContent = envContent.replace(regex, `${key}=${value}`);
+  } else {
+    if (envContent && !envContent.endsWith("\n")) {
+      envContent += "\n";
+    }
+    envContent += `${key}=${value}
+`;
+  }
+  await writeFile3(envPath, envContent);
+}
+
+// tools/general/setInterpreterAutoApproveTool.ts
+var SetInterpreterAutoApproveParameters = z8.object({
+  autoApprove: z8.boolean()
+});
+var setInterpreterAutoApproveTool = tool8({
+  name: "setInterpreterAutoApproveTool",
+  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,
+  needsApproval: async (_runContext, { autoApprove }) => {
+    const newValue = autoApprove ? "1" : "0";
+    return getEnv("HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER", "CODE_INTERPRETER_AUTO_APPROVE") !== newValue;
+  },
+  async execute({ autoApprove }) {
+    const newValue = autoApprove ? "1" : "0";
+    if (getEnv("HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER", "CODE_INTERPRETER_AUTO_APPROVE") === newValue) {
+      return `HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER is already set to ${newValue}.`;
+    }
+    try {
+      await updateEnv("HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER", newValue);
+      return `HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER has been set to ${newValue} in .env and current process.`;
+    } catch (error) {
+      return `Error updating .env file: ${error.message}`;
+    }
+  }
+});
+
+// tools/general/setPatchAutoApproveTool.ts
+import { tool as tool9 } from "@openai/agents";
+import { z as z9 } from "zod";
+var SetPatchAutoApproveParameters = z9.object({
+  autoApprove: z9.boolean()
+});
+var setPatchAutoApproveTool = tool9({
+  name: "setPatchAutoApproveTool",
+  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,
+  needsApproval: async (_runContext, { autoApprove }) => {
+    const newValue = autoApprove ? "1" : "0";
+    return getEnv("HARPER_AGENT_AUTO_APPROVE_PATCHES", "APPLY_PATCH_AUTO_APPROVE") !== newValue;
+  },
+  async execute({ autoApprove }) {
+    const newValue = autoApprove ? "1" : "0";
+    if (getEnv("HARPER_AGENT_AUTO_APPROVE_PATCHES", "APPLY_PATCH_AUTO_APPROVE") === newValue) {
+      return `HARPER_AGENT_AUTO_APPROVE_PATCHES is already set to ${newValue}.`;
+    }
+    try {
+      await updateEnv("HARPER_AGENT_AUTO_APPROVE_PATCHES", newValue);
+      return `HARPER_AGENT_AUTO_APPROVE_PATCHES has been set to ${newValue} in .env and current process.`;
+    } catch (error) {
+      return `Error updating .env file: ${error.message}`;
+    }
+  }
+});
+
+// tools/general/setShellAutoApproveTool.ts
+import { tool as tool10 } from "@openai/agents";
+import { z as z10 } from "zod";
+var SetShellAutoApproveParameters = z10.object({
+  autoApprove: z10.boolean()
+});
+var setShellAutoApproveTool = tool10({
+  name: "setShellAutoApproveTool",
+  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,
+  needsApproval: async (_runContext, { autoApprove }) => {
+    const newValue = autoApprove ? "1" : "0";
+    return getEnv("HARPER_AGENT_AUTO_APPROVE_SHELL", "SHELL_AUTO_APPROVE") !== newValue;
+  },
+  async execute({ autoApprove }) {
+    const newValue = autoApprove ? "1" : "0";
+    if (getEnv("HARPER_AGENT_AUTO_APPROVE_SHELL", "SHELL_AUTO_APPROVE") === newValue) {
+      return `HARPER_AGENT_AUTO_APPROVE_SHELL is already set to ${newValue}.`;
+    }
+    try {
+      await updateEnv("HARPER_AGENT_AUTO_APPROVE_SHELL", newValue);
+      return `HARPER_AGENT_AUTO_APPROVE_SHELL has been set to ${newValue} in .env and current process.`;
+    } catch (error) {
+      return `Error updating .env file: ${error.message}`;
+    }
+  }
+});
+
+// tools/general/shellTool.ts
+import { tool as tool11 } from "@openai/agents";
+import chalk9 from "chalk";
+import { z as z11 } from "zod";
+
+// utils/files/mentionsIgnoredPath.ts
+function mentionsIgnoredPath(command) {
+  const partRegex = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([^\s;&|><]+)/g;
+  let match;
+  while ((match = partRegex.exec(command)) !== null) {
+    const pathCandidate = match[1] ?? match[2] ?? match[3];
+    if (pathCandidate && isIgnored(pathCandidate)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// utils/shell/isRiskyCommand.ts
+var RISKY_COMMANDS = [
+  // File removal
+  /(?:^|[;&|])\s*rm\b/i,
+  /(?:^|[;&|])\s*shred\b/i,
+  /(?:^|[;&|])\s*git\s+clean\b.*\s-f/i,
+  // Database operations
+  /\bdrop\s+(database|table|collection|schema)\b/i,
+  /\btruncate\s+table\b/i,
+  /\bdelete\s+from\b/i,
+  // Disk/System operations
+  /(?:^|[;&|])\s*dd\b.*\bof=/i,
+  /(?:^|[;&|])\s*mkfs\b/i,
+  /(?:^|[;&|])\s*format\b/i,
+  /(?:^|[;&|])\s*fdisk\b/i,
+  /(?:^|[;&|])\s*parted\b/i,
+  // Permissions (broad changes)
+  /(?:^|[;&|])\s*chmod\b.*\s-R/i,
+  /(?:^|[;&|])\s*chown\b.*\s-R/i,
+  // System state
+  /(?:^|[;&|])\s*shutdown\b/i,
+  /(?:^|[;&|])\s*reboot\b/i,
+  /(?:^|[;&|])\s*halt\b/i,
+  /(?:^|[;&|])\s*poweroff\b/i,
+  // Networking/Firewall (potentially destructive to access)
+  /(?:^|[;&|])\s*iptables\b.*\s(-F|-X|-Z)/i,
+  /(?:^|[;&|])\s*ufw\s+reset\b/i,
+  // Dangerous redirections
+  />\s*\/dev\/(?!null)/i
+];
+function isRiskyCommand(command) {
+  const trimmedCommand = command.trim();
+  if (!trimmedCommand) {
+    return false;
+  }
+  return RISKY_COMMANDS.some((pattern) => pattern.test(trimmedCommand));
+}
+
+// utils/shell/LocalShell.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execAsync2 = promisify4(exec2);
+var LocalShell = class {
+  defaultTimeoutMs;
+  constructor(options) {
+    const envValRaw = getEnv("HARPER_AGENT_SHELL_TIMEOUT_MS", "SHELL_DEFAULT_TIMEOUT_MS");
+    const envVal = envValRaw !== void 0 ? Number(envValRaw) : void 0;
+    this.defaultTimeoutMs = options?.defaultTimeoutMs ?? (envVal !== void 0 && !Number.isNaN(envVal) ? envVal : 2e4);
+  }
+  async run(action) {
+    const output = [];
+    for (const command of action.commands) {
+      let stdout = "";
+      let stderr = "";
+      let exitCode = 0;
+      let outcome = {
+        type: "exit",
+        exitCode: 0
+      };
+      try {
+        const { stdout: localStdout, stderr: localStderr } = await execAsync2(
+          command,
+          {
+            cwd: trackedState.cwd,
+            // Prefer per-call timeout, else default
+            timeout: action.timeoutMs ?? this.defaultTimeoutMs,
+            maxBuffer: action.maxOutputLength
+          }
+        );
+        stdout = localStdout;
+        stderr = localStderr;
+      } catch (error) {
+        exitCode = typeof error?.code === "number" ? error.code : null;
+        stdout = error?.stdout ?? "";
+        stderr = error?.stderr ?? "";
+        outcome = error?.killed || error?.signal === "SIGTERM" ? { type: "timeout" } : { type: "exit", exitCode };
+      }
+      output.push({
+        command,
+        stdout,
+        stderr,
+        outcome
+      });
+      if (outcome.type === "timeout") {
+        break;
+      }
+    }
+    return {
+      output,
+      providerData: {
+        working_directory: trackedState.cwd
+      }
+    };
+  }
+};
+
+// tools/general/shellTool.ts
+var ShellParameters = z11.object({
+  commands: z11.array(z11.string()).describe("The commands to execute.")
+});
+var shell = new LocalShell();
+var shellTool = tool11({
+  name: "shellToolForCommandsWithoutABetterTool",
+  description: "Executes shell commands.",
+  parameters: ShellParameters,
+  execute: async ({ commands }) => {
+    const result = await shell.run({ commands });
+    return result.output.map((o) => {
+      let out = `STDOUT:
+${o.stdout}
+STDERR:
+${o.stderr}`;
+      if (o.outcome.type === "exit") {
+        out += `
+EXIT CODE: ${o.outcome.exitCode}`;
+      } else {
+        out += `
+TIMEOUT`;
+      }
+      return out;
+    }).join("\n---\n");
+  },
+  needsApproval: async (runContext, { commands }, callId) => {
+    if (callId && runContext.isToolApproved({ toolName: "shell", callId })) {
+      return false;
+    }
+    const foundRiskyCommand = commands.find((command) => isRiskyCommand(command));
+    const foundIgnoredInteraction = commands.find((command) => mentionsIgnoredPath(command));
+    const autoApproved = getEnv("HARPER_AGENT_AUTO_APPROVE_SHELL", "SHELL_AUTO_APPROVE") === "1" && !foundRiskyCommand && !foundIgnoredInteraction;
+    spinner.stop();
+    if (autoApproved) {
+      console.log(
+        chalk9.bold.bgGreen.black("\n Shell command (auto-approved): \n")
+      );
+    } else if (foundRiskyCommand) {
+      console.log(
+        chalk9.bold.bgYellow.black("\n Shell command approval of risky command required: \n")
+      );
+    } else if (foundIgnoredInteraction) {
+      console.log(
+        chalk9.bold.bgYellow.black("\n Shell command approval of ignored file interaction required: \n")
+      );
+    } else {
+      console.log(
+        chalk9.bold.bgYellow.black("\n Shell command approval required: \n")
+      );
+    }
+    for (const cmd of commands) {
+      console.log(chalk9.dim(`  > ${cmd}`));
+    }
+    if (autoApproved) {
+      spinner.start();
+    }
+    return !autoApproved;
+  }
+});
+
+// tools/git/gitAddTool.ts
+import { tool as tool12 } from "@openai/agents";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify5 } from "util";
+import { z as z12 } from "zod";
+var execFileAsync3 = promisify5(execFile3);
+var GitAddParameters = z12.object({
+  files: z12.array(z12.string()).describe("The files to add. If not provided, all changes will be added.")
+});
+var gitAddTool = tool12({
+  name: "gitAddTool",
+  description: "Add file contents to the index.",
+  parameters: GitAddParameters,
+  async execute({ files }) {
+    try {
+      const args = ["add"];
+      if (!files || files.length === 0) {
+        args.push(".");
+      } else {
+        args.push(...files);
+      }
+      const { stdout, stderr } = await execFileAsync3("git", args);
+      return `Success: ${stdout || stderr || "Files added to index"}`;
+    } catch (error) {
+      return `Error: ${error.stderr || error.message}`;
+    }
+  }
+});
+
+// tools/git/gitBranchTool.ts
+import { tool as tool13 } from "@openai/agents";
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify6 } from "util";
+import { z as z13 } from "zod";
+var execFileAsync4 = promisify6(execFile4);
+var GitBranchParameters = z13.object({
+  branchName: z13.string().describe("The name of the branch to create or switch to."),
+  create: z13.boolean().optional().default(false).describe("Whether to create a new branch.")
+});
+var gitBranchTool = tool13({
+  name: "gitBranchTool",
+  description: "Create or switch to a git branch.",
+  parameters: GitBranchParameters,
+  needsApproval: true,
+  async execute({ branchName, create }) {
+    try {
+      const args = create ? ["checkout", "-b", branchName] : ["checkout", branchName];
+      const { stdout, stderr } = await execFileAsync4("git", args);
+      return `Success: ${stdout || stderr || `Switched to branch ${branchName}`}`;
+    } catch (error) {
+      return `Error: ${error.stderr || error.message}`;
+    }
+  }
+});
+
+// tools/git/gitCommitTool.ts
+import { tool as tool14 } from "@openai/agents";
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify7 } from "util";
+import { z as z14 } from "zod";
+var execFileAsync5 = promisify7(execFile5);
+var GitCommitParameters = z14.object({
+  message: z14.string().describe("The commit message."),
+  addAll: z14.boolean().optional().default(false).describe(
+    "Whether to add all changes before committing (git commit -am)."
+  )
+});
+var gitCommitTool = tool14({
+  name: "gitCommitTool",
+  description: "Commit changes to the repository.",
+  parameters: GitCommitParameters,
+  async execute({ message, addAll }) {
+    try {
+      const args = addAll ? ["commit", "-am", message] : ["commit", "-m", message];
+      const { stdout, stderr } = await execFileAsync5("git", args);
+      return `Success: ${stdout || stderr || "Changes committed"}`;
+    } catch (error) {
+      return `Error: ${error.stderr || error.message}`;
+    }
+  }
+});
+
+// tools/git/gitLogTool.ts
+import { tool as tool15 } from "@openai/agents";
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify8 } from "util";
+import { z as z15 } from "zod";
+var execFileAsync6 = promisify8(execFile6);
+var GitLogParameters = z15.object({
+  count: z15.number().optional().default(10).describe("Number of commits to show."),
+  oneline: z15.boolean().optional().default(true).describe("Whether to show log in oneline format.")
+});
+var gitLogTool = tool15({
+  name: "gitLogTool",
+  description: "Show commit logs.",
+  parameters: GitLogParameters,
+  async execute({ count, oneline }) {
+    try {
+      const args = ["log", "-n", count.toString()];
+      if (oneline) {
+        args.push("--oneline");
+      }
+      const { stdout, stderr } = await execFileAsync6("git", args);
+      return stdout || stderr || "No log output";
+    } catch (error) {
+      return `Error: ${error.stderr || error.message}`;
+    }
+  }
+});
+
+// tools/git/gitStashTool.ts
+import { tool as tool16 } from "@openai/agents";
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify9 } from "util";
+import { z as z16 } from "zod";
+var execFileAsync7 = promisify9(execFile7);
+var allowedActions = ["push", "pop", "apply", "list"];
+var GitStashParameters = z16.object({
+  action: z16.string().describe("The stash action to perform: " + allowedActions.join(", ")),
+  message: z16.string().describe("A message for the stash change.")
+});
+var gitStashTool = tool16({
+  name: "gitStashTool",
+  description: "Stash changes or apply a stash.",
+  parameters: GitStashParameters,
+  async execute({ action, message }) {
+    try {
+      if (!allowedActions.includes(action)) {
+        return `Error: Invalid action '${action}'. Allowed actions are: ${allowedActions.join(", ")}`;
+      }
+      const args = ["stash", action];
+      if (action === "push" && message) {
+        args.push("-m", message);
+      }
+      const { stdout, stderr } = await execFileAsync7("git", args);
+      return `Success: ${stdout || stderr || `Git stash ${action} completed`}`;
+    } catch (error) {
+      return `Error: ${error.stderr || error.message}`;
+    }
+  }
+});
+
+// tools/git/gitStatusTool.ts
+import { tool as tool17 } from "@openai/agents";
+import { execFile as execFile8 } from "child_process";
+import { promisify as promisify10 } from "util";
+import { z as z17 } from "zod";
+var execFileAsync8 = promisify10(execFile8);
+var GitStatusParameters = z17.object({
+  short: z17.boolean().optional().default(false).describe("Whether to show the status in short format.")
+});
+var gitStatusTool = tool17({
+  name: "gitStatusTool",
+  description: "Show the working tree status.",
+  parameters: GitStatusParameters,
+  async execute({ short }) {
+    try {
+      const args = ["status"];
+      if (short) {
+        args.push("--short");
+      }
+      const { stdout, stderr } = await execFileAsync8("git", args);
+      return stdout || stderr || "No status output";
+    } catch (error) {
+      return `Error: ${error.stderr || error.message}`;
+    }
+  }
+});
+
+// tools/git/gitWorkspaceTool.ts
+import { tool as tool18 } from "@openai/agents";
+import { execFile as execFile9 } from "child_process";
+import { promisify as promisify11 } from "util";
+import { z as z18 } from "zod";
+var execFileAsync9 = promisify11(execFile9);
+var GitWorkspaceParameters = z18.object({
+  path: z18.string().describe("The path where the new workspace (worktree) should be created."),
+  branchName: z18.string().describe("The name of the branch to use in the new workspace."),
+  createBranch: z18.boolean().optional().default(false).describe("Whether to create a new branch for this workspace.")
+});
+var gitWorkspaceTool = tool18({
+  name: "gitWorkspaceTool",
+  description: "Create a new workspace (git worktree) for parallel work.",
+  parameters: GitWorkspaceParameters,
+  async execute({ path: workspacePath, branchName, createBranch }) {
+    try {
+      const resolvedPath = resolvePath(trackedState.cwd, workspacePath);
+      const args = createBranch ? ["worktree", "add", "-b", branchName, resolvedPath] : ["worktree", "add", resolvedPath, branchName];
+      const { stdout, stderr } = await execFileAsync9("git", args);
+      return `Success: ${stdout || stderr || `Created workspace at ${resolvedPath}`}`;
+    } catch (error) {
+      return `Error: ${error.stderr || error.message}`;
+    }
+  }
+});
+
+// tools/harper/checkHarperStatusTool.ts
+import { tool as tool19 } from "@openai/agents";
+import { z as z19 } from "zod";
+var ToolParameters6 = z19.object({});
+var checkHarperStatusTool = tool19({
+  name: "checkHarperStatusTool",
+  description: "Checks if a Harper application is currently running.",
+  parameters: ToolParameters6,
+  async execute() {
+    if (harperProcess.running) {
+      return "A Harper application is currently running.";
+    } else {
+      return "No Harper application is currently running.";
+    }
+  }
+});
+
+// tools/harper/createNewHarperApplicationTool.ts
+import { tool as tool20 } from "@openai/agents";
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import path6 from "path";
+import { z as z20 } from "zod";
+
+// utils/package/buildHarperCreateCommand.ts
+function buildCreateCommand(pm, appName, template) {
+  switch (pm) {
+    case "deno":
+      return { cmd: `deno init --npm harper "${appName}" 2>&1`, label: "deno init --npm harper" };
+    case "npm":
+      return {
+        cmd: `npm create harper@latest --yes "${appName}" -- --no-interactive --template ${template} 2>&1`,
+        label: "npm create harper@latest"
+      };
+    default:
+      return {
+        cmd: `${pm} create harper "${appName}" --no-interactive --template ${template} 2>&1`,
+        label: `${pm} create harper`
+      };
+  }
+}
+
+// utils/package/isPackageManagerAvailable.ts
+import { execSync as execSync2 } from "child_process";
+function isPackageManagerAvailable(cmd) {
+  try {
+    execSync2(`${cmd} --version`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// utils/package/pickPreferredPackageManager.ts
+function pickPreferredPackageManager() {
+  const preferred = ["yarn", "pnpm", "bun", "deno"];
+  for (const pm of preferred) {
+    if (isPackageManagerAvailable(pm)) {
+      return pm;
+    }
+  }
+  return "npm";
+}
+var PM_DISPLAY = {
+  yarn: "Yarn",
+  pnpm: "PNPM",
+  bun: "Bun",
+  deno: "Deno",
+  npm: "NPM"
+};
+
+// tools/harper/createNewHarperApplicationTool.ts
+var ToolParameters7 = z20.object({
+  directoryName: z20.string().describe("The name of the directory to create the application in."),
+  template: z20.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 execute3({ 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);
+  try {
+    console.log(`Creating new Harper application in ${resolvedPath} using template ${template}...`);
+    const pm = pickPreferredPackageManager();
+    const { cmd, label } = buildCreateCommand(pm, appName, template);
+    console.log(`Detected ${PM_DISPLAY[pm]}. Executing: ${label} in ${executionCwd} for ${appName}`);
+    execSync3(cmd, {
+      cwd: executionCwd,
+      encoding: "utf8"
+    });
+    console.log(`Initializing new Git repository in ${resolvedPath}...`);
+    execSync3("git init", { cwd: resolvedPath, stdio: "ignore" });
+    const switchedDir = await execute({ path: resolvedPath });
+    const agentsMdExists = existsSync7(path6.join(resolvedPath, "AGENTS.md"));
+    let returnMsg = `Successfully created a new Harper application in '${resolvedPath}' using template '${template}' with a matching Git repository initialized. ${switchedDir}.`;
+    if (agentsMdExists) {
+      returnMsg += ` I found an AGENTS.md file in the new application \u2013 I strongly suggest you read it next to understand how to use your new skills!`;
+    }
+    returnMsg += ` Use the readDir and readFile tools to inspect the contents of the application.`;
+    return returnMsg;
+  } catch (error) {
+    let errorMsg = `Error creating new Harper application: ${error.message}`;
+    if (error.stdout) {
+      errorMsg += `
+
+Command Output:
+${error.stdout}`;
+    }
+    return errorMsg;
+  }
+}
+var createNewHarperApplicationTool = tool20({
+  name: "createNewHarperApplicationTool",
+  description: "Creates a new Harper application using the best available package manager (yarn/pnpm/bun/deno, falling back to npm).",
+  parameters: ToolParameters7,
+  execute: execute3
+});
+
+// tools/harper/getHarperConfigSchemaTool.ts
+import { tool as tool21 } from "@openai/agents";
+import { readFile as readFile3 } from "fs/promises";
+import { createRequire } from "module";
+import { dirname, join as join7 } from "path";
+import { z as z21 } from "zod";
+var ToolParameters8 = z21.object({
+  schemaType: z21.enum(["app", "root"]).describe(
+    'The type of configuration schema to retrieve: "app" for application configuration or "root" for root Harper configuration.'
+  )
+});
+var getHarperConfigSchemaTool = tool21({
+  name: "getHarperConfigSchemaTool",
+  description: "Returns the JSON schema for HarperDB configuration files (either app or root), which describes the config.yaml or harperdb-config.yaml files.",
+  parameters: ToolParameters8,
+  async execute({ schemaType }) {
+    try {
+      return await readFile3(
+        join7(
+          dirname(createRequire(import.meta.url).resolve("harperdb")),
+          `config-${schemaType}.schema.json`
+        ),
+        "utf8"
+      );
+    } catch (error) {
+      return `Error reading HarperDB ${schemaType} configuration schema: ${error}`;
+    }
+  }
+});
+
+// tools/harper/getHarperResourceInterfaceTool.ts
+import { tool as tool22 } from "@openai/agents";
+import { readFile as readFile4 } from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname2, join as join8 } from "path";
+import { z as z22 } from "zod";
+var ToolParameters9 = z22.object({
+  resourceFile: z22.enum([
+    "ResourceInterfaceV2",
+    "ResourceInterface",
+    "Table",
+    "Resource",
+    "ResourceV2"
+  ]).describe(
+    "The resource-related definition file to read. Defaults to ResourceInterfaceV2."
+  ).default("ResourceInterfaceV2")
+});
+var getHarperResourceInterfaceTool = tool22({
+  name: "getHarperResourceInterfaceTool",
+  description: "Reads HarperDB resource interface and class definitions (like ResourceInterfaceV2.d.ts) to understand how resources and tables are structured.",
+  parameters: ToolParameters9,
+  async execute({ resourceFile }) {
+    try {
+      return await readFile4(
+        join8(
+          dirname2(createRequire2(import.meta.url).resolve("harperdb")),
+          "resources",
+          `${resourceFile}.d.ts`
+        ),
+        "utf8"
+      );
+    } catch (error) {
+      return `Error reading HarperDB resource file ${resourceFile}: ${error}`;
+    }
+  }
+});
+
+// tools/harper/getHarperSchemaGraphQLTool.ts
+import { tool as tool23 } from "@openai/agents";
+import { readFile as readFile5 } from "fs/promises";
+import { createRequire as createRequire3 } from "module";
+import { dirname as dirname3, join as join9 } from "path";
+import { z as z23 } from "zod";
+var ToolParameters10 = z23.object({});
+var getHarperSchemaGraphQLTool = tool23({
+  name: "getHarperSchemaGraphQLTool",
+  description: "Returns the GraphQL schema for HarperDB schema files, which define the structure of HarperDB database tables.",
+  parameters: ToolParameters10,
+  async execute() {
+    try {
+      return await readFile5(
+        join9(
+          dirname3(createRequire3(import.meta.url).resolve("harperdb")),
+          `schema.graphql`
+        ),
+        "utf8"
+      );
+    } catch (error) {
+      return `Error reading HarperDB GraphQL schema: ${error}`;
+    }
+  }
+});
+
+// tools/harper/getHarperSkillTool.ts
+import { tool as tool24 } from "@openai/agents";
+import { readdirSync, readFileSync as readFileSync5 } from "fs";
+import { createRequire as createRequire4 } from "module";
+import { dirname as dirname4, join as join10 } from "path";
+import { z as z24 } from "zod";
+var createHarper = dirname4(createRequire4(import.meta.url).resolve("create-harper"));
+var agentsMarkdown = join10(
+  createHarper,
+  "AGENTS.md"
+);
+var skillsDir = join10(
+  createHarper,
+  "template-vanilla",
+  "skills"
+);
+var skillLinkRegex = /\[[^\]]+]\(skills\/([^)]+)\.md\)/g;
+var skills = getSkills();
+var ToolParameters11 = z24.object({
+  skill: z24.enum(skills.length > 0 ? skills : ["none"]).describe(
+    "The name of the skill to retrieve."
+  )
+});
+var getHarperSkillTool = tool24({
+  name: "getHarperSkill",
+  description: getSkillsDescription(),
+  parameters: ToolParameters11,
+  execute: execute4
+});
+function getSkillsDescription() {
+  try {
+    return readFileSync5(agentsMarkdown, "utf8").replace("This repository contains", "This tool describes").replace(skillLinkRegex, "$1");
+  } catch {
+    return "Returns the contents of a Harper skill markdown file. Skills provide guidance on developing Harper applications.";
+  }
+}
+function getSkills() {
+  try {
+    return readdirSync(skillsDir).filter((file) => file.endsWith(".md")).map((file) => file.replace(".md", ""));
+  } catch {
+    return [];
+  }
+}
+async function execute4({ skill }) {
+  if (skill === "none") {
+    return "No skills found.";
+  }
+  try {
+    const filePath = join10(skillsDir, `${skill}.md`);
+    return readFileSync5(filePath, "utf8");
+  } catch (error) {
+    return `Error reading Harper skill "${skill}": ${error}`;
+  }
+}
+
+// tools/harper/hitHarperAPITool.ts
+import { tool as tool25 } from "@openai/agents";
+import { z as z25 } from "zod";
+var ToolParameters12 = z25.object({
+  method: z25.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: z25.string().optional().default("/openapi").describe("The path to fetch from localhost (defaults to /openapi)."),
+  port: z25.number().optional().default(harperProcess.httpPort).describe(
+    "The port to fetch from localhost (defaults to the running Harper port)."
+  ),
+  body: z25.string().optional().default("").describe("An optional JSON string body to send along with the request.")
+});
+var hitHarperAPITool = tool25({
+  name: "hitHarperAPITool",
+  description: "Performs a request against the running Harper API. Use /openapi to look up Harper APIs.",
+  parameters: ToolParameters12,
+  needsApproval: async (runContext, input, callId) => {
+    if (callId && runContext.isToolApproved({ toolName: "hitHarperAPITool", callId })) {
+      return false;
+    }
+    if (input.method === "DELETE") {
+      const segments = (input.path || "").split("/").filter(Boolean);
+      if (segments.length <= 1) {
+        return true;
+      }
+    }
+    return false;
+  },
+  async execute({ path: path7 = "/openapi", port, method = "GET", body }) {
+    try {
+      const effectivePort = port ?? (harperProcess.running ? harperProcess.httpPort : void 0);
+      if (!effectivePort) {
+        return `Error: No Harper application is currently running and no port was specified.`;
+      }
+      const response = await fetch(
+        `http://localhost:${effectivePort}${path7.startsWith("/") ? "" : "/"}${path7}`,
+        {
+          method,
+          headers: body ? { "Content-Type": "application/json" } : {},
+          body: body || null
+        }
+      );
+      if (!response.ok) {
+        return `Error: Received non-ok response from fetch: ${response.statusText} (${response.status})`;
+      }
+      return await response.text();
+    } catch (error) {
+      return `Error: fetch failed: ${error}`;
+    }
+  }
+});
+
+// tools/harper/openHarperInBrowserTool.ts
+import { tool as tool26 } from "@openai/agents";
+import spawn2 from "cross-spawn";
+import { platform } from "os";
+import { z as z26 } from "zod";
+var alreadyOpened = false;
+var ToolParameters13 = z26.object({});
+var openHarperInBrowserTool = tool26({
+  name: "openHarperInBrowserTool",
+  description: "Opens the running Harper app in the user's browser.",
+  parameters: ToolParameters13,
+  async execute() {
+    try {
+      if (alreadyOpened) {
+        return `Browser is already open.`;
+      }
+      if (!harperProcess.running) {
+        return `Error: No Harper application is currently running.`;
+      }
+      const url = `http://localhost:${harperProcess.httpPort}/`;
+      const p = platform();
+      if (p === "darwin") {
+        spawn2("open", [url]);
+      } else if (p === "win32") {
+        spawn2("start", ["", url]);
+      } else {
+        spawn2("xdg-open", [url]);
+      }
+      alreadyOpened = true;
+      return `Successfully opened '${url}' in the browser.`;
+    } catch (error) {
+      return `Error opening browser: ${error}`;
+    }
+  }
+});
+
+// tools/harper/readHarperLogsTool.ts
+import { tool as tool27 } from "@openai/agents";
+import { z as z27 } from "zod";
+var ToolParameters14 = z27.object({});
+var readHarperLogsTool = tool27({
+  name: "readHarperLogsTool",
+  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: ToolParameters14,
+  async execute() {
+    if (!harperProcess.running) {
+      return `Error: No Harper application is currently running.`;
+    }
+    try {
+      const logs = harperProcess.getAndClearLogs();
+      return logs || "No logs available yet.";
+    } catch (error) {
+      return `Error reading Harper application logs: ${error}`;
+    }
+  }
+});
+
+// tools/harper/startHarperTool.ts
+import { tool as tool28 } from "@openai/agents";
+import { existsSync as existsSync8 } from "fs";
+import { basename, resolve } from "path";
+import { z as z28 } from "zod";
+
+// utils/promises/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// tools/harper/startHarperTool.ts
+var ToolParameters15 = z28.object({
+  directoryName: z28.string().describe("The name of the directory that the Harper app is in.")
+});
+var startHarperTool = tool28({
+  name: "startHarperTool",
+  description: "Starts a Harper app background process, allowing you to observe the app in action (by readHarperLogsTool, hitHarperAPITool, openHarperInBrowserTool, etc).",
+  parameters: ToolParameters15,
+  async execute({ directoryName }) {
+    if (isIgnored(directoryName)) {
+      return `Error: Target directory ${directoryName} is restricted by .aiignore`;
+    }
+    if (harperProcess.running) {
+      return `Success! A Harper application is already running, and will auto-reload as changes are made.`;
+    }
+    try {
+      let effectiveDirectory = directoryName;
+      const candidatePath = resolve(process.cwd(), directoryName);
+      if (!existsSync8(candidatePath)) {
+        const cwd = process.cwd();
+        if (basename(cwd) === directoryName) {
+          effectiveDirectory = cwd;
+        }
+      }
+      harperProcess.start(effectiveDirectory);
+      await sleep(5e3);
+      const logs = harperProcess.getAndClearLogs();
+      return `Successfully started Harper application with auto-reload in '${effectiveDirectory}' with initial logs:
+${logs}`;
+    } catch (error) {
+      return `Error: failed to start Harper application: ${error}`;
+    }
+  }
+});
+
+// tools/harper/stopHarperTool.ts
+import { tool as tool29 } from "@openai/agents";
+import { z as z29 } from "zod";
+var ToolParameters16 = z29.object({});
+var stopHarperTool = tool29({
+  name: "stopHarperTool",
+  description: "Stops all previously started Harper app background process.",
+  parameters: ToolParameters16,
+  async execute() {
+    if (!harperProcess.running) {
+      return `Error: No Harper application is currently running.`;
+    }
+    try {
+      harperProcess.stop();
+      return `Successfully stopped Harper application.`;
+    } catch (error) {
+      return `Error stopping Harper application: ${error}`;
+    }
+  }
+});
+
+// tools/factory.ts
+function createTools() {
+  return [
+    changeCwdTool,
+    checkHarperStatusTool,
+    codeInterpreterTool,
+    createApplyPatchTool(),
+    createNewHarperApplicationTool,
+    egrepTool,
+    findTool,
+    getHarperConfigSchemaTool,
+    getHarperResourceInterfaceTool,
+    getHarperSchemaGraphQLTool,
+    getHarperSkillTool,
+    gitAddTool,
+    gitBranchTool,
+    gitCommitTool,
+    gitLogTool,
+    gitStashTool,
+    gitStatusTool,
+    gitWorkspaceTool,
+    hitHarperAPITool,
+    openHarperInBrowserTool,
+    readDirTool,
+    readFileTool,
+    readHarperLogsTool,
+    setInterpreterAutoApproveTool,
+    setPatchAutoApproveTool,
+    setShellAutoApproveTool,
+    shellTool,
+    startHarperTool,
+    stopHarperTool
+  ];
+}
+
+// utils/package/checkForUpdate.ts
+import chalk10 from "chalk";
+import spawn3 from "cross-spawn";
+
+// utils/package/getLatestVersion.ts
+async function getLatestVersion(packageName) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      signal: AbortSignal.timeout(1e3)
+      // 1 second timeout
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return data.version;
+  } catch {
+    return null;
+  }
+}
+
+// utils/package/isVersionNewer.ts
+function isVersionNewer(latest, current) {
+  const l = latest.split(".").map((x) => parseInt(x, 10));
+  const c = current.split(".").map((x) => parseInt(x, 10));
+  for (let i = 0; i < 3; i++) {
+    let latestNumber = l[i];
+    let currentNumber = c[i];
+    if (latestNumber === void 0 || currentNumber === void 0 || isNaN(latestNumber) || isNaN(currentNumber)) {
+      break;
+    }
+    if (latestNumber > currentNumber) {
+      return true;
+    }
+    if (latestNumber < currentNumber) {
+      return false;
+    }
+  }
+  return false;
+}
+
+// utils/package/checkForUpdate.ts
+async function checkForUpdate() {
+  const pkg = getOwnPackageJson();
+  const packageName = pkg.name;
+  const packageVersion = pkg.version;
+  if (process.env.HARPER_AGENT_SKIP_UPDATE) {
+    return packageVersion;
+  }
+  try {
+    const latestVersion = await getLatestVersion(packageName);
+    if (latestVersion && isVersionNewer(latestVersion, packageVersion)) {
+      console.log(
+        chalk10.yellow(
+          `
+A new version of ${chalk10.bold(packageName)} is available! (${chalk10.dim(packageVersion)} -> ${chalk10.green(latestVersion)})`
+        )
+      );
+      console.log(`Automatically updating to the latest version...
+`);
+      const lsResult = spawn3.sync("npm", ["cache", "npx", "ls", packageName], {
+        encoding: "utf8"
+      });
+      if (lsResult.stdout) {
+        const keys = lsResult.stdout.split("\n").map((line) => line.trim()).filter((line) => line.includes(":")).filter((line) => {
+          const [, pkgPart] = line.split(":");
+          return pkgPart && pkgPart.trim().startsWith(`${packageName}@`);
+        }).map((line) => line.split(":")[0].trim());
+        if (keys.length > 0) {
+          spawn3.sync("npm", ["cache", "npx", "rm", ...keys], {
+            stdio: "inherit"
+          });
+        }
+      }
+      const result = spawn3.sync("npx", ["-y", `${packageName}@latest`, ...process.argv.slice(2)], {
+        stdio: "inherit"
+      });
+      process.exit(result.status ?? 0);
+    }
+  } catch {
+  }
+  return packageVersion;
+}
+
+// utils/sessions/modelSettings.ts
+var modelSettings = {
+  parallelToolCalls: false,
+  text: {
+    verbosity: "low"
+  },
+  providerData: {
+    service_tier: trackedState.useFlexTier ? "flex" : "auto"
+  }
+};
+var compactionModelSettings = {
+  ...modelSettings,
+  text: {
+    verbosity: "medium"
+  }
+};
+
+// utils/shell/askQuestion.ts
+import { createInterface } from "readline/promises";
+
+// lifecycle/handleExit.ts
+async function handleExit() {
+  await cleanUpAndSayBye();
+  process.exit(0);
+}
+
+// utils/shell/askQuestion.ts
+async function askQuestion(query) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  rl.on("SIGINT", handleExit);
+  try {
+    const response = await rl.question(query);
+    console.log("");
+    return response;
+  } finally {
+    rl.close();
+  }
+}
+
+// utils/shell/ensureApiKey.ts
+import chalk11 from "chalk";
+
+// utils/arrays/excludeFalsy.ts
+function excludeFalsy(item) {
+  return !!item;
+}
+
+// utils/shell/askSecureQuestion.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { Writable } from "stream";
+async function askSecureQuestion(query) {
+  let muted = false;
+  const mutableStdout = new Writable({
+    write: function(chunk, encoding, callback) {
+      if (!muted) {
+        process.stdout.write(chunk, encoding);
+      }
+      callback();
+    }
+  });
+  const rl = createInterface2({
+    input: process.stdin,
+    output: mutableStdout,
+    terminal: true
+  });
+  rl.on("SIGINT", handleExit);
+  try {
+    const responsePromise = rl.question(query);
+    muted = true;
+    const response = await responsePromise;
+    muted = false;
+    console.log("");
+    return response;
+  } finally {
+    rl.close();
+  }
+}
+
+// utils/shell/ensureApiKey.ts
+async function ensureApiKey() {
+  const models = [
+    trackedState.model,
+    trackedState.compactionModel
+  ].filter(excludeFalsy);
+  const requiredEnvVars = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    if (model.startsWith("claude-")) {
+      requiredEnvVars.add("ANTHROPIC_API_KEY");
+    } else if (model.startsWith("gemini-")) {
+      requiredEnvVars.add("GOOGLE_GENERATIVE_AI_API_KEY");
+    } else if (model.startsWith("ollama-")) {
+    } else {
+      requiredEnvVars.add("OPENAI_API_KEY");
+    }
+  }
+  for (const envVar of requiredEnvVars) {
+    if (process.env[envVar]) {
+      continue;
+    }
+    let providerName = "OpenAI";
+    let keyUrl = "https://platform.openai.com/api-keys";
+    if (envVar === "ANTHROPIC_API_KEY") {
+      providerName = "Anthropic";
+      keyUrl = "https://console.anthropic.com/settings/keys";
+    } else if (envVar === "GOOGLE_GENERATIVE_AI_API_KEY") {
+      providerName = "Google AI";
+      keyUrl = "https://aistudio.google.com/app/apikey";
+    }
+    harperResponse(chalk11.red(`${envVar} is not set.`));
+    console.log(`To get started with ${providerName}, you'll need an API key.`);
+    console.log(`1. Grab a key from ${chalk11.cyan(keyUrl)}`);
+    console.log(`2. Enter it below and I'll save it to your ${chalk11.cyan(".env")} file.
+`);
+    const key = await askSecureQuestion(`${providerName} API Key: `);
+    if (!key) {
+      console.log(chalk11.red("No key provided. Exiting."));
+      process.exit(1);
+    }
+    await updateEnv(envVar, key);
+    console.log(chalk11.green("API key saved successfully!\n"));
+  }
+}
+
+// utils/sessions/createSession.ts
+import { MemorySession as MemorySession3 } from "@openai/agents";
+
+// lifecycle/trackCompaction.ts
+import chalk12 from "chalk";
+function trackCompaction(session) {
+  const originalRunCompaction = session.runCompaction.bind(session);
+  session.runCompaction = async (args) => {
+    const originalMessage = spinner.message;
+    spinner.message = "Compacting conversation history...";
+    const wasSpinning = spinner.isSpinning;
+    let timeout = null;
+    if (!wasSpinning) {
+      if (!trackedState.atStartOfLine) {
+        process.stdout.write("\n");
+        trackedState.atStartOfLine = true;
+      }
+      timeout = setTimeout(() => {
+        spinner.start();
+      }, 50);
+    }
+    try {
+      return await originalRunCompaction(args);
+    } catch (error) {
+      const err = error ?? {};
+      const name = err.name || "Error";
+      const message = err.message || String(err);
+      const code = err.code ? ` code=${err.code}` : "";
+      const status = err.status || err.statusCode || err.response?.status;
+      const statusStr = status ? ` status=${status}` : "";
+      const msgLower = (message || "").toLowerCase();
+      const isNoToolOutput = /no tool output found for function call/i.test(message || "");
+      const callIdMatch = typeof message === "string" ? message.match(/function call\s+(call_[A-Za-z0-9_-]+)/i) : null;
+      const callId = callIdMatch?.[1];
+      const isRateLimited = status === 429 || /rate limit|too many requests/i.test(message || "");
+      const isContextExceeded = status === 413 || /maximum context length|context length|too many tokens|token limit|reduce the length|content length/i.test(
+        msgLower
+      );
+      const isAuth = status === 401 || status === 403 || /invalid api key|unauthorized|permission/i.test(msgLower);
+      const isServer = typeof status === "number" && status >= 500 || /server error|temporary|timeout/i.test(msgLower);
+      const hintParts = [];
+      if (isNoToolOutput) {
+        hintParts.push(
+          `A previous tool call in the session history appears to be missing its tool result (orphaned tool call). Compaction cannot reference a tool call without a corresponding tool output. Ensure tools always return a structured object (e.g., { status, output }) and never throw. ` + (callId ? `Missing call id: ${callId}. ` : "") + `If this persists, consider truncating the session before the orphaned call or retrying the failing tool.`
+        );
+      }
+      if (isContextExceeded) {
+        hintParts.push(
+          `The compaction request likely exceeded the model's context window. Try using a compaction model with a larger context, reducing history, or increasing compaction aggressiveness.`
+        );
+      }
+      if (isRateLimited) {
+        hintParts.push(
+          `Rate limited by the provider. Back off and retry later, or lower compaction frequency.`
+        );
+      }
+      if (isAuth) {
+        hintParts.push(`Authentication/permissions issue. Verify the API key and model access for compaction.`);
+      }
+      if (isServer) {
+        hintParts.push(`Upstream server error. This is likely transient; retrying later may succeed.`);
+      }
+      const compactionCtx = `
+Context: compactionModel=${trackedState.compactionModel || "unknown"}`;
+      let argsSnippet = "";
+      try {
+        const s = typeof args === "string" ? args : JSON.stringify(args);
+        if (s) {
+          argsSnippet = `
+Compaction args: ${s.slice(0, 300)}${s.length > 300 ? "\u2026" : ""}`;
+        }
+      } catch {
+      }
+      const hint = hintParts.length ? `
+Hint (compaction): ${hintParts.join(" ")}` : "";
+      let responseDataSnippet = "";
+      const data = err.response?.data ?? err.data;
+      if (data) {
+        try {
+          const s = typeof data === "string" ? data : JSON.stringify(data);
+          responseDataSnippet = `
+Response data: ${s.slice(0, 500)}${s.length > 500 ? "\u2026" : ""}`;
+        } catch {
+        }
+      }
+      const stack = err.stack ? `
+Stack: ${String(err.stack).split("\n").slice(0, 8).join("\n")}` : "";
+      const composed = `${name}:${code}${statusStr} ${message}${hint}${compactionCtx}${argsSnippet}${responseDataSnippet}${stack}`;
+      harperResponse(chalk12.red(composed));
+      trackedState.atStartOfLine = true;
+      return void 0;
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      if (!wasSpinning) {
+        spinner.stop();
+      }
+      spinner.message = originalMessage;
+    }
+  };
+}
+
+// utils/sessions/DiskSession.ts
+import { MemorySession } from "@openai/agents";
+import sqlite3 from "sqlite3";
+var DiskSession = class extends MemorySession {
+  db;
+  ready;
+  useJsonb = false;
+  constructor(dbPath, options) {
+    super(options);
+    this.db = new sqlite3.Database(dbPath);
+    this.ready = this.init(options);
+  }
+  async init(options) {
+    await this.run(`
+			CREATE TABLE IF NOT EXISTS session_items (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				sessionId TEXT,
+				data JSONB
+			)
+		`);
+    try {
+      await this.get("SELECT jsonb('{}')");
+      this.useJsonb = true;
+    } catch {
+      this.useJsonb = false;
+    }
+    let sessionId = this.sessionId;
+    if (!options?.sessionId) {
+      const row = await this.get("SELECT DISTINCT sessionId FROM session_items LIMIT 1");
+      if (row) {
+        sessionId = row.sessionId;
+        this.sessionId = sessionId;
+      }
+    }
+    if (!sessionId) {
+      sessionId = this.sessionId || "default-session";
+    }
+    const rows = await this.all(
+      "SELECT json(data) AS data FROM session_items WHERE sessionId = ? ORDER BY id ASC",
+      sessionId
+    );
+    if (rows.length > 0) {
+      const itemsFromDb = rows.map((row) => JSON.parse(row.data));
+      this.items = itemsFromDb;
+    } else {
+      const items = this.items || [];
+      if (items.length > 0) {
+        const sql = this.useJsonb ? "INSERT INTO session_items (sessionId, data) VALUES (?, jsonb(?))" : "INSERT INTO session_items (sessionId, data) VALUES (?, ?)";
+        for (const item of items) {
+          await this.run(sql, sessionId, JSON.stringify(item));
+        }
+      }
+    }
+  }
+  async getSessionId() {
+    await this.ready;
+    return super.getSessionId();
+  }
+  async getItems(limit) {
+    await this.ready;
+    return super.getItems(limit);
+  }
+  async addItems(items) {
+    await this.ready;
+    await super.addItems(items);
+    const sessionId = await this.getSessionId();
+    const sql = this.useJsonb ? "INSERT INTO session_items (sessionId, data) VALUES (?, jsonb(?))" : "INSERT INTO session_items (sessionId, data) VALUES (?, ?)";
+    for (const item of items) {
+      await this.run(sql, sessionId, JSON.stringify(item));
+    }
+  }
+  async popItem() {
+    await this.ready;
+    const item = await super.popItem();
+    if (item) {
+      const sessionId = await this.getSessionId();
+      await this.run(
+        `
+				DELETE FROM session_items
+				WHERE id = (
+					SELECT id FROM session_items
+					WHERE sessionId = ?
+					ORDER BY id DESC
+					LIMIT 1
+				)
+			`,
+        sessionId
+      );
+    }
+    return item;
+  }
+  async clearSession() {
+    await this.ready;
+    await super.clearSession();
+    const sessionId = await this.getSessionId();
+    await this.run("DELETE FROM session_items WHERE sessionId = ?", sessionId);
+  }
+  run(sql, ...params) {
+    return new Promise((resolve2, reject) => {
+      this.db.run(sql, ...params, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve2();
+        }
+      });
+    });
+  }
+  get(sql, ...params) {
+    return new Promise((resolve2, reject) => {
+      this.db.get(sql, ...params, (err, row) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve2(row);
+        }
+      });
+    });
+  }
+  all(sql, ...params) {
+    return new Promise((resolve2, reject) => {
+      this.db.all(sql, ...params, (err, rows) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve2(rows);
+        }
+      });
+    });
+  }
+};
+
+// utils/sessions/MemoryCompactionSession.ts
+import {
+  MemorySession as MemorySession2
+} from "@openai/agents";
+
+// utils/sessions/compactConversation.ts
+import { Agent as Agent2, run, system } from "@openai/agents";
+async function compactConversation(items) {
+  const firstItem = items[0];
+  const recentItems = items.slice(-3);
+  const itemsToCompact = items.slice(1, -3);
+  let noticeContent = "... conversation history compacted ...";
+  if (trackedState.compactionModel && itemsToCompact.length > 0) {
+    try {
+      const agent = new Agent2({
+        name: "History Compactor",
+        model: isOpenAIModel(trackedState.compactionModel) ? trackedState.compactionModel : getModel(trackedState.compactionModel),
+        modelSettings: compactionModelSettings,
+        instructions: "Summarize the conversation history so far into a single concise paragraph. Focus on the key facts and decisions made."
+      });
+      const result = await run(
+        agent,
+        itemsToCompact
+      );
+      const summary = result.finalOutput;
+      if (summary && summary.trim().length > 0) {
+        const s = summary.replace(/\s+/g, " ").trim();
+        noticeContent = `... conversation history compacted: ${s} ...`;
+      }
+    } catch (err) {
+      const msg = String(err?.message || err || "");
+      const isNoTrace = /no existing trace found/i.test(msg) || /setCurrentSpan/i.test(msg);
+      if (!isNoTrace) {
+        console.warn("Compaction summarization failed:", msg);
+      }
+    }
+  }
+  const itemsToAdd = [firstItem, system(noticeContent), ...recentItems].filter(excludeFalsy);
+  return { noticeContent, itemsToAdd };
+}
+
+// utils/sessions/modelContextLimits.ts
+function getModelContextLimit(modelName) {
+  if (!modelName) {
+    return DEFAULT_LIMIT;
+  }
+  const name = modelName.toLowerCase();
+  if (name.startsWith("gpt-4o") || name.startsWith("gpt-5")) {
+    return 2e5;
+  }
+  if (name.startsWith("gpt-4")) {
+    return 128e3;
+  }
+  if (name.startsWith("claude-3.5") || name.startsWith("claude-3")) {
+    return 2e5;
+  }
+  if (name.startsWith("gemini-1.5")) {
+    return 1e6;
+  }
+  if (name.startsWith("gemini-")) {
+    return 128e3;
+  }
+  if (name.startsWith("ollama-")) {
+    return 8e3;
+  }
+  return DEFAULT_LIMIT;
+}
+function getCompactionTriggerTokens(modelName, fraction = 0.5) {
+  const limit = getModelContextLimit(modelName);
+  const f = Math.min(Math.max(fraction, 0.5), 0.95);
+  return Math.floor(limit * f);
+}
+var DEFAULT_LIMIT = 128e3;
+
+// utils/sessions/MemoryCompactionSession.ts
+var MemoryCompactionSession = class {
+  underlyingSession;
+  triggerTokens;
+  itemsAddedSinceLastCompaction = 0;
+  constructor(options) {
+    this.underlyingSession = options.underlyingSession ?? new MemorySession2();
+    if (trackedState.compactionModel) {
+      const fraction = options.triggerFraction ?? 0.5;
+      this.triggerTokens = getCompactionTriggerTokens(trackedState.compactionModel, fraction);
+    }
+  }
+  async getSessionId() {
+    return this.underlyingSession.getSessionId();
+  }
+  async getItems(limit) {
+    return this.underlyingSession.getItems(limit);
+  }
+  async addItems(items) {
+    await this.underlyingSession.addItems(items);
+    this.itemsAddedSinceLastCompaction += items.length;
+    await this.runCompaction({ reason: "post-add-check", mode: "auto" });
+  }
+  async popItem() {
+    return this.underlyingSession.popItem();
+  }
+  async clearSession() {
+    this.itemsAddedSinceLastCompaction = 0;
+    await this.underlyingSession.clearSession();
+  }
+  /**
+   * Compaction entry point used by the underlying agent.
+   * This method first decides if compaction is necessary (token-aware gating),
+   * and only then performs the compaction. External callers should invoke this
+   * method directly; there is no separate "maybe" helper anymore.
+   *
+   * Behavior:
+   * - If a token trigger threshold is configured (via modelName), compaction is
+   *   skipped unless the estimated token count exceeds the threshold, unless a
+   *   forcing flag is provided in args.
+   * - If history is trivially small (<= 4 items), it skips compaction.
+   * - Otherwise, it keeps the first item, adds a compaction notice (optionally
+   *   summarized by the model), and retains the last 3 recent items.
+   */
+  async runCompaction(args) {
+    const items = await this.underlyingSession.getItems();
+    if (items.length <= 1) {
+      return null;
+    }
+    const force = !!args?.force || !!args?.always || args?.trigger === "force";
+    if (!force && this.triggerTokens && this.triggerTokens > 0) {
+      const tokenEstimate = estimateTokens(items);
+      if (tokenEstimate < this.triggerTokens) {
+        return null;
+      }
+    }
+    if (items.length <= 4) {
+      return null;
+    }
+    const { itemsToAdd } = await compactConversation(items);
+    this.itemsAddedSinceLastCompaction = 0;
+    await this.underlyingSession.clearSession();
+    await this.underlyingSession.addItems(itemsToAdd.filter(excludeFalsy));
+    return null;
+  }
+};
+function estimateTokens(items) {
+  let chars = 0;
+  for (const it of items) {
+    if (!it) {
+      continue;
+    }
+    if (Array.isArray(it.content)) {
+      for (const c of it.content) {
+        if (!c) {
+          continue;
+        }
+        if (typeof c.text === "string") {
+          chars += c.text.length;
+        } else if (typeof c.content === "string") {
+          chars += c.content.length;
+        } else if (typeof c === "string") {
+          chars += c.length;
+        }
+      }
+    }
+    if (typeof it.content === "string") {
+      chars += it.content.length;
+    }
+    if (typeof it.text === "string") {
+      chars += it.text.length;
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+
+// utils/sessions/createSession.ts
+function createSession(sessionPath = null) {
+  const underlyingSession = sessionPath ? new DiskSession(sessionPath) : new MemorySession3();
+  const session = new MemoryCompactionSession({
+    underlyingSession
+  });
+  trackCompaction(session);
+  return session;
+}
+
+// agent.ts
+var argumentTruncationPoint = 100;
+process.on("SIGINT", handleExit);
+process.on("SIGTERM", handleExit);
+async function main() {
+  process.on("SIGINT", async () => {
+    await cleanUpAndSayBye();
+    process.exit(0);
+  });
+  await checkForUpdate();
+  parseArgs();
+  await ensureApiKey();
+  sayHi();
+  const agent = trackedState.agent = new Agent3({
+    name: "Harper App Development Assistant",
+    model: isOpenAIModel(trackedState.model) ? trackedState.model : getModel(trackedState.model),
+    modelSettings,
+    instructions: readAgentsMD() || defaultInstructions(),
+    tools: createTools()
+  });
+  const session = createSession(trackedState.sessionPath);
+  while (true) {
+    let task = "";
+    let lastToolCallInfo = null;
+    trackedState.controller = new AbortController();
+    if (!trackedState.approvalState) {
+      task = await askQuestion("> ");
+      if (!task) {
+        trackedState.emptyLines += 1;
+        if (trackedState.emptyLines >= 2) {
+          return handleExit();
+        }
+        continue;
+      }
+      trackedState.emptyLines = 0;
+      process.stdout.write("\n");
+    }
+    spinner.start();
+    try {
+      const stream = await run2(agent, trackedState.approvalState ?? task, {
+        session,
+        stream: true,
+        signal: trackedState.controller.signal,
+        maxTurns: 30
+      });
+      trackedState.approvalState = null;
+      let hasStartedResponse = false;
+      trackedState.atStartOfLine = true;
+      for await (const event of stream) {
+        switch (event.type) {
+          case "raw_model_stream_event":
+            const data = event.data;
+            switch (data.type) {
+              case "response_started":
+                if (!trackedState.atStartOfLine) {
+                  process.stdout.write("\n");
+                  trackedState.atStartOfLine = true;
+                }
+                spinner.start();
+                break;
+              case "output_text_delta":
+                spinner.stop();
+                if (!hasStartedResponse) {
+                  process.stdout.write(`${chalk13.bold("Harper:")} `);
+                  hasStartedResponse = true;
+                }
+                process.stdout.write(chalk13.cyan(data.delta));
+                trackedState.atStartOfLine = data.delta.endsWith("\n");
+                break;
+              case "response_done":
+                const tier = data.response?.providerData?.service_tier || data.providerData?.service_tier;
+                if (tier) {
+                  stream.state.usage.serviceTier = tier;
+                  const entries = stream.state.usage.requestUsageEntries;
+                  if (entries && entries.length > 0) {
+                    entries[entries.length - 1].serviceTier = tier;
+                  }
+                }
+                spinner.stop();
+                trackedState.atStartOfLine = true;
+                break;
+            }
+            break;
+          case "agent_updated_stream_event":
+            spinner.stop();
+            console.log(
+              `
+${chalk13.magenta("\u{1F464}")} ${chalk13.bold("Agent switched to:")} ${chalk13.italic(event.agent.name)}`
+            );
+            trackedState.atStartOfLine = true;
+            spinner.start();
+            break;
+          case "run_item_stream_event":
+            if (event.name === "tool_called") {
+              spinner.stop();
+              const item = event.item.rawItem ?? event.item;
+              const name = item.name || item.type || "tool";
+              let args = typeof item.arguments === "string" ? item.arguments : item.arguments ? JSON.stringify(item.arguments) : "";
+              if (!args && item.type === "shell_call" && item.action?.commands) {
+                args = JSON.stringify(item.action.commands);
+              }
+              if (!args && item.type === "apply_patch_call" && item.operation) {
+                args = JSON.stringify(item.operation);
+              }
+              const displayedArgs = args ? `(${args.slice(0, argumentTruncationPoint)}${args.length > argumentTruncationPoint ? "..." : ""})` : "()";
+              console.log(`
+${chalk13.yellow("\u{1F6E0}\uFE0F")}  ${chalk13.cyan(name)}${chalk13.dim(displayedArgs)}`);
+              lastToolCallInfo = `${name}${displayedArgs}`;
+              trackedState.atStartOfLine = true;
+              if (!stream.interruptions?.length) {
+                spinner.start();
+              }
+            }
+            break;
+        }
+        spinner.status = costTracker.getStatusString(
+          stream.state.usage,
+          trackedState.model || "gpt-5.2",
+          trackedState.compactionModel || "gpt-4o-mini"
+        );
+      }
+      if (stream.interruptions?.length) {
+        for (const interruption of stream.interruptions) {
+          spinner.stop();
+          console.log(
+            chalk13.bold.bgYellow.black("\nTool approval required (see above):")
+          );
+          const answer = await askQuestion(`	Proceed? [y/N] `);
+          const approved = answer.trim().toLowerCase();
+          const ok = approved === "y" || approved === "yes" || approved === "ok" || approved === "k";
+          if (ok) {
+            stream.state.approve(interruption);
+          } else {
+            stream.state.reject(interruption);
+          }
+        }
+        trackedState.approvalState = stream.state;
+      }
+      spinner.stop();
+      if (!trackedState.atStartOfLine || hasStartedResponse) {
+        process.stdout.write("\n\n");
+      }
+      if (!trackedState.approvalState) {
+        costTracker.recordTurn(
+          trackedState.model || "gpt-5.2",
+          stream.state.usage,
+          trackedState.compactionModel || "gpt-4o-mini"
+        );
+      }
+    } catch (error) {
+      spinner.stop();
+      process.stdout.write("\n");
+      const err = error ?? {};
+      const name = err.name || "Error";
+      const message = err.message || String(err);
+      const code = err.code ? ` code=${err.code}` : "";
+      const status = err.status || err.statusCode || err.response?.status;
+      const statusStr = status ? ` status=${status}` : "";
+      const callIdMatch = message.match(/function call\s+(call_[A-Za-z0-9_-]+)/i);
+      const callId = callIdMatch?.[1];
+      const isNoToolOutput = /No tool output found for function call/i.test(message || "");
+      const hint = isNoToolOutput ? `
+Hint: A tool likely threw or returned no result. Ensure tools always return a structured object (e.g., { status, output }) and never throw. If this followed a tool call${callId ? ` (${callId})` : ""}${lastToolCallInfo ? `: ${lastToolCallInfo}` : ""}, review that tool's implementation and logs.` : "";
+      let responseDataSnippet = "";
+      const data = err.response?.data ?? err.data;
+      if (data) {
+        try {
+          const s = typeof data === "string" ? data : JSON.stringify(data);
+          responseDataSnippet = `
+Response data: ${s.slice(0, 500)}${s.length > 500 ? "\u2026" : ""}`;
+        } catch {
+        }
+      }
+      const stack = err.stack ? `
+Stack: ${String(err.stack).split("\n").slice(0, 8).join("\n")}` : "";
+      const lastTool = lastToolCallInfo ? `
+Last tool call: ${lastToolCallInfo}` : "";
+      const composed = `${name}:${code}${statusStr} ${message}${hint}${lastTool}${responseDataSnippet}${stack}`;
+      harperResponse(chalk13.red(composed));
+      trackedState.atStartOfLine = true;
+      trackedState.approvalState = null;
+    }
+  }
+}
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});