open-agents-ai 0.142.2 → 0.144.0

package/dist/index.js

@@ -1370,7 +1370,7 @@ ${stdinInput ?? ""}`);
       }
       runCommand(command, timeout, stdinInput) {
         const start = performance.now();
-        return new Promise((resolve32) => {
+        return new Promise((resolve33) => {
           const child = spawn("bash", ["-c", command], {
             cwd: this.workingDir,
             env: {
@@ -1395,7 +1395,7 @@ ${stdinInput ?? ""}`);
             clearTimeout(timer);
             if (exitFlushTimer)
               clearTimeout(exitFlushTimer);
-            resolve32(result);
+            resolve33(result);
           };
           const timer = setTimeout(() => {
             killed = true;
@@ -1492,6 +1492,61 @@ ${stderr}` : ""),
 // packages/execution/dist/tools/file-read.js
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
+function computeMaxUngatedLines(contextWindow) {
+  if (contextWindow <= 0)
+    return 200;
+  const budget = Math.floor(contextWindow * 0.15);
+  const maxLines = Math.floor(budget / 10);
+  return Math.max(80, Math.min(500, maxLines));
+}
+function buildStructuralPreview(lines, filePath, maxLines) {
+  const total = lines.length;
+  const HEAD = Math.min(30, Math.floor(maxLines * 0.35));
+  const TAIL = Math.min(15, Math.floor(maxLines * 0.15));
+  const parts = [];
+  parts.push(`# ${filePath} \u2014 ${total} lines (showing structural preview)
+`);
+  parts.push(`## Lines 1-${HEAD}:`);
+  for (let i = 0; i < HEAD; i++) {
+    parts.push(`${String(i + 1).padStart(6)} | ${lines[i]}`);
+  }
+  const sigs = [];
+  for (let i = HEAD; i < total - TAIL; i++) {
+    const line = lines[i];
+    if (SIG_PATTERNS.some((p) => p.test(line))) {
+      sigs.push(`${String(i + 1).padStart(6)} | ${line}`);
+    }
+  }
+  if (sigs.length > 0) {
+    parts.push(`
+## Signatures (lines ${HEAD + 1}-${total - TAIL}) \u2014 ${sigs.length} found:`);
+    const maxSigs = Math.floor(maxLines * 0.4);
+    if (sigs.length > maxSigs) {
+      parts.push(...sigs.slice(0, maxSigs));
+      parts.push(`  ... ${sigs.length - maxSigs} more signatures`);
+    } else {
+      parts.push(...sigs);
+    }
+  } else {
+    parts.push(`
+## Lines ${HEAD + 1}-${total - TAIL}: ${total - HEAD - TAIL} lines (no signatures detected)`);
+  }
+  if (TAIL > 0) {
+    const tailStart = total - TAIL;
+    parts.push(`
+## Lines ${tailStart + 1}-${total}:`);
+    for (let i = tailStart; i < total; i++) {
+      parts.push(`${String(i + 1).padStart(6)} | ${lines[i]}`);
+    }
+  }
+  parts.push(``);
+  parts.push(`To read a specific section: file_read(path="${filePath}", offset=LINE, limit=50)`);
+  parts.push(`To search for a pattern: grep_search(pattern="...", path="${filePath}")`);
+  if (sigs.length > 0) {
+    parts.push(`To explore interactively: file_explore(strategy="search", path="${filePath}", query="...")`);
+  }
+  return parts.join("\n");
+}
 function extractPath(args) {
   if (typeof args["path"] === "string" && args["path"].trim()) {
     return args["path"].trim();
@@ -1516,13 +1571,25 @@ function extractPath(args) {
   }
   return null;
 }
-var FileReadTool;
+var SIG_PATTERNS, FileReadTool;
 var init_file_read = __esm({
   "packages/execution/dist/tools/file-read.js"() {
     "use strict";
+    SIG_PATTERNS = [
+      /^\s*(export\s+)?(async\s+)?function\s+\w+/,
+      /^\s*(export\s+)?(abstract\s+)?class\s+\w+/,
+      /^\s*(export\s+)?interface\s+\w+/,
+      /^\s*(export\s+)?type\s+\w+\s*=/,
+      /^\s*(export\s+)?enum\s+\w+/,
+      /^\s*(?:public|private|protected|static|async|get|set)\s+\w+\s*[(<]/,
+      /^\s*(pub\s+)?(async\s+)?fn\s+\w+/,
+      /^\s*(pub\s+)?struct\s+\w+/,
+      /^\s*def\s+\w+/,
+      /^\s*class\s+\w+/
+    ];
     FileReadTool = class {
       name = "file_read";
-      description = "Read the contents of a file";
+      description = "Read the contents of a file. For large files (200+ lines), returns a structural preview with signatures \u2014 use offset/limit to read specific sections.";
       parameters = {
         type: "object",
         properties: {
@@ -1537,7 +1604,7 @@ var init_file_read = __esm({
       constructor(workingDir) {
         this.workingDir = workingDir;
       }
-      /** Set actual context window size to enable auto-windowing for small contexts */
+      /** Set actual context window size for proportional auto-windowing */
       setContextWindowSize(size) {
         this._contextWindowSize = size;
       }
@@ -1559,24 +1626,25 @@ var init_file_read = __esm({
           const content = await readFile(fullPath, "utf-8");
           let lines = content.split("\n");
           const totalLines = lines.length;
-          if (offset !== void 0) {
-            const startIdx = Math.max(0, offset - 1);
+          if (offset !== void 0 || limit !== void 0) {
+            const startIdx = Math.max(0, (offset ?? 1) - 1);
             lines = lines.slice(startIdx, limit ? startIdx + limit : void 0);
-          } else if (this._contextWindowSize > 0 && this._contextWindowSize <= 32768 && !limit) {
-            const maxLines = this._contextWindowSize <= 16384 ? 80 : 120;
-            if (totalLines > maxLines) {
-              lines = lines.slice(0, maxLines);
-              const numbered2 = lines.map((line, i) => `${String(i + 1).padStart(6)} | ${line}`).join("\n");
-              return {
-                success: true,
-                output: `${numbered2}
-
-[File has ${totalLines} lines \u2014 showing first ${maxLines}. Use offset/limit to see more.]`,
-                durationMs: performance.now() - start
-              };
-            }
+            const numbered2 = lines.map((line, i) => `${String(startIdx + i + 1).padStart(6)} | ${line}`).join("\n");
+            return {
+              success: true,
+              output: numbered2,
+              durationMs: performance.now() - start
+            };
+          }
+          const maxLines = computeMaxUngatedLines(this._contextWindowSize);
+          if (totalLines > maxLines) {
+            return {
+              success: true,
+              output: buildStructuralPreview(lines, filePath, maxLines),
+              durationMs: performance.now() - start
+            };
           }
-          const numbered = lines.map((line, i) => `${String(i + (offset ?? 1)).padStart(6)} | ${line}`).join("\n");
+          const numbered = lines.map((line, i) => `${String(i + 1).padStart(6)} | ${line}`).join("\n");
           return {
             success: true,
             output: numbered,
@@ -2556,7 +2624,7 @@ ${JSON.stringify(extracted, null, 2)}`);
         return null;
       }
       runProcess(cmd, args, timeoutMs) {
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           const proc = execFile3(cmd, args, {
             timeout: timeoutMs,
             maxBuffer: 10 * 1024 * 1024,
@@ -2566,7 +2634,7 @@ ${JSON.stringify(extracted, null, 2)}`);
               reject(new Error(`Process timeout after ${timeoutMs}ms`));
               return;
             }
-            resolve32({
+            resolve33({
               stdout: String(stdout),
               stderr: String(stderr),
               exitCode: error ? error.code ?? 1 : 0
@@ -9975,7 +10043,7 @@ var init_custom_tool = __esm({
       }
       /** Execute a single shell command and return output */
       runCommand(command) {
-        return new Promise((resolve32) => {
+        return new Promise((resolve33) => {
           const child = spawn4("bash", ["-c", command], {
             cwd: this.workingDir,
             env: { ...process.env, CI: "true", NO_COLOR: "1" },
@@ -10000,11 +10068,11 @@ var init_custom_tool = __esm({
               child.kill("SIGTERM");
             } catch {
             }
-            resolve32({ success: false, output: stdout, error: "Command timed out after 60s" });
+            resolve33({ success: false, output: stdout, error: "Command timed out after 60s" });
           }, 6e4);
           child.on("close", (code) => {
             clearTimeout(timer);
-            resolve32({
+            resolve33({
               success: code === 0,
               output: stdout + (stderr && code === 0 ? `
 STDERR:
@@ -10014,7 +10082,7 @@ ${stderr}` : ""),
           });
           child.on("error", (err) => {
             clearTimeout(timer);
-            resolve32({ success: false, output: stdout, error: err.message });
+            resolve33({ success: false, output: stdout, error: err.message });
           });
         });
       }
@@ -11481,7 +11549,7 @@ import { writeFile as writeFile8, mkdtemp, rm, readdir as readdir3, stat } from
 import { join as join18 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 function runProcess(cmd, args, options) {
-  return new Promise((resolve32) => {
+  return new Promise((resolve33) => {
     const proc = spawn6(cmd, args, {
       cwd: options.cwd,
       timeout: options.timeout,
@@ -11511,7 +11579,7 @@ function runProcess(cmd, args, options) {
       }
     });
     proc.on("error", (err) => {
-      resolve32({
+      resolve33({
         stdout,
         stderr: stderr || err.message,
         exitCode: 1,
@@ -11523,7 +11591,7 @@ function runProcess(cmd, args, options) {
       if (signal === "SIGTERM" || signal === "SIGKILL") {
         timedOut = true;
       }
-      resolve32({
+      resolve33({
         stdout,
         stderr,
         exitCode: code ?? (timedOut ? 124 : 1),
@@ -12006,7 +12074,7 @@ Justification: ${justification || "(none provided)"}`,
             })();
             const ipfsResult = await Promise.race([
               ipfsPromise,
-              new Promise((resolve32) => setTimeout(() => resolve32(null), 2e3))
+              new Promise((resolve33) => setTimeout(() => resolve33(null), 2e3))
             ]);
             if (ipfsResult && ipfsResult.success) {
               const cidData = JSON.parse(ipfsResult.output);
@@ -12450,7 +12518,7 @@ print("__OA_REPL_READY__")
           return;
         const sockId = randomBytes3(8).toString("hex");
         this.ipcPath = join20(tmpdir3(), `oa-repl-ipc-${sockId}.sock`);
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           this.ipcServer = createServer((conn) => {
             let buffer = new Uint8Array(0);
             conn.on("data", (chunk) => {
@@ -12466,7 +12534,7 @@ print("__OA_REPL_READY__")
             });
           });
           this.ipcServer.on("error", reject);
-          this.ipcServer.listen(this.ipcPath, () => resolve32());
+          this.ipcServer.listen(this.ipcPath, () => resolve33());
         });
       }
       async processIpcBuffer(conn, input) {
@@ -12529,9 +12597,9 @@ print("__OA_REPL_READY__")
       }
       // ── Code execution ─────────────────────────────────────────────────────
       executeCode(code, isInit = false) {
-        return new Promise((resolve32) => {
+        return new Promise((resolve33) => {
           if (!this.proc?.stdin || !this.proc?.stdout || !this.proc?.stderr) {
-            resolve32({ success: false, output: "REPL process not available", error: "No process", durationMs: 0 });
+            resolve33({ success: false, output: "REPL process not available", error: "No process", durationMs: 0 });
             return;
           }
           const sentinel = `__OA_SENTINEL_${randomBytes3(6).toString("hex")}__`;
@@ -12541,7 +12609,7 @@ print("__OA_REPL_READY__")
           const timeout = setTimeout(() => {
             if (!resolved) {
               resolved = true;
-              resolve32({
+              resolve33({
                 success: false,
                 output: stdout || "Execution timed out",
                 error: `Timeout after ${this.execTimeout / 1e3}s`,
@@ -12558,13 +12626,13 @@ print("__OA_REPL_READY__")
               if (isInit) {
                 const ready = cleanOutput.includes("__OA_REPL_READY__");
                 const displayOutput = cleanOutput.replace("__OA_REPL_READY__", "").trim();
-                resolve32({
+                resolve33({
                   success: ready,
                   output: displayOutput || "REPL initialized",
                   durationMs: 0
                 });
               } else {
-                resolve32({
+                resolve33({
                   success: true,
                   output: cleanOutput || "(no output)",
                   durationMs: 0
@@ -12573,7 +12641,7 @@ print("__OA_REPL_READY__")
             }
             if (stdout.length > 2e5) {
               cleanup();
-              resolve32({
+              resolve33({
                 success: true,
                 output: stdout.slice(0, 2e5) + "\n[output truncated at 200KB]",
                 durationMs: 0
@@ -16812,6 +16880,7 @@ train.py reverted to last kept state. Ready for next experiment.`,
 import { execSync as execSync18, exec as execCb } from "node:child_process";
 import { readFile as readFile15, writeFile as writeFile15, mkdir as mkdir11 } from "node:fs/promises";
 import { resolve as resolve22, join as join32 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 import { randomBytes as randomBytes4 } from "node:crypto";
 function isValidCron(expr) {
   const parts = expr.trim().split(/\s+/);
@@ -16941,6 +17010,31 @@ async function saveStore(workingDir, store) {
   store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   await writeFile15(join32(dir, "tasks.json"), JSON.stringify(store, null, 2), "utf-8");
 }
+function globalStoreDir() {
+  return join32(homedir8(), ".open-agents", "scheduled");
+}
+async function loadGlobalStore() {
+  try {
+    const raw = await readFile15(join32(globalStoreDir(), "tasks.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { tasks: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function saveGlobalStore(store) {
+  const dir = globalStoreDir();
+  await mkdir11(dir, { recursive: true });
+  await mkdir11(join32(dir, "logs"), { recursive: true });
+  store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile15(join32(dir, "tasks.json"), JSON.stringify(store, null, 2), "utf-8");
+}
+async function loadAllStores(workingDir) {
+  const [local, global] = await Promise.all([
+    loadStore(workingDir),
+    loadGlobalStore()
+  ]);
+  return { local, global };
+}
 var SCHEDULE_PRESETS, CRON_MARKER, SchedulerTool;
 var init_scheduler = __esm({
   "packages/execution/dist/tools/scheduler.js"() {
@@ -16964,7 +17058,7 @@ var init_scheduler = __esm({
     CRON_MARKER = "# OPEN-AGENTS-SCHEDULED:";
     SchedulerTool = class {
       name = "scheduler";
-      description = "Schedule tasks for automatic future execution using OS-level cron. Actions: 'create' a new scheduled task, 'list' all scheduled tasks, 'cancel' a task by ID, 'pause'/'resume' a task. Schedules: use presets ('daily', 'every 5 minutes', 'hourly', 'weekly'), natural language ('in 30m', 'at 14:30'), or raw cron expressions ('0 */2 * * *'). Tasks launch the agent automatically at the scheduled time.";
+      description = "Schedule tasks for automatic future execution using OS-level cron. Actions: 'create' a new scheduled task, 'list' all scheduled tasks, 'cancel' a task by ID, 'pause'/'resume' a task. Schedules: use presets ('daily', 'every 5 minutes', 'hourly', 'weekly'), natural language ('in 30m', 'at 14:30'), or raw cron expressions ('0 */2 * * *'). Scope: 'local' (default, stored in .oa/) or 'global' (stored in ~/.open-agents/, visible from all projects). Tasks launch the agent automatically at the scheduled time.";
       parameters = {
         type: "object",
         properties: {
@@ -16992,6 +17086,11 @@ var init_scheduler = __esm({
           one_shot: {
             type: "boolean",
             description: "If true, task auto-removes after first execution"
+          },
+          scope: {
+            type: "string",
+            enum: ["local", "global"],
+            description: "Scope: 'local' (project .oa/, default) or 'global' (~/.open-agents/, visible from all projects)"
           }
         },
         required: ["action"]
@@ -17053,6 +17152,7 @@ var init_scheduler = __esm({
         const id = `sched-${randomBytes4(4).toString("hex")}`;
         const oneShot = Boolean(args["one_shot"]);
         const maxRuns = typeof args["max_runs"] === "number" ? args["max_runs"] : void 0;
+        const scope = String(args["scope"] ?? "local");
         const newTask = {
           id,
           task,
@@ -17062,11 +17162,19 @@ var init_scheduler = __esm({
           enabled: true,
           runCount: 0,
           maxRuns,
-          oneShot: oneShot || void 0
+          oneShot: oneShot || void 0,
+          scope,
+          projectDir: resolve22(this.workingDir)
         };
-        const store = await loadStore(this.workingDir);
-        store.tasks.push(newTask);
-        await saveStore(this.workingDir, store);
+        if (scope === "global") {
+          const store = await loadGlobalStore();
+          store.tasks.push(newTask);
+          await saveGlobalStore(store);
+        } else {
+          const store = await loadStore(this.workingDir);
+          store.tasks.push(newTask);
+          await saveStore(this.workingDir, store);
+        }
         installCronJob(newTask, this.workingDir);
         return {
           success: true,
@@ -17075,6 +17183,7 @@ var init_scheduler = __esm({
             `  ID: ${id}`,
             `  Task: ${task}`,
             `  Schedule: ${describeCron(cronExpr)} (${cronExpr})`,
+            `  Scope: ${scope}${scope === "global" ? " (visible from all projects)" : " (this project only)"}`,
             oneShot ? `  Mode: one-shot (auto-removes after first run)` : "",
             maxRuns ? `  Max runs: ${maxRuns}` : "",
             `  Status: enabled`,
@@ -17086,28 +17195,53 @@ var init_scheduler = __esm({
         };
       }
       async listTasks(start) {
-        const store = await loadStore(this.workingDir);
+        const { local, global } = await loadAllStores(this.workingDir);
         const cronJobs = listCronJobs();
-        if (store.tasks.length === 0) {
+        const totalCount = local.tasks.length + global.tasks.length;
+        if (totalCount === 0) {
           return {
             success: true,
             output: "No scheduled tasks. Use scheduler(action='create', task='...', schedule='daily') to create one.",
             durationMs: performance.now() - start
           };
         }
-        const lines = [`Scheduled Tasks (${store.tasks.length}):
-`];
-        for (const t of store.tasks) {
-          const status = t.enabled ? "enabled" : "PAUSED";
-          const cronInstalled = cronJobs.some((j) => j.id === t.id);
-          const cronStatus = cronInstalled ? "" : " [cron not installed]";
-          lines.push(`  [${t.id}] ${status}${cronStatus}`);
-          lines.push(`    Task: ${t.task.slice(0, 100)}${t.task.length > 100 ? "..." : ""}`);
-          lines.push(`    Schedule: ${t.nextRunDescription} (${t.schedule})`);
-          lines.push(`    Runs: ${t.runCount}${t.maxRuns ? `/${t.maxRuns}` : ""}${t.oneShot ? " (one-shot)" : ""}`);
-          if (t.lastRun)
-            lines.push(`    Last run: ${t.lastRun}`);
-          lines.push("");
+        const lines = [];
+        if (local.tasks.length > 0) {
+          lines.push(`Local Tasks \u2014 this project (${local.tasks.length}):
+`);
+          for (const t of local.tasks) {
+            const status = t.enabled ? "enabled" : "PAUSED";
+            const cronInstalled = cronJobs.some((j) => j.id === t.id);
+            const cronStatus = cronInstalled ? "" : " [cron not installed]";
+            lines.push(`  [${t.id}] ${status}${cronStatus} [local]`);
+            lines.push(`    Task: ${t.task.slice(0, 100)}${t.task.length > 100 ? "..." : ""}`);
+            lines.push(`    Schedule: ${t.nextRunDescription} (${t.schedule})`);
+            lines.push(`    Runs: ${t.runCount}${t.maxRuns ? `/${t.maxRuns}` : ""}${t.oneShot ? " (one-shot)" : ""}`);
+            if (t.lastRun)
+              lines.push(`    Last run: ${t.lastRun}`);
+            lines.push("");
+          }
+        }
+        if (global.tasks.length > 0) {
+          lines.push(`Global Tasks \u2014 shared across projects (${global.tasks.length}):
+`);
+          for (const t of global.tasks) {
+            const status = t.enabled ? "enabled" : "PAUSED";
+            const cronInstalled = cronJobs.some((j) => j.id === t.id);
+            const cronStatus = cronInstalled ? "" : " [cron not installed]";
+            const isThisProject = t.projectDir === resolve22(this.workingDir);
+            const origin = isThisProject ? " [this project]" : t.projectDir ? ` [from: ${t.projectDir}]` : "";
+            lines.push(`  [${t.id}] ${status}${cronStatus} [global]${origin}`);
+            lines.push(`    Task: ${t.task.slice(0, 100)}${t.task.length > 100 ? "..." : ""}`);
+            lines.push(`    Schedule: ${t.nextRunDescription} (${t.schedule})`);
+            lines.push(`    Runs: ${t.runCount}${t.maxRuns ? `/${t.maxRuns}` : ""}${t.oneShot ? " (one-shot)" : ""}`);
+            if (t.lastRun)
+              lines.push(`    Last run: ${t.lastRun}`);
+            if (!isThisProject && t.projectDir) {
+              lines.push(`    \u26A0 NOT scoped to this project \u2014 override with caution`);
+            }
+            lines.push("");
+          }
         }
         return {
           success: true,
@@ -17668,7 +17802,7 @@ ${sections.join("\n")}`,
         const description = String(args["description"] ?? "");
         const category = args["category"] ?? "followup";
         const priority = args["priority"] ?? "normal";
-        const notes = args["notes"] ?? void 0;
+        const notes2 = args["notes"] ?? void 0;
         const relatedFilesStr = args["related_files"] ?? "";
         const relatedFiles = relatedFilesStr ? relatedFilesStr.split(",").map((f) => f.trim()).filter(Boolean) : void 0;
         let expiresAt;
@@ -17701,7 +17835,7 @@ ${sections.join("\n")}`,
           expiresAt,
           relatedFiles,
           status: "active",
-          notes
+          notes: notes2
         };
         const store = await loadAttentionStore(this.workingDir);
         store.items.push(item);
@@ -18395,6 +18529,7 @@ var init_factory = __esm({
 import { execSync as execSync21 } from "node:child_process";
 import { readFile as readFile18, writeFile as writeFile18, mkdir as mkdir14 } from "node:fs/promises";
 import { resolve as resolve26, join as join37 } from "node:path";
+import { homedir as homedir9 } from "node:os";
 import { randomBytes as randomBytes7 } from "node:crypto";
 function isValidCron2(expr) {
   const parts = expr.trim().split(/\s+/);
@@ -18523,6 +18658,31 @@ async function saveStore2(workingDir, store) {
   store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   await writeFile18(join37(dir, "store.json"), JSON.stringify(store, null, 2), "utf-8");
 }
+function globalCronDir() {
+  return join37(homedir9(), ".open-agents", "cron-agents");
+}
+async function loadGlobalCronStore() {
+  try {
+    const raw = await readFile18(join37(globalCronDir(), "store.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { jobs: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function saveGlobalCronStore(store) {
+  const dir = globalCronDir();
+  await mkdir14(dir, { recursive: true });
+  await mkdir14(join37(dir, "logs"), { recursive: true });
+  store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile18(join37(dir, "store.json"), JSON.stringify(store, null, 2), "utf-8");
+}
+async function loadAllCronStores(workingDir) {
+  const [local, global] = await Promise.all([
+    loadStore2(workingDir),
+    loadGlobalCronStore()
+  ]);
+  return { local, global };
+}
 var LONG_HORIZON_PRESETS, CRON_AGENT_MARKER, CronAgentTool;
 var init_cron_agent = __esm({
   "packages/execution/dist/tools/cron-agent.js"() {
@@ -18591,6 +18751,11 @@ var init_cron_agent = __esm({
             type: "array",
             items: { type: "string" },
             description: "Tags for organizing jobs (for 'create')"
+          },
+          scope: {
+            type: "string",
+            enum: ["local", "global"],
+            description: "Scope: 'local' (project .oa/, default) or 'global' (~/.open-agents/, visible from all projects)"
           }
         },
         required: ["action"]
@@ -18659,6 +18824,7 @@ var init_cron_agent = __esm({
         const verifyCommand = args["verify_command"] ? String(args["verify_command"]) : void 0;
         const maxRuns = typeof args["max_runs"] === "number" ? args["max_runs"] : 0;
         const tags = Array.isArray(args["tags"]) ? args["tags"] : [];
+        const scope = String(args["scope"] ?? "local");
         const job = {
           id,
           task,
@@ -18672,11 +18838,19 @@ var init_cron_agent = __esm({
           runCount: 0,
           maxRuns,
           history: [],
-          tags
+          tags,
+          scope,
+          projectDir: resolve26(this.workingDir)
         };
-        const store = await loadStore2(this.workingDir);
-        store.jobs.push(job);
-        await saveStore2(this.workingDir, store);
+        if (scope === "global") {
+          const store = await loadGlobalCronStore();
+          store.jobs.push(job);
+          await saveGlobalCronStore(store);
+        } else {
+          const store = await loadStore2(this.workingDir);
+          store.jobs.push(job);
+          await saveStore2(this.workingDir, store);
+        }
         installCronAgentJob(job, this.workingDir);
         return {
           success: true,
@@ -18700,19 +18874,19 @@ var init_cron_agent = __esm({
         };
       }
       async listJobs(start) {
-        const store = await loadStore2(this.workingDir);
-        if (store.jobs.length === 0) {
+        const { local, global } = await loadAllCronStores(this.workingDir);
+        const totalCount = local.jobs.length + global.jobs.length;
+        if (totalCount === 0) {
           return {
             success: true,
             output: "No cron agent jobs. Use cron_agent(action='create', ...) to schedule one.",
             durationMs: performance.now() - start
           };
         }
-        const lines = [`Cron Agent Jobs (${store.jobs.length}):
-`];
-        for (const job of store.jobs) {
+        const lines = [];
+        const formatJob = (job, scopeLabel, isThisProject) => {
           const statusIcon = job.status === "active" ? "\u25CF" : job.status === "completed" ? "\u2714" : job.status === "paused" ? "\u23F8" : "\u2716";
-          lines.push(`  ${statusIcon} [${job.id}] ${job.status.toUpperCase()}`);
+          lines.push(`  ${statusIcon} [${job.id}] ${job.status.toUpperCase()} [${scopeLabel}]`);
           lines.push(`    Goal: ${job.goal.slice(0, 80)}${job.goal.length > 80 ? "..." : ""}`);
           lines.push(`    Schedule: ${job.scheduleDescription}`);
           lines.push(`    Runs: ${job.runCount}${job.maxRuns > 0 ? `/${job.maxRuns}` : ""}`);
@@ -18720,7 +18894,25 @@ var init_cron_agent = __esm({
             lines.push(`    Last run: ${job.lastRunAt}`);
           if (job.tags.length > 0)
             lines.push(`    Tags: ${job.tags.join(", ")}`);
+          if (!isThisProject && job.projectDir) {
+            lines.push(`    Origin: ${job.projectDir}`);
+            lines.push(`    \u26A0 NOT scoped to this project \u2014 override with caution`);
+          }
           lines.push("");
+        };
+        if (local.jobs.length > 0) {
+          lines.push(`Local Cron Jobs \u2014 this project (${local.jobs.length}):
+`);
+          for (const job of local.jobs)
+            formatJob(job, "local", true);
+        }
+        if (global.jobs.length > 0) {
+          lines.push(`Global Cron Jobs \u2014 shared (${global.jobs.length}):
+`);
+          for (const job of global.jobs) {
+            const isThisProject = job.projectDir === resolve26(this.workingDir);
+            formatJob(job, isThisProject ? "global, this project" : "global", isThisProject);
+          }
         }
         return {
           success: true,
@@ -18856,6 +19048,575 @@ ${truncated}`, durationMs: performance.now() - start };
   }
 });
 
+// packages/execution/dist/tools/file-explore.js
+import { readFile as readFile19 } from "node:fs/promises";
+import { resolve as resolve27 } from "node:path";
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+function getPatterns(filePath) {
+  if (/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(filePath))
+    return SIG_PATTERNS2.ts;
+  if (/\.py$/.test(filePath))
+    return SIG_PATTERNS2.py;
+  if (/\.rs$/.test(filePath))
+    return SIG_PATTERNS2.rs;
+  if (/\.go$/.test(filePath))
+    return SIG_PATTERNS2.go;
+  return SIG_PATTERNS2.default;
+}
+function clearExploreNotes() {
+  sessionNotes.length = 0;
+}
+function getExploreNotes() {
+  return sessionNotes;
+}
+var execFileAsync3, sessionNotes, SIG_PATTERNS2, FileExploreTool;
+var init_file_explore = __esm({
+  "packages/execution/dist/tools/file-explore.js"() {
+    "use strict";
+    execFileAsync3 = promisify3(execFile4);
+    sessionNotes = [];
+    SIG_PATTERNS2 = {
+      ts: [
+        /^\s*(export\s+)?(async\s+)?function\s+\w+/,
+        /^\s*(export\s+)?(abstract\s+)?class\s+\w+/,
+        /^\s*(export\s+)?(const|let|var)\s+\w+\s*[:=]/,
+        /^\s*(export\s+)?interface\s+\w+/,
+        /^\s*(export\s+)?type\s+\w+\s*=/,
+        /^\s*(export\s+)?enum\s+\w+/,
+        /^\s*(?:public|private|protected|static|async|get|set)\s+\w+\s*[(<]/
+      ],
+      py: [
+        /^\s*def\s+\w+/,
+        /^\s*class\s+\w+/,
+        /^\s*async\s+def\s+\w+/,
+        /^[A-Z_][A-Z_0-9]*\s*=/
+      ],
+      rs: [
+        /^\s*(pub\s+)?(async\s+)?fn\s+\w+/,
+        /^\s*(pub\s+)?struct\s+\w+/,
+        /^\s*(pub\s+)?enum\s+\w+/,
+        /^\s*(pub\s+)?trait\s+\w+/,
+        /^\s*impl\s+/
+      ],
+      go: [
+        /^\s*func\s+/,
+        /^\s*type\s+\w+\s+struct/,
+        /^\s*type\s+\w+\s+interface/
+      ],
+      default: [
+        /^\s*(export\s+)?(function|class|const|let|var|def|fn|pub|type|interface|enum|struct|trait|impl)\s+/
+      ]
+    };
+    FileExploreTool = class {
+      name = "file_explore";
+      description = "Explore large files without reading them entirely into context. Strategies: 'overview' (structural skeleton \u2014 imports, exports, signatures), 'search' (grep pattern with \xB1N context lines), 'chunk' (read specific line range, auto-saved to working notes), 'outline' (function/class/method signatures only), 'notes' (show accumulated findings from this session). Use this INSTEAD of file_read for files > 200 lines. Pattern: overview \u2192 search for target \u2192 chunk to read details \u2192 note findings.";
+      parameters = {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "File path to explore"
+          },
+          strategy: {
+            type: "string",
+            enum: ["overview", "search", "chunk", "outline", "notes"],
+            description: "Exploration strategy"
+          },
+          query: {
+            type: "string",
+            description: "Search pattern (for 'search' strategy) or note text (for 'chunk' with note)"
+          },
+          offset: {
+            type: "number",
+            description: "Starting line number, 1-based (for 'chunk' strategy)"
+          },
+          limit: {
+            type: "number",
+            description: "Number of lines to read (for 'chunk', default 50)"
+          },
+          context_lines: {
+            type: "number",
+            description: "Lines of context around each match (for 'search', default 5)"
+          },
+          note: {
+            type: "string",
+            description: "Working note to save about this chunk (for 'chunk' strategy)"
+          }
+        },
+        required: ["strategy"]
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const strategy = String(args["strategy"] ?? "overview");
+        const filePath = String(args["path"] ?? "");
+        const start = performance.now();
+        switch (strategy) {
+          case "overview":
+            return this.overview(filePath, start);
+          case "search":
+            return this.search(filePath, String(args["query"] ?? ""), args, start);
+          case "chunk":
+            return this.chunk(filePath, args, start);
+          case "outline":
+            return this.outline(filePath, start);
+          case "notes":
+            return this.showNotes(filePath, start);
+          default:
+            return {
+              success: false,
+              output: "",
+              error: `Unknown strategy '${strategy}'. Use: overview, search, chunk, outline, notes`,
+              durationMs: performance.now() - start
+            };
+        }
+      }
+      /**
+       * overview: Read structural skeleton — first 30 lines (imports/config),
+       * all signature lines, last 20 lines (exports/module boundary).
+       */
+      async overview(filePath, start) {
+        if (!filePath)
+          return { success: false, output: "", error: "path required for overview", durationMs: performance.now() - start };
+        try {
+          const fullPath = resolve27(this.workingDir, filePath);
+          const content = await readFile19(fullPath, "utf-8");
+          const lines = content.split("\n");
+          const total = lines.length;
+          const HEAD = Math.min(30, total);
+          const TAIL = Math.min(20, Math.max(0, total - HEAD));
+          const parts = [];
+          parts.push(`# ${filePath} (${total} lines)
+`);
+          parts.push("## Head (lines 1-" + HEAD + ")");
+          for (let i = 0; i < HEAD; i++) {
+            parts.push(`${String(i + 1).padStart(6)} | ${lines[i]}`);
+          }
+          if (total > HEAD + TAIL) {
+            const patterns = getPatterns(filePath);
+            const sigs = [];
+            for (let i = HEAD; i < total - TAIL; i++) {
+              const line = lines[i];
+              if (patterns.some((p) => p.test(line))) {
+                sigs.push(`${String(i + 1).padStart(6)} | ${line}`);
+              }
+            }
+            if (sigs.length > 0) {
+              parts.push(`
+## Signatures (lines ${HEAD + 1}-${total - TAIL}) \u2014 ${sigs.length} found`);
+              parts.push(...sigs);
+            } else {
+              parts.push(`
+## Middle (lines ${HEAD + 1}-${total - TAIL}) \u2014 ${total - HEAD - TAIL} lines, no signatures detected`);
+            }
+          }
+          if (TAIL > 0) {
+            const tailStart = total - TAIL;
+            parts.push(`
+## Tail (lines ${tailStart + 1}-${total})`);
+            for (let i = tailStart; i < total; i++) {
+              parts.push(`${String(i + 1).padStart(6)} | ${lines[i]}`);
+            }
+          }
+          parts.push(`
+[Use file_explore(strategy='search', query='...') to find specific sections]`);
+          parts.push(`[Use file_explore(strategy='chunk', offset=N, limit=50) to read a section]`);
+          return {
+            success: true,
+            output: parts.join("\n"),
+            durationMs: performance.now() - start
+          };
+        } catch (error) {
+          return {
+            success: false,
+            output: "",
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: performance.now() - start
+          };
+        }
+      }
+      /**
+       * search: Grep for pattern with context lines around each match.
+       */
+      async search(filePath, query, args, start) {
+        if (!query)
+          return { success: false, output: "", error: "query required for search strategy", durationMs: performance.now() - start };
+        const contextLines = Number(args["context_lines"] ?? 5);
+        const searchPath = filePath ? resolve27(this.workingDir, filePath) : this.workingDir;
+        try {
+          const rgArgs = [
+            "--line-number",
+            "--no-heading",
+            "--color=never",
+            "-C",
+            String(contextLines)
+          ];
+          if (filePath) {
+            rgArgs.push(query, searchPath);
+          } else {
+            rgArgs.push(query, this.workingDir);
+          }
+          const { stdout } = await execFileAsync3("rg", rgArgs, {
+            cwd: this.workingDir,
+            maxBuffer: 1024 * 1024
+          });
+          const lines = stdout.split("\n").filter((l) => l.length > 0);
+          const matchCount = lines.filter((l) => /^\d+:/.test(l) || /:\d+:/.test(l)).length;
+          const MAX = 80;
+          const truncated = lines.length > MAX;
+          const output = lines.slice(0, MAX).join("\n");
+          const result = [
+            `Found ${matchCount} matches for "${query}"${filePath ? ` in ${filePath}` : ""}:`,
+            "",
+            truncated ? output + `
+
+[Truncated \u2014 ${lines.length - MAX} more lines]` : output,
+            "",
+            `[Use file_explore(strategy='chunk', path='...', offset=N) to read around a specific match]`
+          ].join("\n");
+          return {
+            success: true,
+            output: result,
+            durationMs: performance.now() - start
+          };
+        } catch (error) {
+          const err = error;
+          if (err.code === 1) {
+            return {
+              success: true,
+              output: `No matches for "${query}"${filePath ? ` in ${filePath}` : ""}.`,
+              durationMs: performance.now() - start
+            };
+          }
+          try {
+            const grepArgs = ["-rn", "--color=never", `-C${contextLines}`];
+            if (filePath) {
+              grepArgs.push(query, searchPath);
+            } else {
+              grepArgs.push(query, this.workingDir);
+            }
+            const { stdout } = await execFileAsync3("grep", grepArgs, {
+              cwd: this.workingDir,
+              maxBuffer: 1024 * 1024
+            });
+            return {
+              success: true,
+              output: stdout.split("\n").slice(0, 80).join("\n"),
+              durationMs: performance.now() - start
+            };
+          } catch {
+            return {
+              success: true,
+              output: `No matches for "${query}".`,
+              durationMs: performance.now() - start
+            };
+          }
+        }
+      }
+      /**
+       * chunk: Read a specific line range and optionally save a working note.
+       */
+      async chunk(filePath, args, start) {
+        if (!filePath)
+          return { success: false, output: "", error: "path required for chunk strategy", durationMs: performance.now() - start };
+        const offset = Number(args["offset"] ?? 1);
+        const limit = Number(args["limit"] ?? 50);
+        const note = args["note"];
+        try {
+          const fullPath = resolve27(this.workingDir, filePath);
+          const content = await readFile19(fullPath, "utf-8");
+          const allLines = content.split("\n");
+          const total = allLines.length;
+          const startIdx = Math.max(0, offset - 1);
+          const endIdx = Math.min(total, startIdx + limit);
+          const chunk = allLines.slice(startIdx, endIdx);
+          const numbered = chunk.map((line, i) => `${String(startIdx + i + 1).padStart(6)} | ${line}`).join("\n");
+          if (note) {
+            sessionNotes.push({
+              file: filePath,
+              lineRange: [startIdx + 1, endIdx],
+              finding: note,
+              timestamp: Date.now()
+            });
+          }
+          const nav = [];
+          if (startIdx > 0) {
+            nav.push(`[Previous: file_explore(strategy='chunk', path='${filePath}', offset=${Math.max(1, startIdx + 1 - limit)}, limit=${limit})]`);
+          }
+          if (endIdx < total) {
+            nav.push(`[Next: file_explore(strategy='chunk', path='${filePath}', offset=${endIdx + 1}, limit=${limit})]`);
+          }
+          nav.push(`[${total} total lines \u2014 showing ${startIdx + 1}-${endIdx}]`);
+          if (sessionNotes.length > 0) {
+            nav.push(`[${sessionNotes.length} working notes \u2014 file_explore(strategy='notes') to review]`);
+          }
+          return {
+            success: true,
+            output: numbered + "\n\n" + nav.join("\n"),
+            durationMs: performance.now() - start
+          };
+        } catch (error) {
+          return {
+            success: false,
+            output: "",
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: performance.now() - start
+          };
+        }
+      }
+      /**
+       * outline: Extract only function/class/method/export signatures.
+       */
+      async outline(filePath, start) {
+        if (!filePath)
+          return { success: false, output: "", error: "path required for outline", durationMs: performance.now() - start };
+        try {
+          const fullPath = resolve27(this.workingDir, filePath);
+          const content = await readFile19(fullPath, "utf-8");
+          const lines = content.split("\n");
+          const patterns = getPatterns(filePath);
+          const sigs = [];
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (patterns.some((p) => p.test(line))) {
+              sigs.push(`${String(i + 1).padStart(6)} | ${line.trimEnd()}`);
+            }
+          }
+          if (sigs.length === 0) {
+            return {
+              success: true,
+              output: `${filePath}: ${lines.length} lines, no recognizable signatures found.
+[Use file_explore(strategy='overview') for a broader view]`,
+              durationMs: performance.now() - start
+            };
+          }
+          return {
+            success: true,
+            output: `# ${filePath} \u2014 ${sigs.length} signatures (${lines.length} total lines)
+
+` + sigs.join("\n") + `
+
+[Use file_explore(strategy='chunk', offset=N) to read around a specific signature]`,
+            durationMs: performance.now() - start
+          };
+        } catch (error) {
+          return {
+            success: false,
+            output: "",
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: performance.now() - start
+          };
+        }
+      }
+      /**
+       * notes: Show accumulated working notes from this exploration session.
+       */
+      showNotes(filePath, start) {
+        const notes2 = filePath ? sessionNotes.filter((n) => n.file === filePath) : sessionNotes;
+        if (notes2.length === 0) {
+          return {
+            success: true,
+            output: "No working notes yet. Use file_explore(strategy='chunk', note='your finding') to save notes as you explore.",
+            durationMs: performance.now() - start
+          };
+        }
+        const parts = [`# Working Notes (${notes2.length})
+`];
+        for (const n of notes2) {
+          parts.push(`- **${n.file}** lines ${n.lineRange[0]}-${n.lineRange[1]}: ${n.finding}`);
+        }
+        return {
+          success: true,
+          output: parts.join("\n"),
+          durationMs: performance.now() - start
+        };
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/working-notes.js
+function getWorkingNotes() {
+  return notes;
+}
+function getWorkingNotesSummary() {
+  if (notes.length === 0)
+    return "";
+  const parts = [`Working notes (${notes.length}):`];
+  for (const n of notes) {
+    const loc = n.file ? ` [${n.file}${n.line ? `:${n.line}` : ""}]` : "";
+    parts.push(`- [${n.category}] ${n.content.slice(0, 150)}${loc}`);
+  }
+  return parts.join("\n");
+}
+function clearWorkingNotes() {
+  notes.length = 0;
+  noteCounter = 0;
+}
+var noteCounter, notes, WorkingNotesTool;
+var init_working_notes = __esm({
+  "packages/execution/dist/tools/working-notes.js"() {
+    "use strict";
+    noteCounter = 0;
+    notes = [];
+    WorkingNotesTool = class {
+      name = "working_notes";
+      description = "In-task scratchpad for tracking discoveries, decisions, and TODOs. Notes persist across tool calls and survive context compaction. Actions: 'add' a note, 'list' all notes, 'search' notes by keyword, 'clear' all notes, 'summary' get a compact summary. Use this to maintain signal when exploring large codebases \u2014 note findings as you go so you don't lose them to context limits.";
+      parameters = {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["add", "list", "search", "clear", "summary"],
+            description: "Action to perform (default: 'list')"
+          },
+          content: {
+            type: "string",
+            description: "Note content (for 'add') or search query (for 'search')"
+          },
+          category: {
+            type: "string",
+            enum: ["finding", "todo", "question", "decision", "blocker"],
+            description: "Note category (for 'add', default: 'finding')"
+          },
+          file: {
+            type: "string",
+            description: "Related file path (for 'add')"
+          },
+          line: {
+            type: "number",
+            description: "Related line number (for 'add')"
+          }
+        },
+        required: []
+      };
+      async execute(args) {
+        const action = String(args["action"] ?? "list");
+        const start = performance.now();
+        switch (action) {
+          case "add": {
+            const content = String(args["content"] ?? "");
+            if (!content)
+              return { success: false, output: "", error: "content required", durationMs: performance.now() - start };
+            const note = {
+              id: ++noteCounter,
+              category: String(args["category"] ?? "finding"),
+              content,
+              file: args["file"],
+              line: args["line"],
+              timestamp: Date.now()
+            };
+            notes.push(note);
+            return {
+              success: true,
+              output: `Note #${note.id} added [${note.category}]${note.file ? ` (${note.file}${note.line ? `:${note.line}` : ""})` : ""}: ${content.slice(0, 100)}`,
+              durationMs: performance.now() - start
+            };
+          }
+          case "list": {
+            if (notes.length === 0) {
+              return {
+                success: true,
+                output: "No working notes. Use working_notes(action='add', content='...') to start tracking findings.",
+                durationMs: performance.now() - start
+              };
+            }
+            const lines = [`Working Notes (${notes.length}):
+`];
+            for (const n of notes) {
+              const loc = n.file ? ` @ ${n.file}${n.line ? `:${n.line}` : ""}` : "";
+              lines.push(`  #${n.id} [${n.category}]${loc}: ${n.content}`);
+            }
+            return {
+              success: true,
+              output: lines.join("\n"),
+              durationMs: performance.now() - start
+            };
+          }
+          case "search": {
+            const query = String(args["content"] ?? "").toLowerCase();
+            if (!query)
+              return { success: false, output: "", error: "content (search query) required", durationMs: performance.now() - start };
+            const matches = notes.filter((n) => n.content.toLowerCase().includes(query) || n.file && n.file.toLowerCase().includes(query) || n.category.toLowerCase().includes(query));
+            if (matches.length === 0) {
+              return {
+                success: true,
+                output: `No notes matching "${query}".`,
+                durationMs: performance.now() - start
+              };
+            }
+            const lines = [`Notes matching "${query}" (${matches.length}):
+`];
+            for (const n of matches) {
+              const loc = n.file ? ` @ ${n.file}${n.line ? `:${n.line}` : ""}` : "";
+              lines.push(`  #${n.id} [${n.category}]${loc}: ${n.content}`);
+            }
+            return {
+              success: true,
+              output: lines.join("\n"),
+              durationMs: performance.now() - start
+            };
+          }
+          case "clear": {
+            const count = notes.length;
+            notes.length = 0;
+            noteCounter = 0;
+            return {
+              success: true,
+              output: `Cleared ${count} working notes.`,
+              durationMs: performance.now() - start
+            };
+          }
+          case "summary": {
+            if (notes.length === 0) {
+              return {
+                success: true,
+                output: "No working notes to summarize.",
+                durationMs: performance.now() - start
+              };
+            }
+            const groups = /* @__PURE__ */ new Map();
+            for (const n of notes) {
+              const list = groups.get(n.category) ?? [];
+              list.push(n);
+              groups.set(n.category, list);
+            }
+            const parts = [`Working Notes Summary (${notes.length} total):
+`];
+            for (const [cat, items] of groups) {
+              parts.push(`  ${cat.toUpperCase()} (${items.length}):`);
+              for (const n of items) {
+                const loc = n.file ? ` [${n.file}${n.line ? `:${n.line}` : ""}]` : "";
+                parts.push(`    - ${n.content.slice(0, 120)}${loc}`);
+              }
+            }
+            const files = new Set(notes.filter((n) => n.file).map((n) => n.file));
+            if (files.size > 0) {
+              parts.push(`
+  Files referenced: ${[...files].join(", ")}`);
+            }
+            return {
+              success: true,
+              output: parts.join("\n"),
+              durationMs: performance.now() - start
+            };
+          }
+          default:
+            return {
+              success: false,
+              output: "",
+              error: `Unknown action '${action}'. Use: add, list, search, clear, summary`,
+              durationMs: performance.now() - start
+            };
+        }
+      }
+    };
+  }
+});
+
 // packages/execution/dist/tools/fortemi-bridge.js
 import { existsSync as existsSync24, readFileSync as readFileSync17 } from "node:fs";
 import { join as join38 } from "node:path";
@@ -19012,7 +19773,7 @@ import { spawn as spawn13 } from "node:child_process";
 async function runShell(options) {
   const { command, args = [], cwd: cwd4, env, timeoutMs = DEFAULT_TIMEOUT_MS } = options;
   const mergedEnv = env ? { ...process.env, ...env } : process.env;
-  return new Promise((resolve32) => {
+  return new Promise((resolve33) => {
     const start = Date.now();
     let timedOut = false;
     const child = spawn13(command, args, {
@@ -19036,7 +19797,7 @@ async function runShell(options) {
       clearTimeout(timer);
       const durationMs = Date.now() - start;
       const exitCode = timedOut ? -1 : code ?? -1;
-      resolve32({
+      resolve33({
         stdout,
         stderr,
         exitCode,
@@ -19048,7 +19809,7 @@ async function runShell(options) {
     child.on("error", (err) => {
       clearTimeout(timer);
       const durationMs = Date.now() - start;
-      resolve32({
+      resolve33({
         stdout,
         stderr: stderr + err.message,
         exitCode: -1,
@@ -19163,7 +19924,7 @@ async function applyUnifiedDiff(patch) {
 }
 function runWithStdin(options) {
   const { command, args, cwd: cwd4, stdin } = options;
-  return new Promise((resolve32) => {
+  return new Promise((resolve33) => {
     const child = spawn14(command, args, {
       cwd: cwd4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -19180,10 +19941,10 @@ function runWithStdin(options) {
     child.stdin.end();
     child.on("close", (code) => {
       const exitCode = code ?? -1;
-      resolve32({ success: exitCode === 0, exitCode, stdout, stderr });
+      resolve33({ success: exitCode === 0, exitCode, stdout, stderr });
     });
     child.on("error", (err) => {
-      resolve32({ success: false, exitCode: -1, stdout, stderr: err.message });
+      resolve33({ success: false, exitCode: -1, stdout, stderr: err.message });
     });
   });
 }
@@ -19631,6 +20392,7 @@ __export(dist_exports, {
   ExploreToolsTool: () => ExploreToolsTool,
   FactoryTool: () => FactoryTool,
   FileEditTool: () => FileEditTool,
+  FileExploreTool: () => FileExploreTool,
   FilePatchTool: () => FilePatchTool,
   FileReadTool: () => FileReadTool,
   FileWriteTool: () => FileWriteTool,
@@ -19673,10 +20435,13 @@ __export(dist_exports, {
   WebCrawlTool: () => WebCrawlTool,
   WebFetchTool: () => WebFetchTool,
   WebSearchTool: () => WebSearchTool,
+  WorkingNotesTool: () => WorkingNotesTool,
   applyPatch: () => applyPatch,
   buildCustomTools: () => buildCustomTools,
   buildSkillsSummary: () => buildSkillsSummary,
   checkDesktopDeps: () => checkDesktopDeps,
+  clearExploreNotes: () => clearExploreNotes,
+  clearWorkingNotes: () => clearWorkingNotes,
   createFortemiBridgeTools: () => createFortemiBridgeTools,
   createWorktree: () => createWorktree,
   detectSearchProvider: () => detectSearchProvider,
@@ -19686,6 +20451,9 @@ __export(dist_exports, {
   ensureDepsForGroup: () => ensureDepsForGroup,
   getActiveAttentionItems: () => getActiveAttentionItems,
   getDueReminders: () => getDueReminders,
+  getExploreNotes: () => getExploreNotes,
+  getWorkingNotes: () => getWorkingNotes,
+  getWorkingNotesSummary: () => getWorkingNotesSummary,
   isFortemiAvailable: () => isFortemiAvailable,
   isImagePath: () => isImagePath,
   listCustomToolFiles: () => listCustomToolFiles,
@@ -19762,6 +20530,8 @@ var init_dist2 = __esm({
     init_opencode();
     init_factory();
     init_cron_agent();
+    init_file_explore();
+    init_working_notes();
     init_nexus();
     init_fortemi_bridge();
     init_system_deps();
@@ -20745,13 +21515,13 @@ var init_plannerRunner = __esm({
 });
 
 // packages/retrieval/dist/grep-search.js
-import { execFile as execFile4 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
-var execFileAsync3, GrepSearch;
+import { execFile as execFile5 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+var execFileAsync4, GrepSearch;
 var init_grep_search2 = __esm({
   "packages/retrieval/dist/grep-search.js"() {
     "use strict";
-    execFileAsync3 = promisify3(execFile4);
+    execFileAsync4 = promisify4(execFile5);
     GrepSearch = class {
       rootDir;
       constructor(rootDir) {
@@ -20773,7 +21543,7 @@ var init_grep_search2 = __esm({
         }
         args.push(pattern, this.rootDir);
         try {
-          const { stdout } = await execFileAsync3("rg", args, {
+          const { stdout } = await execFileAsync4("rg", args, {
             maxBuffer: 10 * 1024 * 1024
           });
           return this.parseRipgrepOutput(stdout);
@@ -20834,8 +21604,8 @@ var init_code_retriever = __esm({
         });
       }
       async getFileContent(filePath, startLine, endLine) {
-        const { readFile: readFile23 } = await import("node:fs/promises");
-        const content = await readFile23(filePath, "utf-8");
+        const { readFile: readFile24 } = await import("node:fs/promises");
+        const content = await readFile24(filePath, "utf-8");
         if (startLine === void 0)
           return content;
         const lines = content.split("\n");
@@ -20848,9 +21618,9 @@ var init_code_retriever = __esm({
 });
 
 // packages/retrieval/dist/lexicalSearch.js
-import { execFile as execFile5 } from "node:child_process";
-import { promisify as promisify4 } from "node:util";
-import { readFile as readFile19, readdir as readdir5, stat as stat3 } from "node:fs/promises";
+import { execFile as execFile6 } from "node:child_process";
+import { promisify as promisify5 } from "node:util";
+import { readFile as readFile20, readdir as readdir5, stat as stat3 } from "node:fs/promises";
 import { join as join40, extname as extname7 } from "node:path";
 async function searchByPath(pathPattern, options) {
   const allFiles = await collectFiles(options.rootDir, options.includeGlobs ?? DEFAULT_INCLUDE_GLOBS, options.excludeGlobs ?? DEFAULT_EXCLUDE_GLOBS);
@@ -20893,7 +21663,7 @@ async function runSearch(pattern, kind, options) {
 }
 async function isRipgrepAvailable() {
   try {
-    await execFileAsync4("rg", ["--version"], { timeout: 2e3 });
+    await execFileAsync5("rg", ["--version"], { timeout: 2e3 });
     return true;
   } catch {
     return false;
@@ -20913,7 +21683,7 @@ async function searchWithRipgrep(pattern, kind, options) {
   args.push(pattern, options.rootDir);
   let stdout;
   try {
-    const result = await execFileAsync4("rg", args, {
+    const result = await execFileAsync5("rg", args, {
       maxBuffer: 20 * 1024 * 1024,
       timeout: 1e4
     });
@@ -20956,7 +21726,7 @@ async function searchWithNodeFallback(pattern, kind, options) {
     if (results.length >= maxMatches)
       break;
     try {
-      const content = await readFile19(filePath, "utf-8");
+      const content = await readFile20(filePath, "utf-8");
       const contentLines = content.split("\n");
       for (let i = 0; i < contentLines.length; i++) {
         if (results.length >= maxMatches)
@@ -21023,11 +21793,11 @@ function matchesGlob(filePath, glob2) {
     return false;
   }
 }
-var execFileAsync4, DEFAULT_INCLUDE_GLOBS, DEFAULT_EXCLUDE_GLOBS, DEFAULT_MAX_MATCHES, ALWAYS_SKIP, ALL_CODE_EXTS;
+var execFileAsync5, DEFAULT_INCLUDE_GLOBS, DEFAULT_EXCLUDE_GLOBS, DEFAULT_MAX_MATCHES, ALWAYS_SKIP, ALL_CODE_EXTS;
 var init_lexicalSearch = __esm({
   "packages/retrieval/dist/lexicalSearch.js"() {
     "use strict";
-    execFileAsync4 = promisify4(execFile5);
+    execFileAsync5 = promisify5(execFile6);
     DEFAULT_INCLUDE_GLOBS = ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.py"];
     DEFAULT_EXCLUDE_GLOBS = ["node_modules", "dist", ".git", "build", "coverage"];
     DEFAULT_MAX_MATCHES = 50;
@@ -21299,7 +22069,7 @@ var init_graphExpand = __esm({
 });
 
 // packages/retrieval/dist/snippetPacker.js
-import { readFile as readFile20 } from "node:fs/promises";
+import { readFile as readFile21 } from "node:fs/promises";
 import { join as join41 } from "node:path";
 async function packSnippets(requests, opts = {}) {
   const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
@@ -21329,7 +22099,7 @@ async function extractSnippet(req, repoRoot, contextLines = DEFAULT_CONTEXT_LINE
   const absPath = req.filePath.startsWith("/") ? req.filePath : join41(repoRoot, req.filePath);
   let content;
   try {
-    content = await readFile20(absPath, "utf-8");
+    content = await readFile21(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -21864,9 +22634,9 @@ var init_verifierRunner = __esm({
       async executeTests(patch, repoRoot) {
         if (patch.testsToRun.length === 0)
           return "(no tests specified)";
-        const { execFile: execFile6 } = await import("node:child_process");
-        const { promisify: promisify6 } = await import("node:util");
-        const execFileAsync5 = promisify6(execFile6);
+        const { execFile: execFile7 } = await import("node:child_process");
+        const { promisify: promisify7 } = await import("node:util");
+        const execFileAsync6 = promisify7(execFile7);
         const outputs = [];
         const workDir = this.options.workingDir || repoRoot;
         for (const cmd of patch.testsToRun.slice(0, 3)) {
@@ -21875,7 +22645,7 @@ var init_verifierRunner = __esm({
             const [bin, ...args] = parts;
             if (!bin)
               continue;
-            const { stdout, stderr } = await execFileAsync5(bin, args, {
+            const { stdout, stderr } = await execFileAsync6(bin, args, {
               cwd: workDir,
               timeout: 6e4,
               maxBuffer: 1024 * 1024
@@ -22555,6 +23325,7 @@ var init_agenticRunner = __esm({
     init_dist();
     init_personality();
     init_promptLoader();
+    init_dist2();
     SYSTEM_PROMPT = loadPrompt("agentic/system-large.md");
     SYSTEM_PROMPT_MEDIUM = loadPrompt("agentic/system-medium.md");
     SYSTEM_PROMPT_SMALL = loadPrompt("agentic/system-small.md");
@@ -22875,8 +23646,8 @@ ${this.options.dynamicContext}`,
       async waitIfPaused() {
         if (!this._paused)
           return true;
-        await new Promise((resolve32) => {
-          this._pauseResolve = resolve32;
+        await new Promise((resolve33) => {
+          this._pauseResolve = resolve33;
         });
         return !this.aborted;
       }
@@ -23909,14 +24680,14 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
       waitForSudoPassword(timeoutMs = 12e4) {
         if (this._sudoPassword)
           return Promise.resolve(this._sudoPassword);
-        return new Promise((resolve32) => {
+        return new Promise((resolve33) => {
           const timer = setTimeout(() => {
             this._sudoResolve = null;
-            resolve32(null);
+            resolve33(null);
           }, timeoutMs);
           this._sudoResolve = (pw) => {
             clearTimeout(timer);
-            resolve32(pw);
+            resolve33(pw);
           };
         });
       }
@@ -24224,6 +24995,18 @@ ${tail}`;
         const fileRegistryStr = this.formatFileRegistry();
         if (fileRegistryStr)
           enrichments.push(fileRegistryStr);
+        try {
+          const notesSummary = getWorkingNotesSummary();
+          if (notesSummary)
+            enrichments.push(notesSummary);
+          const exploreNotes = getExploreNotes();
+          if (exploreNotes.length > 0) {
+            const exploreStr = `File exploration notes (${exploreNotes.length}):
+` + exploreNotes.map((n) => `- ${n.file} lines ${n.lineRange[0]}-${n.lineRange[1]}: ${n.finding}`).join("\n");
+            enrichments.push(exploreStr);
+          }
+        } catch {
+        }
         if (tier === "large") {
           const memexIndexStr = this.formatMemexIndex();
           if (memexIndexStr)
@@ -25616,12 +26399,12 @@ var init_nexusBackend = __esm({
         const deadline = Date.now() + (request.timeoutMs ?? 12e4);
         try {
           while (!done && Date.now() < deadline) {
-            await new Promise((resolve32) => {
+            await new Promise((resolve33) => {
               let resolved = false;
               const finish = () => {
                 if (!resolved) {
                   resolved = true;
-                  resolve32();
+                  resolve33();
                 }
               };
               let watcher = null;
@@ -26561,7 +27344,7 @@ __export(listen_exports, {
 import { spawn as spawn15, execSync as execSync22 } from "node:child_process";
 import { existsSync as existsSync28, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, readdirSync as readdirSync6 } from "node:fs";
 import { join as join43, dirname as dirname13 } from "node:path";
-import { homedir as homedir8 } from "node:os";
+import { homedir as homedir10 } from "node:os";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 import { EventEmitter } from "node:events";
 import { createInterface as createInterface2 } from "node:readline";
@@ -26673,7 +27456,7 @@ function findLiveWhisperScript() {
     }
   } catch {
   }
-  const nvmBase = join43(homedir8(), ".nvm", "versions", "node");
+  const nvmBase = join43(homedir10(), ".nvm", "versions", "node");
   if (existsSync28(nvmBase)) {
     try {
       for (const ver of readdirSync6(nvmBase)) {
@@ -26703,9 +27486,9 @@ function ensureTranscribeCliBackground() {
     }
     try {
       const { exec: exec4 } = await import("node:child_process");
-      return new Promise((resolve32) => {
+      return new Promise((resolve33) => {
         exec4("npm i -g transcribe-cli", { timeout: 18e4 }, (err) => {
-          resolve32(!err);
+          resolve33(!err);
         });
       });
     } catch {
@@ -26764,7 +27547,7 @@ var init_listen = __esm({
         return this._ready;
       }
       async start() {
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("Whisper fallback: model load timeout (5 min). First run downloads the model."));
           }, 3e5);
@@ -26792,7 +27575,7 @@ var init_listen = __esm({
                   this._ready = true;
                   clearTimeout(timeout);
                   this.emit("ready");
-                  resolve32();
+                  resolve33();
                   break;
                 case "transcript":
                   this.emit("transcript", {
@@ -26927,7 +27710,7 @@ var init_listen = __esm({
           }
         } catch {
         }
-        const nvmBase = join43(homedir8(), ".nvm", "versions", "node");
+        const nvmBase = join43(homedir10(), ".nvm", "versions", "node");
         if (existsSync28(nvmBase)) {
           try {
             const { readdirSync: readdirSync18 } = await import("node:fs");
@@ -26996,11 +27779,11 @@ var init_listen = __esm({
               this.liveTranscriber.on("error", (err) => {
                 this.emit("error", err);
               });
-              await new Promise((resolve32, reject) => {
+              await new Promise((resolve33, reject) => {
                 const timeout = setTimeout(() => reject(new Error("Model load timeout (60s)")), 6e4);
                 this.liveTranscriber.on("ready", () => {
                   clearTimeout(timeout);
-                  resolve32();
+                  resolve33();
                 });
                 this.liveTranscriber.on("error", (err) => {
                   clearTimeout(timeout);
@@ -27162,11 +27945,11 @@ transcribe-cli error: ${transcribeCliError}` : "";
               sampleWidth: 2,
               chunkDuration: 3
             });
-            await new Promise((resolve32, reject) => {
+            await new Promise((resolve33, reject) => {
               const timeout = setTimeout(() => reject(new Error("Model load timeout (60s)")), 6e4);
               transcriber.on("ready", () => {
                 clearTimeout(timeout);
-                resolve32();
+                resolve33();
               });
               transcriber.on("error", (err) => {
                 clearTimeout(timeout);
@@ -32137,8 +32920,8 @@ var init_voice_session = __esm({
         this.server.keepAliveTimeout = 0;
         this.wss = new import_websocket_server.default({ server: this.server, path: "/ws" });
         this.wss.on("connection", (ws, req) => this.handleWSConnection(ws, req));
-        await new Promise((resolve32, reject) => {
-          this.server.listen(port, "127.0.0.1", () => resolve32());
+        await new Promise((resolve33, reject) => {
+          this.server.listen(port, "127.0.0.1", () => resolve33());
           this.server.on("error", reject);
         });
         try {
@@ -32356,7 +33139,7 @@ var init_voice_session = __esm({
       }
       // ── Cloudflared tunnel ────────────────────────────────────────────────
       startCloudflared(port) {
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("Cloudflared tunnel start timeout (30s)"));
           }, 3e4);
@@ -32374,7 +33157,7 @@ var init_voice_session = __esm({
             if (urlMatch && !urlFound) {
               urlFound = true;
               clearTimeout(timeout);
-              resolve32(urlMatch[0]);
+              resolve33(urlMatch[0]);
             }
           };
           this.cloudflaredProcess.stdout?.on("data", handleOutput);
@@ -32414,13 +33197,13 @@ var init_voice_session = __esm({
       }
       // ── Helpers ───────────────────────────────────────────────────────────
       findFreePort() {
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           const srv = createServer2();
           srv.listen(0, "127.0.0.1", () => {
             const addr = srv.address();
             if (addr && typeof addr === "object") {
               const port = addr.port;
-              srv.close(() => resolve32(port));
+              srv.close(() => resolve33(port));
             } else {
               srv.close(() => reject(new Error("Could not find free port")));
             }
@@ -32543,8 +33326,8 @@ async function collectSystemMetricsAsync() {
     vramUtilization: 0
   };
   try {
-    const smi = await new Promise((resolve32, reject) => {
-      exec("nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => err ? reject(err) : resolve32(stdout));
+    const smi = await new Promise((resolve33, reject) => {
+      exec("nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => err ? reject(err) : resolve33(stdout));
     });
     const line = smi.trim().split("\n")[0];
     if (line) {
@@ -32692,8 +33475,8 @@ var init_expose = __esm({
           throw new Error("Gateway already running");
         const port = await this.findFreePort();
         this.server = this.createProxyServer(port);
-        await new Promise((resolve32, reject) => {
-          this.server.listen(port, "127.0.0.1", () => resolve32());
+        await new Promise((resolve33, reject) => {
+          this.server.listen(port, "127.0.0.1", () => resolve33());
           this.server.on("error", reject);
         });
         let lastStartErr;
@@ -32755,8 +33538,8 @@ var init_expose = __esm({
         this._cloudflaredPid = state.pid;
         this._proxyPort = state.proxyPort;
         this.server = this.createProxyServer(state.proxyPort);
-        await new Promise((resolve32, reject) => {
-          this.server.listen(state.proxyPort, "127.0.0.1", () => resolve32());
+        await new Promise((resolve33, reject) => {
+          this.server.listen(state.proxyPort, "127.0.0.1", () => resolve33());
           this.server.on("error", reject);
         });
         this._stats.status = "active";
@@ -32781,8 +33564,8 @@ var init_expose = __esm({
         }
         this._cloudflaredPid = null;
         if (this.server) {
-          await new Promise((resolve32) => {
-            this.server.close(() => resolve32());
+          await new Promise((resolve33) => {
+            this.server.close(() => resolve33());
           });
           this.server = null;
         }
@@ -33114,7 +33897,7 @@ var init_expose = __esm({
       _proxyPort = 0;
       startCloudflared(port) {
         this._proxyPort = port;
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("Cloudflared tunnel start timeout (30s)"));
           }, 3e4);
@@ -33143,7 +33926,7 @@ var init_expose = __esm({
               this.cloudflaredProcess?.unref();
               this.cloudflaredProcess?.stdout?.destroy();
               this.cloudflaredProcess?.stderr?.destroy();
-              resolve32(urlMatch[0]);
+              resolve33(urlMatch[0]);
             }
           };
           this.cloudflaredProcess.stdout?.on("data", handleOutput);
@@ -33232,13 +34015,13 @@ ${this.formatConnectionInfo()}`);
       }
       // ── Helpers ─────────────────────────────────────────────────────────────
       findFreePort() {
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           const srv = createServer3();
           srv.listen(0, "127.0.0.1", () => {
             const addr = srv.address();
             if (addr && typeof addr === "object") {
               const port = addr.port;
-              srv.close(() => resolve32(port));
+              srv.close(() => resolve33(port));
             } else {
               srv.close(() => reject(new Error("Could not find free port")));
             }
@@ -34185,8 +34968,8 @@ var init_peer_mesh = __esm({
         this.wss.on("connection", (ws, req) => {
           this.handleInboundConnection(ws, req.url ?? "");
         });
-        await new Promise((resolve32, reject) => {
-          this.server.listen(port, "127.0.0.1", () => resolve32());
+        await new Promise((resolve33, reject) => {
+          this.server.listen(port, "127.0.0.1", () => resolve33());
           this.server.on("error", reject);
         });
         this.pingTimer = setInterval(() => this.pingAll(), PING_INTERVAL_MS);
@@ -34225,7 +35008,7 @@ var init_peer_mesh = __esm({
           this.wss = null;
         }
         if (this.server) {
-          await new Promise((resolve32) => this.server.close(() => resolve32()));
+          await new Promise((resolve33) => this.server.close(() => resolve33()));
           this.server = null;
         }
         this.emit("stopped");
@@ -34243,7 +35026,7 @@ var init_peer_mesh = __esm({
         if (!wsUrl.includes("/p2p"))
           wsUrl += "/p2p";
         wsUrl += `?key=${encodeURIComponent(this._authKey)}`;
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           const ws = new import_websocket.default(wsUrl, { handshakeTimeout: 1e4 });
           let resolved = false;
           const timeout = setTimeout(() => {
@@ -34283,7 +35066,7 @@ var init_peer_mesh = __esm({
                 this.connections.set(peer.peerId, ws);
                 this.setupPeerHandlers(ws, peer.peerId);
                 this.emit("peer_connected", peer);
-                resolve32(peer);
+                resolve33(peer);
               } else {
                 this.handleMessage(msg, ws);
               }
@@ -34338,12 +35121,12 @@ var init_peer_mesh = __esm({
           throw new Error(`Peer ${peerId} not connected`);
         }
         const msgId = randomBytes11(8).toString("hex");
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           const timeout = setTimeout(() => {
             this.pendingRequests.delete(msgId);
             reject(new Error(`Inference timeout (${timeoutMs}ms)`));
           }, timeoutMs);
-          this.pendingRequests.set(msgId, { resolve: resolve32, reject, timeout, chunks: [] });
+          this.pendingRequests.set(msgId, { resolve: resolve33, reject, timeout, chunks: [] });
           this.sendMsg(ws, "infer_request", request, msgId);
         });
       }
@@ -34565,13 +35348,13 @@ var init_peer_mesh = __esm({
         ws.send(JSON.stringify(msg));
       }
       findFreePort() {
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           const srv = createServer4();
           srv.listen(0, "127.0.0.1", () => {
             const addr = srv.address();
             if (addr && typeof addr === "object") {
               const port = addr.port;
-              srv.close(() => resolve32(port));
+              srv.close(() => resolve33(port));
             } else {
               srv.close(() => reject(new Error("Could not find free port")));
             }
@@ -35817,7 +36600,7 @@ __export(oa_directory_exports, {
 });
 import { existsSync as existsSync32, mkdirSync as mkdirSync11, readFileSync as readFileSync23, writeFileSync as writeFileSync12, readdirSync as readdirSync8, statSync as statSync11, unlinkSync as unlinkSync6 } from "node:fs";
 import { join as join48, relative as relative2, basename as basename9, extname as extname8 } from "node:path";
-import { homedir as homedir9 } from "node:os";
+import { homedir as homedir11 } from "node:os";
 function initOaDirectory(repoRoot) {
   const oaPath = join48(repoRoot, OA_DIR);
   for (const sub of SUBDIRS) {
@@ -35857,7 +36640,7 @@ function saveProjectSettings(repoRoot, settings) {
   writeFileSync12(join48(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function loadGlobalSettings() {
-  const settingsPath = join48(homedir9(), ".open-agents", "settings.json");
+  const settingsPath = join48(homedir11(), ".open-agents", "settings.json");
   try {
     if (existsSync32(settingsPath)) {
       return JSON.parse(readFileSync23(settingsPath, "utf-8"));
@@ -35867,7 +36650,7 @@ function loadGlobalSettings() {
   return {};
 }
 function saveGlobalSettings(settings) {
-  const dir = join48(homedir9(), ".open-agents");
+  const dir = join48(homedir11(), ".open-agents");
   mkdirSync11(dir, { recursive: true });
   const existing = loadGlobalSettings();
   const merged = { ...existing, ...settings };
@@ -36247,13 +37030,13 @@ function recordUsage(kind, value, opts) {
     }
     saveUsageFile(filePath, data);
   };
-  update(join48(homedir9(), ".open-agents", USAGE_HISTORY_FILE));
+  update(join48(homedir11(), ".open-agents", USAGE_HISTORY_FILE));
   if (opts?.repoRoot) {
     update(join48(opts.repoRoot, OA_DIR, USAGE_HISTORY_FILE));
   }
 }
 function loadUsageHistory(kind, repoRoot) {
-  const globalPath = join48(homedir9(), ".open-agents", USAGE_HISTORY_FILE);
+  const globalPath = join48(homedir11(), ".open-agents", USAGE_HISTORY_FILE);
   const globalData = loadUsageFile(globalPath);
   const localData = repoRoot ? loadUsageFile(join48(repoRoot, OA_DIR, USAGE_HISTORY_FILE)) : { records: [] };
   const map = /* @__PURE__ */ new Map();
@@ -36286,7 +37069,7 @@ function deleteUsageRecord(kind, value, repoRoot) {
       saveUsageFile(filePath, data);
     }
   };
-  remove(join48(homedir9(), ".open-agents", USAGE_HISTORY_FILE));
+  remove(join48(homedir11(), ".open-agents", USAGE_HISTORY_FILE));
   if (repoRoot) {
     remove(join48(repoRoot, OA_DIR, USAGE_HISTORY_FILE));
   }
@@ -36337,10 +37120,10 @@ var init_oa_directory = __esm({
 // packages/cli/dist/tui/setup.js
 import * as readline from "node:readline";
 import { execSync as execSync24, spawn as spawn18, exec as exec2 } from "node:child_process";
-import { promisify as promisify5 } from "node:util";
+import { promisify as promisify6 } from "node:util";
 import { existsSync as existsSync33, writeFileSync as writeFileSync13, readFileSync as readFileSync24, appendFileSync as appendFileSync2, mkdirSync as mkdirSync12 } from "node:fs";
 import { join as join49 } from "node:path";
-import { homedir as homedir10, platform } from "node:os";
+import { homedir as homedir12, platform } from "node:os";
 function detectSystemSpecs() {
   let totalRamGB = 0;
   let availableRamGB = 0;
@@ -36477,12 +37260,12 @@ function modelSupportsToolCalling(modelName) {
   return false;
 }
 function ask(rl, question) {
-  return new Promise((resolve32) => {
-    rl.question(question, (answer) => resolve32(answer.trim()));
+  return new Promise((resolve33) => {
+    rl.question(question, (answer) => resolve33(answer.trim()));
   });
 }
 function askSecret(rl, question) {
-  return new Promise((resolve32) => {
+  return new Promise((resolve33) => {
     process.stdout.write(question);
     let secret = "";
     const stdin = process.stdin;
@@ -36500,7 +37283,7 @@ function askSecret(rl, question) {
             stdin.setRawMode(hadRawMode ?? false);
           }
           process.stdout.write("\n");
-          resolve32(secret.trim());
+          resolve33(secret.trim());
           return;
         } else if (c3 === "") {
           stdin.removeListener("data", onData);
@@ -36508,7 +37291,7 @@ function askSecret(rl, question) {
             stdin.setRawMode(hadRawMode ?? false);
           }
           process.stdout.write("\n");
-          resolve32("");
+          resolve33("");
           return;
         } else if (c3 === "\x7F" || c3 === "\b") {
           if (secret.length > 0) {
@@ -36743,7 +37526,7 @@ async function ensureOllamaRunning(backendUrl, rl) {
     return false;
   }
   for (let i = 0; i < 5; i++) {
-    await new Promise((resolve32) => setTimeout(resolve32, 2e3));
+    await new Promise((resolve33) => setTimeout(resolve33, 2e3));
     try {
       const resp = await fetch(`${backendUrl}/api/tags`, {
         signal: AbortSignal.timeout(3e3)
@@ -37204,7 +37987,7 @@ async function doSetup(config, rl) {
         try {
           const child = spawn18("ollama", ["serve"], { stdio: "ignore", detached: true });
           child.unref();
-          await new Promise((resolve32) => setTimeout(resolve32, 3e3));
+          await new Promise((resolve33) => setTimeout(resolve33, 3e3));
           try {
             models = await fetchOllamaModels(config.backendUrl);
             process.stdout.write(`  ${c2.green("\u2714")} Ollama is running.
@@ -37232,7 +38015,7 @@ async function doSetup(config, rl) {
             try {
               const child = spawn18("ollama", ["serve"], { stdio: "ignore", detached: true });
               child.unref();
-              await new Promise((resolve32) => setTimeout(resolve32, 3e3));
+              await new Promise((resolve33) => setTimeout(resolve33, 3e3));
               try {
                 models = await fetchOllamaModels(config.backendUrl);
                 process.stdout.write(`  ${c2.green("\u2714")} Ollama is running.
@@ -37380,7 +38163,7 @@ async function doSetup(config, rl) {
           `PARAMETER num_predict ${numPredict}`,
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
-        const modelDir2 = join49(homedir10(), ".open-agents", "models");
+        const modelDir2 = join49(homedir12(), ".open-agents", "models");
         mkdirSync12(modelDir2, { recursive: true });
         const modelfilePath = join49(modelDir2, `Modelfile.${customName}`);
         writeFileSync13(modelfilePath, modelfileContent + "\n", "utf8");
@@ -37428,7 +38211,7 @@ async function isModelAvailable(config) {
 }
 function isFirstRun() {
   try {
-    return !existsSync33(join49(homedir10(), ".open-agents", "config.json"));
+    return !existsSync33(join49(homedir12(), ".open-agents", "config.json"));
   } catch {
     return true;
   }
@@ -37465,7 +38248,7 @@ function detectPkgManager() {
   return null;
 }
 function getVenvDir() {
-  return join49(homedir10(), ".open-agents", "venv");
+  return join49(homedir12(), ".open-agents", "venv");
 }
 function hasVenvModule() {
   try {
@@ -37490,7 +38273,7 @@ function ensureVenv(log) {
     return null;
   }
   try {
-    mkdirSync12(join49(homedir10(), ".open-agents"), { recursive: true });
+    mkdirSync12(join49(homedir12(), ".open-agents"), { recursive: true });
     execSync24(`python3 -m venv "${venvDir}"`, { stdio: "pipe", timeout: 3e4 });
     execSync24(`"${join49(venvDir, "bin", "pip")}" install --upgrade pip`, {
       stdio: "pipe",
@@ -37756,9 +38539,9 @@ function ensureCloudflaredBackground(onInfo) {
       const archMap = { x64: "amd64", arm64: "arm64", arm: "arm" };
       const cfArch = archMap[arch] ?? "amd64";
       try {
-        execSync24(`curl -fsSL "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${cfArch}" -o /tmp/cloudflared && chmod +x /tmp/cloudflared && mkdir -p "${homedir10()}/.local/bin" && mv /tmp/cloudflared "${homedir10()}/.local/bin/cloudflared"`, { stdio: "pipe", timeout: 6e4 });
-        if (!process.env.PATH?.includes(`${homedir10()}/.local/bin`)) {
-          process.env.PATH = `${homedir10()}/.local/bin:${process.env.PATH}`;
+        execSync24(`curl -fsSL "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${cfArch}" -o /tmp/cloudflared && chmod +x /tmp/cloudflared && mkdir -p "${homedir12()}/.local/bin" && mv /tmp/cloudflared "${homedir12()}/.local/bin/cloudflared"`, { stdio: "pipe", timeout: 6e4 });
+        if (!process.env.PATH?.includes(`${homedir12()}/.local/bin`)) {
+          process.env.PATH = `${homedir12()}/.local/bin:${process.env.PATH}`;
         }
         if (hasCmd("cloudflared")) {
           log("cloudflared installed.");
@@ -37853,7 +38636,7 @@ async function createExpandedVariantAsync(baseModel, specs, sizeGB, kvBytesPerTo
       `PARAMETER num_predict ${numPredict}`,
       `PARAMETER stop "<|endoftext|>"`
     ].join("\n");
-    const modelDir2 = join49(homedir10(), ".open-agents", "models");
+    const modelDir2 = join49(homedir12(), ".open-agents", "models");
     mkdirSync12(modelDir2, { recursive: true });
     const modelfilePath = join49(modelDir2, `Modelfile.${customName}`);
     writeFileSync13(modelfilePath, modelfileContent + "\n", "utf8");
@@ -37930,7 +38713,7 @@ async function ensureNeovim() {
   const platform5 = process.platform;
   const arch = process.arch;
   if (platform5 === "linux") {
-    const binDir = join49(homedir10(), ".local", "bin");
+    const binDir = join49(homedir12(), ".local", "bin");
     const nvimDest = join49(binDir, "nvim");
     try {
       mkdirSync12(binDir, { recursive: true });
@@ -38002,7 +38785,7 @@ async function ensureNeovim() {
 }
 function ensurePathInShellRc(binDir) {
   const shell = process.env.SHELL ?? "";
-  const rcFile = shell.includes("zsh") ? join49(homedir10(), ".zshrc") : join49(homedir10(), ".bashrc");
+  const rcFile = shell.includes("zsh") ? join49(homedir12(), ".zshrc") : join49(homedir12(), ".bashrc");
   try {
     const rcContent = existsSync33(rcFile) ? readFileSync24(rcFile, "utf8") : "";
     if (rcContent.includes(binDir))
@@ -38023,7 +38806,7 @@ var init_setup = __esm({
     init_render();
     init_config();
     init_dist();
-    execAsync = promisify5(exec2);
+    execAsync = promisify6(exec2);
     QWEN_VARIANTS = [
       { tag: "qwen3.5:0.8b", sizeGB: 1, label: "0.8B params (1.0 GB)", cloud: false },
       { tag: "qwen3.5:2b", sizeGB: 2.7, label: "2B params (2.7 GB)", cloud: false },
@@ -38221,7 +39004,7 @@ function tuiSelect(opts) {
   const maxVisible = opts.maxVisible ?? Math.max(3, contentArea - selectChrome);
   let scrollOffset = 0;
   let lastRenderedLines = 0;
-  return new Promise((resolve32) => {
+  return new Promise((resolve33) => {
     const stdin = process.stdin;
     const hadRawMode = stdin.isRaw;
     const savedRlListeners = [];
@@ -38396,7 +39179,7 @@ function tuiSelect(opts) {
               if (!isSkippable(itemIdx) && matchSet.has(itemIdx)) {
                 cursor = itemIdx;
                 cleanup();
-                resolve32({ confirmed: true, key: items[cursor].key, index: cursor });
+                resolve33({ confirmed: true, key: items[cursor].key, index: cursor });
                 return;
               } else if (!isSkippable(itemIdx)) {
                 cursor = itemIdx;
@@ -38472,7 +39255,7 @@ function tuiSelect(opts) {
                 items.splice(deletedIdx, 1);
                 if (items.length === 0) {
                   cleanup();
-                  resolve32({ confirmed: false, key: null, index: -1 });
+                  resolve33({ confirmed: false, key: null, index: -1 });
                   return;
                 }
                 updateFilter();
@@ -38561,7 +39344,7 @@ function tuiSelect(opts) {
       } else if (seq === "\r" || seq === "\n") {
         if (!isSkippable(cursor) && matchSet.has(cursor)) {
           cleanup();
-          resolve32({ confirmed: true, key: items[cursor].key, index: cursor });
+          resolve33({ confirmed: true, key: items[cursor].key, index: cursor });
         }
       } else if (seq === "\x1B" || seq === "\x1B\x1B") {
         if (filter) {
@@ -38574,14 +39357,14 @@ function tuiSelect(opts) {
           render();
         } else if (hasBreadcrumbs) {
           cleanup();
-          resolve32({ confirmed: false, key: "__back__", index: cursor });
+          resolve33({ confirmed: false, key: "__back__", index: cursor });
         } else {
           cleanup();
-          resolve32({ confirmed: false, key: null, index: cursor });
+          resolve33({ confirmed: false, key: null, index: cursor });
         }
       } else if (seq === "") {
         cleanup();
-        resolve32({ confirmed: false, key: null, index: cursor });
+        resolve33({ confirmed: false, key: null, index: cursor });
       } else if (seq === "\x7F" || seq === "\b") {
         if (filter.length > 0) {
           filter = filter.slice(0, -1);
@@ -38595,7 +39378,7 @@ function tuiSelect(opts) {
           render();
         } else if (hasBreadcrumbs) {
           cleanup();
-          resolve32({ confirmed: false, key: "__back__", index: cursor });
+          resolve33({ confirmed: false, key: "__back__", index: cursor });
         }
       } else if (seq.length === 1 && seq.charCodeAt(0) >= 32 && seq.charCodeAt(0) < 127) {
         if (opts.onCustomKey && !isSkippable(cursor) && matchSet.has(cursor)) {
@@ -38603,7 +39386,7 @@ function tuiSelect(opts) {
             done: () => render(),
             resolve: (result) => {
               cleanup();
-              resolve32(result);
+              resolve33(result);
             },
             getInput: (prompt, prefill) => getInputFromUser(prompt, prefill),
             render: () => render(),
@@ -38720,7 +39503,7 @@ var init_tui_select = __esm({
 
 // packages/cli/dist/tui/drop-panel.js
 import { existsSync as existsSync34 } from "node:fs";
-import { extname as extname9, resolve as resolve27 } from "node:path";
+import { extname as extname9, resolve as resolve28 } from "node:path";
 function ansi4(code, text) {
   return isTTY4 ? `\x1B[${code}m${text}\x1B[0m` : text;
 }
@@ -38833,7 +39616,7 @@ function showDropPanel(opts) {
       if (filePath.startsWith("file://")) {
         filePath = decodeURIComponent(filePath.slice(7));
       }
-      filePath = resolve27(filePath);
+      filePath = resolve28(filePath);
       if (!existsSync34(filePath)) {
         errorMsg = `File not found: ${filePath}`;
         render();
@@ -39145,12 +39928,12 @@ function stopNeovimMode() {
   } catch {
   }
   const s = _state;
-  return new Promise((resolve32) => {
+  return new Promise((resolve33) => {
     setTimeout(() => {
       if (s && !s.cleanedUp) {
         doCleanup(s);
       }
-      resolve32();
+      resolve33();
     }, 300);
   });
 }
@@ -39386,7 +40169,7 @@ __export(voice_exports, {
 });
 import { existsSync as existsSync36, mkdirSync as mkdirSync13, writeFileSync as writeFileSync14, readFileSync as readFileSync25, unlinkSync as unlinkSync8, readdirSync as readdirSync9, renameSync, statSync as statSync12 } from "node:fs";
 import { join as join51, dirname as dirname17 } from "node:path";
-import { homedir as homedir11, tmpdir as tmpdir9, platform as platform2 } from "node:os";
+import { homedir as homedir13, tmpdir as tmpdir9, platform as platform2 } from "node:os";
 import { execSync as execSync26, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
 function sanitizeForTTS(text) {
@@ -39410,7 +40193,7 @@ function listVoiceModels() {
   }));
 }
 function voiceDir() {
-  return join51(homedir11(), ".open-agents", "voice");
+  return join51(homedir13(), ".open-agents", "voice");
 }
 function modelsDir() {
   return join51(voiceDir(), "models");
@@ -40406,7 +41189,7 @@ var init_voice = __esm({
         }
         p = p.replace(/\\ /g, " ");
         if (p.startsWith("~/") || p === "~") {
-          p = join51(homedir11(), p.slice(1));
+          p = join51(homedir13(), p.slice(1));
         }
         if (!existsSync36(p)) {
           return `File not found: ${p}
@@ -40821,7 +41604,7 @@ var init_voice = __esm({
         this.speaking = false;
       }
       sleep(ms) {
-        return new Promise((resolve32) => setTimeout(resolve32, ms));
+        return new Promise((resolve33) => setTimeout(resolve33, ms));
       }
       // -------------------------------------------------------------------------
       // Synthesis pipeline
@@ -41087,7 +41870,7 @@ var init_voice = __esm({
         const cmd = this.getPlayCommand(path);
         if (!cmd)
           return;
-        return new Promise((resolve32) => {
+        return new Promise((resolve33) => {
           const child = nodeSpawn(cmd[0], cmd.slice(1), {
             stdio: "ignore",
             detached: false
@@ -41096,12 +41879,12 @@ var init_voice = __esm({
           child.on("close", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve32();
+            resolve33();
           });
           child.on("error", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve32();
+            resolve33();
           });
           setTimeout(() => {
             if (this.currentPlayback === child) {
@@ -41111,7 +41894,7 @@ var init_voice = __esm({
               }
               this.currentPlayback = null;
             }
-            resolve32();
+            resolve33();
           }, 15e3);
         });
       }
@@ -41186,7 +41969,7 @@ var init_voice = __esm({
       /** Non-blocking shell execution — async alternative to execSync.
        *  Returns stdout string on exit 0, rejects otherwise. */
       asyncShell(command, timeoutMs = 3e4) {
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           const proc = nodeSpawn("sh", ["-c", command], {
             stdio: ["ignore", "pipe", "pipe"],
             cwd: tmpdir9()
@@ -41207,7 +41990,7 @@ var init_voice = __esm({
           proc.on("close", (code) => {
             clearTimeout(timer);
             if (code === 0)
-              resolve32(stdout.trim());
+              resolve33(stdout.trim());
             else
               reject(new Error(stderr.slice(0, 300) || `Exit code ${code}`));
           });
@@ -41692,7 +42475,7 @@ if __name__ == '__main__':
         const venvPy = luxttsVenvPy();
         if (!existsSync36(venvPy))
           return false;
-        return new Promise((resolve32) => {
+        return new Promise((resolve33) => {
           const env = { ...process.env, LUXTTS_REPO_PATH: luxttsRepoDir() };
           const daemon = nodeSpawn(venvPy, [luxttsInferScript()], {
             stdio: ["pipe", "pipe", "pipe"],
@@ -41711,7 +42494,7 @@ if __name__ == '__main__':
               try {
                 const msg = JSON.parse(line);
                 if (msg.type === "ready") {
-                  resolve32(true);
+                  resolve33(true);
                 } else if (msg.type === "result" || msg.type === "error") {
                   const pending = this._luxttsPending.get(msg.id);
                   if (pending) {
@@ -41735,25 +42518,25 @@ if __name__ == '__main__':
           });
           daemon.on("error", () => {
             this._luxttsDaemon = null;
-            resolve32(false);
+            resolve33(false);
           });
           setTimeout(() => {
             if (this._luxttsDaemon === daemon && !this._luxttsPending.has("__ready__")) {
-              resolve32(false);
+              resolve33(false);
             }
           }, 6e4);
         });
       }
       /** Send a request to the LuxTTS daemon and await the response */
       luxttsRequest(req) {
-        return new Promise((resolve32, reject) => {
+        return new Promise((resolve33, reject) => {
           if (!this._luxttsDaemon || this._luxttsDaemon.killed) {
             reject(new Error("LuxTTS daemon not running"));
             return;
           }
           const id = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
           req.id = id;
-          this._luxttsPending.set(id, { resolve: resolve32, reject });
+          this._luxttsPending.set(id, { resolve: resolve33, reject });
           this._luxttsDaemon.stdin.write(JSON.stringify(req) + "\n");
           setTimeout(() => {
             if (this._luxttsPending.has(id)) {
@@ -44777,9 +45560,9 @@ async function handleVoiceMenu(ctx, save, hasLocal) {
             }
             const { basename: basename16, join: pathJoin } = await import("node:path");
             const { copyFileSync: copyFileSync2, mkdirSync: mkdirSync22, existsSync: exists } = await import("node:fs");
-            const { homedir: homedir16 } = await import("node:os");
+            const { homedir: homedir18 } = await import("node:os");
             const modelName = basename16(onnxDrop.path, ".onnx").replace(/[^a-zA-Z0-9_-]/g, "-");
-            const destDir = pathJoin(homedir16(), ".open-agents", "voice", "models", modelName);
+            const destDir = pathJoin(homedir18(), ".open-agents", "voice", "models", modelName);
             if (!exists(destDir))
               mkdirSync22(destDir, { recursive: true });
             copyFileSync2(onnxDrop.path, pathJoin(destDir, "model.onnx"));
@@ -45680,11 +46463,11 @@ async function handleUpdate(subcommand, ctx) {
   const targetVersion = info?.latestVersion ?? currentVersion;
   const installOverlay = startInstallOverlay(targetVersion);
   let installError = "";
-  const runInstall2 = (cmd) => new Promise((resolve32) => {
+  const runInstall2 = (cmd) => new Promise((resolve33) => {
     const child = exec4(cmd, { timeout: 18e4 }, (err, _stdout, stderr) => {
       if (err)
         installError = (stderr || err.message || "").trim();
-      resolve32(!err);
+      resolve33(!err);
     });
     child.stdout?.on("data", (chunk) => {
       const text = String(chunk);
@@ -45778,8 +46561,8 @@ async function handleUpdate(subcommand, ctx) {
   }
   if (doRebuild) {
     installOverlay.setStatus("Rebuilding native modules...");
-    await new Promise((resolve32) => {
-      const child = exec4(`${sudoPrefix}npm rebuild -g open-agents-ai 2>/dev/null || true`, { timeout: 12e4 }, () => resolve32(true));
+    await new Promise((resolve33) => {
+      const child = exec4(`${sudoPrefix}npm rebuild -g open-agents-ai 2>/dev/null || true`, { timeout: 12e4 }, () => resolve33(true));
       child.stdout?.resume();
       child.stderr?.resume();
     });
@@ -45810,8 +46593,8 @@ async function handleUpdate(subcommand, ctx) {
     const venvPip = pathJoin(venvDir, "bin", "pip");
     if (fsExists(venvPip)) {
       installOverlay.setStatus("Upgrading Python packages...");
-      await new Promise((resolve32) => {
-        const child = exec4(`"${venvPip}" install --upgrade moondream-station pytesseract Pillow opencv-python-headless numpy 2>/dev/null || true`, { timeout: 3e5 }, (err) => resolve32(!err));
+      await new Promise((resolve33) => {
+        const child = exec4(`"${venvPip}" install --upgrade moondream-station pytesseract Pillow opencv-python-headless numpy 2>/dev/null || true`, { timeout: 3e5 }, (err) => resolve33(!err));
         child.stdout?.resume();
         child.stderr?.resume();
       });
@@ -46207,16 +46990,16 @@ async function showExposeDashboard(gateway, rl, ctx) {
     renderDashboard();
   }, 1e3);
   let stopGateway = false;
-  await new Promise((resolve32) => {
+  await new Promise((resolve33) => {
     const onData = (data) => {
       const key = data.toString();
       if (key === "q" || key === "Q" || key === "\x1B" || key === "") {
-        resolve32();
+        resolve33();
         return;
       }
       if (key === "s" || key === "S") {
         stopGateway = true;
-        resolve32();
+        resolve33();
         return;
       }
       if (key === "c" || key === "C") {
@@ -46267,8 +47050,8 @@ async function showExposeDashboard(gateway, rl, ctx) {
         process.stdout.write("\x1B[?1002h\x1B[?1006h");
       }
     };
-    const origResolve = resolve32;
-    resolve32 = (() => {
+    const origResolve = resolve33;
+    resolve33 = (() => {
       cleanup();
       origResolve();
     });
@@ -46326,7 +47109,7 @@ var init_commands = __esm({
 import { existsSync as existsSync38, readFileSync as readFileSync27, readdirSync as readdirSync11 } from "node:fs";
 import { join as join53, basename as basename10 } from "node:path";
 import { execSync as execSync27 } from "node:child_process";
-import { homedir as homedir13, platform as platform3, release } from "node:os";
+import { homedir as homedir15, platform as platform3, release } from "node:os";
 function getModelTier(modelName) {
   const m = modelName.toLowerCase();
   const sizeMatch = m.match(/\b(\d+)b\b/);
@@ -46413,7 +47196,7 @@ function loadMemoryContext(repoRoot) {
     if (legacyEntries)
       sections.push(legacyEntries);
   }
-  const globalMemDir = join53(homedir13(), ".open-agents", "memory");
+  const globalMemDir = join53(homedir15(), ".open-agents", "memory");
   const globalEntries = loadMemoryDir(globalMemDir, "global");
   if (globalEntries)
     sections.push(globalEntries);
@@ -52133,7 +52916,7 @@ var init_tool_policy = __esm({
 
 // packages/cli/dist/tui/telegram-bridge.js
 import { mkdirSync as mkdirSync19, existsSync as existsSync44, unlinkSync as unlinkSync10, readdirSync as readdirSync16, statSync as statSync14 } from "node:fs";
-import { join as join60, resolve as resolve28 } from "node:path";
+import { join as join60, resolve as resolve29 } from "node:path";
 import { writeFile as writeFileAsync } from "node:fs/promises";
 function convertMarkdownToTelegramHTML(md) {
   let html = md;
@@ -52376,7 +53159,7 @@ with summary "no_reply" to silently skip without responding.
         this.agentConfig = agentConfig;
         this.repoRoot = repoRoot;
         this.toolPolicyConfig = toolPolicyConfig;
-        this.mediaCacheDir = resolve28(repoRoot || ".", ".oa", "telegram-media-cache");
+        this.mediaCacheDir = resolve29(repoRoot || ".", ".oa", "telegram-media-cache");
       }
       /** Set admin user ID filter */
       setAdmin(userId) {
@@ -53612,7 +54395,7 @@ var init_braille_spinner = __esm({
 // packages/cli/dist/tui/system-metrics.js
 import { loadavg as loadavg3, cpus as cpus3, totalmem as totalmem4, freemem as freemem3, platform as platform4 } from "node:os";
 import { exec as exec3 } from "node:child_process";
-import { readFile as readFile21 } from "node:fs/promises";
+import { readFile as readFile22 } from "node:fs/promises";
 function formatRate(bytesPerSec) {
   if (bytesPerSec < 1024)
     return `${Math.round(bytesPerSec)}B`;
@@ -53624,7 +54407,7 @@ function formatRate(bytesPerSec) {
 }
 async function readProcNetDev() {
   try {
-    const data = await readFile21("/proc/net/dev", "utf8");
+    const data = await readFile22("/proc/net/dev", "utf8");
     let rxTotal = 0;
     let txTotal = 0;
     for (const line of data.split("\n")) {
@@ -53662,8 +54445,8 @@ async function collectNetworkMetrics() {
   }
   if (plat === "darwin") {
     try {
-      const output = await new Promise((resolve32, reject) => {
-        exec3("netstat -ib 2>/dev/null | head -30", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => err ? reject(err) : resolve32(stdout));
+      const output = await new Promise((resolve33, reject) => {
+        exec3("netstat -ib 2>/dev/null | head -30", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => err ? reject(err) : resolve33(stdout));
       });
       let rxBytes = 0, txBytes = 0;
       for (const line of output.split("\n")) {
@@ -53697,8 +54480,8 @@ async function collectGpuMetrics() {
   if (_nvidiaSmiAvailable === false)
     return noGpu;
   try {
-    const smi = await new Promise((resolve32, reject) => {
-      exec3("nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => err ? reject(err) : resolve32(stdout));
+    const smi = await new Promise((resolve33, reject) => {
+      exec3("nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => err ? reject(err) : resolve33(stdout));
     });
     _nvidiaSmiAvailable = true;
     const line = smi.trim().split("\n")[0];
@@ -56347,13 +57130,13 @@ var init_mouse_filter = __esm({
 import * as readline2 from "node:readline";
 import { Writable } from "node:stream";
 import { cwd } from "node:process";
-import { resolve as resolve29, join as join61, dirname as dirname19, extname as extname10 } from "node:path";
+import { resolve as resolve30, join as join61, dirname as dirname19, extname as extname10 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
 import { readFileSync as readFileSync34, writeFileSync as writeFileSync19, appendFileSync as appendFileSync4, rmSync as rmSync3, readdirSync as readdirSync17, mkdirSync as mkdirSync20 } from "node:fs";
 import { existsSync as existsSync45 } from "node:fs";
 import { execSync as execSync30 } from "node:child_process";
-import { homedir as homedir14 } from "node:os";
+import { homedir as homedir16 } from "node:os";
 function formatTimeAgo(date) {
   const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
   if (seconds < 60)
@@ -56502,6 +57285,9 @@ function buildTools(repoRoot, config, contextWindowSize) {
     new OpenCodeTool(repoRoot),
     new FactoryTool(repoRoot),
     new CronAgentTool(repoRoot),
+    // Chunked file exploration + working notes
+    new FileExploreTool(repoRoot),
+    new WorkingNotesTool(),
     // Nexus P2P networking + x402 micropayments
     new NexusTool(repoRoot)
   ];
@@ -57651,7 +58437,7 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
   } };
 }
 async function startInteractive(config, repoPath) {
-  const repoRoot = resolve29(repoPath ?? cwd());
+  const repoRoot = resolve30(repoPath ?? cwd());
   const resumeFlag = process.env.__OA_RESUMED ?? "";
   const isResumed = resumeFlag !== "";
   const hasTaskToResume = resumeFlag === "1";
@@ -57823,14 +58609,14 @@ async function startInteractive(config, repoPath) {
       renderInfo(msg);
       statusBar.endContentWrite();
     }
-  }, () => new Promise((resolve32) => {
+  }, () => new Promise((resolve33) => {
     depSudoPromptPending = true;
     depSudoResolver = (pw) => {
       depSudoPromptPending = false;
       depSudoResolver = null;
       if (pw)
         sessionSudoPassword = pw;
-      resolve32(pw);
+      resolve33(pw);
     };
     const pwPrompt1 = `  ${c2.bold(c2.yellow("\u{1F511} Password needed for dependency install:"))}
 `;
@@ -58118,7 +58904,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     const hits = allCompletions.filter((c3) => c3.toLowerCase().startsWith(lower));
     return [hits, line];
   }
-  const HISTORY_DIR = join61(homedir14(), ".open-agents");
+  const HISTORY_DIR = join61(homedir16(), ".open-agents");
   const HISTORY_FILE = join61(HISTORY_DIR, "repl-history");
   const MAX_HISTORY_LINES = 500;
   let savedHistory = [];
@@ -59634,7 +60420,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       } catch {
       }
       try {
-        const voiceDir2 = join61(homedir14(), ".open-agents", "voice");
+        const voiceDir2 = join61(homedir16(), ".open-agents", "voice");
         const voicePidFiles = ["luxtts-daemon.pid", "piper-daemon.pid"];
         for (const pf of voicePidFiles) {
           const pidPath = join61(voiceDir2, pf);
@@ -60037,8 +60823,8 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync45(resolve29(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync45(resolve29(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync45(resolve30(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync45(resolve30(repoRoot, cleanPath));
     if (activeTask) {
       if (activeTask.runner.isPaused) {
         activeTask.runner.resume();
@@ -60046,7 +60832,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
       if (isImage) {
         try {
-          const imgPath = resolve29(repoRoot, cleanPath);
+          const imgPath = resolve30(repoRoot, cleanPath);
           const imgBuffer = readFileSync34(imgPath);
           const base64 = imgBuffer.toString("base64");
           const ext = extname10(cleanPath).toLowerCase();
@@ -60060,7 +60846,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
       } else if (isMedia) {
         writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
         const engine = getListenEngine();
-        const result = await engine.transcribeFile(resolve29(repoRoot, cleanPath), repoRoot);
+        const result = await engine.transcribeFile(resolve30(repoRoot, cleanPath), repoRoot);
         if (result) {
           const transcript = `[Transcription of ${cleanPath}]
 ${result.text}`;
@@ -60204,7 +60990,7 @@ ${result.text}`;
       const ext = cleanPath.toLowerCase().split(".").pop() || "";
       if (cloneExts.includes("." + ext)) {
         writeContent(() => renderInfo(`Setting voice clone reference: ${cleanPath}`));
-        const msg = await voiceEngine.setCloneVoice(resolve29(repoRoot, cleanPath));
+        const msg = await voiceEngine.setCloneVoice(resolve30(repoRoot, cleanPath));
         writeContent(() => renderInfo(msg));
         showPrompt();
         return;
@@ -60213,7 +60999,7 @@ ${result.text}`;
     if (isMedia && fullInput === input) {
       writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
       const engine = getListenEngine();
-      const result = await engine.transcribeFile(resolve29(repoRoot, cleanPath), repoRoot);
+      const result = await engine.transcribeFile(resolve30(repoRoot, cleanPath), repoRoot);
       if (result) {
         fullInput = `The user has provided an audio/video file: ${cleanPath}.
 
@@ -60499,7 +61285,7 @@ ${c2.dim("(Use /quit to exit)")}
   };
 }
 async function runWithTUI(task, config, repoPath) {
-  const repoRoot = resolve29(repoPath ?? cwd());
+  const repoRoot = resolve30(repoPath ?? cwd());
   const needsSetup = isFirstRun() || !await isModelAvailable(config);
   if (needsSetup && config.backendType === "ollama") {
     const setupModel = await runSetupWizard(config);
@@ -60882,7 +61668,7 @@ var init_run = __esm({
 // packages/indexer/dist/codebase-indexer.js
 import { glob } from "glob";
 import ignore from "ignore";
-import { readFile as readFile22, stat as stat4 } from "node:fs/promises";
+import { readFile as readFile23, stat as stat4 } from "node:fs/promises";
 import { createHash as createHash4 } from "node:crypto";
 import { join as join62, relative as relative3, extname as extname11, basename as basename15 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
@@ -60928,7 +61714,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile22(join62(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile23(join62(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -60948,7 +61734,7 @@ var init_codebase_indexer = __esm({
             const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
               continue;
-            const content = await readFile22(fullPath);
+            const content = await readFile23(fullPath);
             const hash = createHash4("sha256").update(content).digest("hex");
             const ext = extname11(relativePath);
             indexed.push({
@@ -61071,11 +61857,11 @@ var index_repo_exports = {};
 __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
-import { resolve as resolve30 } from "node:path";
+import { resolve as resolve31 } from "node:path";
 import { existsSync as existsSync46, statSync as statSync15 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
-  const repoRoot = resolve30(opts.repoPath ?? cwd2());
+  const repoRoot = resolve31(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
   if (!existsSync46(repoRoot)) {
@@ -61330,8 +62116,8 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join63, resolve as resolve31 } from "node:path";
-import { homedir as homedir15 } from "node:os";
+import { join as join63, resolve as resolve32 } from "node:path";
+import { homedir as homedir17 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function redactIfSensitive(key, value) {
   if (SENSITIVE_KEYS.has(key) && typeof value === "string" && value.length > 0) {
@@ -61363,7 +62149,7 @@ async function configCommand(opts, config) {
   return handleShow(opts, config);
 }
 function handleShow(opts, config) {
-  const repoRoot = resolve31(opts.repoPath ?? cwd3());
+  const repoRoot = resolve32(opts.repoPath ?? cwd3());
   printHeader("Configuration");
   const resolved = resolveSettings(repoRoot);
   printSection("Core Inference");
@@ -61413,7 +62199,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join63(homedir15(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join63(homedir17(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -61446,7 +62232,7 @@ function handleSet(opts, _config) {
     process.exit(1);
   }
   if (opts.local) {
-    const repoRoot = resolve31(opts.repoPath ?? cwd3());
+    const repoRoot = resolve32(opts.repoPath ?? cwd3());
     try {
       initOaDirectory(repoRoot);
       const coerced = coerceForSettings(key, value);
@@ -61644,7 +62430,7 @@ async function serveVllm(opts, config) {
   await runVllmServer(args, opts.verbose ?? false);
 }
 async function runVllmServer(args, verbose) {
-  return new Promise((resolve32, reject) => {
+  return new Promise((resolve33, reject) => {
     const child = spawn19("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
@@ -61679,10 +62465,10 @@ async function runVllmServer(args, verbose) {
     child.once("exit", (code, signal) => {
       if (signal) {
         printInfo(`vLLM server stopped by signal ${signal}`);
-        resolve32();
+        resolve33();
       } else if (code === 0) {
         printSuccess("vLLM server exited cleanly");
-        resolve32();
+        resolve33();
       } else {
         printError(`vLLM server exited with code ${code}`);
         reject(new Error(`vLLM exited with code ${code}`));