@pensar/apex 0.0.80 → 0.0.81-canary.5a90bb41

package/build/index.js

@@ -31956,7 +31956,7 @@ var package_default2;
 var init_package = __esm(() => {
   package_default2 = {
     name: "@pensar/apex",
-    version: "0.0.80",
+    version: "0.0.81-canary.5a90bb41",
     description: "AI-powered penetration testing CLI tool with terminal UI",
     module: "src/tui/index.tsx",
     main: "build/index.js",
@@ -36137,6 +36137,279 @@ var init_zod = __esm(() => {
   zod_default = exports_external;
 });
 
+// src/util/errors.ts
+var NamedError;
+var init_errors2 = __esm(() => {
+  init_zod();
+  NamedError = class NamedError extends Error {
+    static create(name, data) {
+      const schema2 = zod_default.object({
+        name: zod_default.literal(name),
+        data
+      });
+      const result = class extends NamedError {
+        data;
+        static Schema = schema2;
+        name = name;
+        constructor(data2, options) {
+          super(name, options);
+          this.data = data2;
+          this.name = name;
+        }
+        static isInstance(input) {
+          return typeof input === "object" && input !== null && "name" in input && input.name === name;
+        }
+        schema() {
+          return schema2;
+        }
+        toObject() {
+          return {
+            name,
+            data: this.data
+          };
+        }
+      };
+      Object.defineProperty(result, "name", { value: name });
+      return result;
+    }
+    static Unknown = NamedError.create("UnknownError", zod_default.object({
+      message: zod_default.string()
+    }));
+  };
+});
+
+// src/util/lock.ts
+function getLock(key) {
+  if (!locks.has(key)) {
+    locks.set(key, {
+      readers: 0,
+      writer: false,
+      waitingReaders: [],
+      waitingWriters: []
+    });
+  }
+  return locks.get(key);
+}
+function processQueue(key) {
+  const lock = locks.get(key);
+  if (!lock || lock.writer || lock.readers > 0)
+    return;
+  if (lock.waitingWriters.length > 0) {
+    const nextWriter = lock.waitingWriters.shift();
+    nextWriter();
+    return;
+  }
+  while (lock.waitingReaders.length > 0) {
+    const nextReader = lock.waitingReaders.shift();
+    nextReader();
+  }
+  if (lock.readers === 0 && !lock.writer && lock.waitingReaders.length === 0 && lock.waitingWriters.length === 0) {
+    locks.delete(key);
+  }
+}
+async function read(key) {
+  const lock = getLock(key);
+  return new Promise((resolve3) => {
+    if (!lock.writer && lock.waitingWriters.length === 0) {
+      lock.readers++;
+      resolve3({
+        [Symbol.dispose]: () => {
+          lock.readers--;
+          processQueue(key);
+        }
+      });
+    } else {
+      lock.waitingReaders.push(() => {
+        lock.readers++;
+        resolve3({
+          [Symbol.dispose]: () => {
+            lock.readers--;
+            processQueue(key);
+          }
+        });
+      });
+    }
+  });
+}
+async function write(key) {
+  const lock = getLock(key);
+  return new Promise((resolve3) => {
+    if (!lock.writer && lock.readers === 0) {
+      lock.writer = true;
+      resolve3({
+        [Symbol.dispose]: () => {
+          lock.writer = false;
+          processQueue(key);
+        }
+      });
+    } else {
+      lock.waitingWriters.push(() => {
+        lock.writer = true;
+        resolve3({
+          [Symbol.dispose]: () => {
+            lock.writer = false;
+            processQueue(key);
+          }
+        });
+      });
+    }
+  });
+}
+var locks;
+var init_lock = __esm(() => {
+  locks = new Map;
+});
+
+// src/core/storage/index.ts
+import os3 from "os";
+import path3 from "path";
+import fs3 from "fs/promises";
+import { readdir } from "fs/promises";
+function getBaseDir() {
+  return process.env.PENSAR_DATA_DIR ?? path3.join(os3.homedir(), ".pensar");
+}
+async function remove(key) {
+  const dir = getBaseDir();
+  const target = path3.join(dir, ...key) + ".json";
+  return withErrorHandling(async () => {
+    await fs3.unlink(target).catch(() => {});
+  });
+}
+async function write2(key, content, ext) {
+  const dir = getBaseDir();
+  const target = path3.join(dir, ...key) + (ext ? ext : ".json");
+  return withErrorHandling(async () => {
+    let __stack = [];
+    try {
+      const _2 = __using(__stack, await write(target), 0);
+      await fs3.mkdir(path3.dirname(target), { recursive: true });
+      await fs3.writeFile(target, JSON.stringify(content, null, 2), "utf-8");
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
+  });
+}
+async function createDir(key) {
+  const dir = getBaseDir();
+  const target = path3.join(dir, ...key);
+  return withErrorHandling(async () => {
+    let __stack = [];
+    try {
+      const _2 = __using(__stack, await write(target), 0);
+      await fs3.mkdir(target, { recursive: true });
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
+  });
+}
+async function writeRaw(key, content) {
+  const dir = getBaseDir();
+  const target = path3.join(dir, ...key);
+  return withErrorHandling(async () => {
+    let __stack = [];
+    try {
+      const _2 = __using(__stack, await write(target), 0);
+      const parentDir = path3.dirname(target);
+      await fs3.mkdir(parentDir, { recursive: true });
+      await fs3.writeFile(target, content, "utf-8");
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
+  });
+}
+async function read2(key, ext) {
+  const dir = getBaseDir();
+  const target = path3.join(dir, ...key) + (ext ? ext : ".json");
+  return withErrorHandling(async () => {
+    let __stack = [];
+    try {
+      const _2 = __using(__stack, await read(target), 0);
+      const text = await fs3.readFile(target, "utf-8");
+      const result = ext ? text : JSON.parse(text);
+      return result;
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
+  });
+}
+async function update2(key, fn, ext) {
+  const dir = getBaseDir();
+  const target = path3.join(dir, ...key) + (ext ? ext : ".json");
+  return withErrorHandling(async () => {
+    let __stack = [];
+    try {
+      const _2 = __using(__stack, await write(target), 0);
+      const text = await fs3.readFile(target, "utf-8");
+      const content = ext ? text : JSON.parse(text);
+      fn(content);
+      await fs3.writeFile(target, JSON.stringify(content, null, 2), "utf-8");
+      return content;
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
+  });
+}
+async function withErrorHandling(body) {
+  return body().catch((e) => {
+    if (!(e instanceof Error))
+      throw e;
+    const errnoExcpetion = e;
+    if (errnoExcpetion.code === "ENOENT") {
+      throw new NotFoundError({
+        message: `Resource not found: ${errnoExcpetion.path}`
+      });
+    }
+    throw e;
+  });
+}
+async function listFilesRecursively(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFilesRecursively(fullPath));
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function list(prefix) {
+  const dir = getBaseDir();
+  const targetDir = path3.join(dir, ...prefix);
+  try {
+    const files = await listFilesRecursively(targetDir);
+    const result = files.map((filePath) => {
+      const relativePath = path3.relative(targetDir, filePath);
+      return [...prefix, ...relativePath.slice(0, -5).split(path3.sep)];
+    });
+    result.sort();
+    return result;
+  } catch {
+    return [];
+  }
+}
+var NotFoundError;
+var init_storage = __esm(() => {
+  init_zod();
+  init_errors2();
+  init_lock();
+  NotFoundError = NamedError.create("NotFoundError", zod_default.object({
+    message: zod_default.string()
+  }));
+});
+
 // src/core/credentials/manager.ts
 import { randomBytes as randomBytes2 } from "crypto";
 function generateCredentialId() {
@@ -36615,6 +36888,30 @@ var init_toolset = __esm(() => {
       detail: "Validate that testing is complete by checking coverage against the original scope and identifying any gaps.",
       category: "utility",
       defaultEnabled: true
+    },
+    {
+      id: "add_memory",
+      name: "Add Memory",
+      description: "Save to memory",
+      detail: "Save a piece of knowledge to persistent memory. Memories survive across sessions and can store reusable techniques, target notes, credential patterns, useful payloads, or any information worth remembering.",
+      category: "utility",
+      defaultEnabled: true
+    },
+    {
+      id: "list_memories",
+      name: "List Memories",
+      description: "Browse saved memories",
+      detail: "List all saved memories with optional tag filtering. Returns summaries sorted by most recent first. Use the returned id with Get Memory to retrieve full content.",
+      category: "utility",
+      defaultEnabled: true
+    },
+    {
+      id: "get_memory",
+      name: "Get Memory",
+      description: "Retrieve a memory",
+      detail: "Retrieve the full content of a saved memory by its id. Use List Memories first to discover available memory ids.",
+      category: "utility",
+      defaultEnabled: true
     }
   ];
   TOOLSETS = [
@@ -37017,9 +37314,9 @@ function saveSubagentData(session, data) {
   const filename = `${data.agentName}-${ts}.json`;
   writeFileSync2(join4(subagentsDir, filename), JSON.stringify(savedData, null, 2));
 }
-function writeAgentManifest(session, entries) {
+function writeAgentManifest(session, entries2) {
   const manifestPath = join4(session.rootPath, MANIFEST_FILE);
-  writeFileSync2(manifestPath, JSON.stringify(entries, null, 2));
+  writeFileSync2(manifestPath, JSON.stringify(entries2, null, 2));
 }
 function buildManifestEntries(targets) {
   return targets.map((t2, i) => ({
@@ -37032,8 +37329,8 @@ function buildManifestEntries(targets) {
     spawnedAt: new Date().toISOString()
   }));
 }
-function finalizeManifest(session, entries, results) {
-  const finalManifest = entries.map((entry, i) => ({
+function finalizeManifest(session, entries2, results) {
+  const finalManifest = entries2.map((entry, i) => ({
     ...entry,
     status: results[i] != null ? "completed" : "failed",
     completedAt: new Date().toISOString()
@@ -37612,9 +37909,9 @@ function assertNever(_x) {
   throw new Error;
 }
 function assert(_2) {}
-function getEnumValues(entries) {
-  const numericValues = Object.values(entries).filter((v2) => typeof v2 === "number");
-  const values = Object.entries(entries).filter(([k2, _2]) => numericValues.indexOf(+k2) === -1).map(([_2, v2]) => v2);
+function getEnumValues(entries2) {
+  const numericValues = Object.values(entries2).filter((v2) => typeof v2 === "number");
+  const values = Object.entries(entries2).filter(([k2, _2]) => numericValues.indexOf(+k2) === -1).map(([_2, v2]) => v2);
   return values;
 }
 function joinValues(array, separator = "|") {
@@ -38208,7 +38505,7 @@ var initializer = (inst, def) => {
     enumerable: false
   });
 }, $ZodError, $ZodRealError;
-var init_errors2 = __esm(() => {
+var init_errors3 = __esm(() => {
   init_core();
   init_util2();
   $ZodError = $constructor("$ZodError", initializer);
@@ -38261,7 +38558,7 @@ var _parse = (_Err) => (schema2, value, _ctx, _params) => {
 }, safeParseAsync;
 var init_parse = __esm(() => {
   init_core();
-  init_errors2();
+  init_errors3();
   init_util2();
   parse2 = /* @__PURE__ */ _parse($ZodRealError);
   parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
@@ -46216,17 +46513,17 @@ function _set(Class2, valueType, params) {
   });
 }
 function _enum(Class2, values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
+  const entries2 = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
   return new Class2({
     type: "enum",
-    entries,
+    entries: entries2,
     ...normalizeParams(params)
   });
 }
-function _nativeEnum(Class2, entries, params) {
+function _nativeEnum(Class2, entries2, params) {
   return new Class2({
     type: "enum",
-    entries,
+    entries: entries2,
     ...normalizeParams(params)
   });
 }
@@ -47513,7 +47810,7 @@ var init_core2 = __esm(() => {
   init_json_schema();
   init_core();
   init_parse();
-  init_errors2();
+  init_errors3();
   init_schemas2();
   init_checks();
   init_versions();
@@ -47598,7 +47895,7 @@ var initializer2 = (inst, issues) => {
     }
   });
 }, ZodError3, ZodRealError;
-var init_errors3 = __esm(() => {
+var init_errors4 = __esm(() => {
   init_core2();
   init_core2();
   ZodError3 = $constructor("ZodError", initializer2);
@@ -47611,7 +47908,7 @@ var init_errors3 = __esm(() => {
 var parse4, parseAsync2, safeParse2, safeParseAsync2;
 var init_parse2 = __esm(() => {
   init_core2();
-  init_errors3();
+  init_errors4();
   parse4 = /* @__PURE__ */ _parse(ZodRealError);
   parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
   safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
@@ -47850,17 +48147,17 @@ function set(valueType, params) {
   });
 }
 function _enum2(values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
+  const entries2 = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
   return new ZodEnum2({
     type: "enum",
-    entries,
+    entries: entries2,
     ...exports_util.normalizeParams(params)
   });
 }
-function nativeEnum(entries, params) {
+function nativeEnum(entries2, params) {
   return new ZodEnum2({
     type: "enum",
-    entries,
+    entries: entries2,
     ...exports_util.normalizeParams(params)
   });
 }
@@ -48835,7 +49132,7 @@ var init_external2 = __esm(() => {
   init_coerce();
   init_schemas3();
   init_checks2();
-  init_errors3();
+  init_errors4();
   init_parse2();
   init_compat();
   config2(en_default2());
@@ -53268,8 +53565,8 @@ var require_baggage_impl = __commonJS((exports) => {
   exports.BaggageImpl = undefined;
 
   class BaggageImpl {
-    constructor(entries) {
-      this._entries = entries ? new Map(entries) : new Map;
+    constructor(entries2) {
+      this._entries = entries2 ? new Map(entries2) : new Map;
     }
     getEntry(key) {
       const entry = this._entries.get(key);
@@ -53320,8 +53617,8 @@ var require_utils = __commonJS((exports) => {
   var baggage_impl_1 = require_baggage_impl();
   var symbol_1 = require_symbol();
   var diag = diag_1.DiagAPI.instance();
-  function createBaggage(entries = {}) {
-    return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries)));
+  function createBaggage(entries2 = {}) {
+    return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries2)));
   }
   exports.createBaggage = createBaggage;
   function baggageEntryMetadataFromString(str) {
@@ -99560,8 +99857,8 @@ var require_dist2 = __commonJS((exports, module2) => {
       return ajv;
     }
     const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
-    const list2 = opts.formats || formats_1.formatNames;
-    addFormats(ajv, list2, formats, exportName);
+    const list3 = opts.formats || formats_1.formatNames;
+    addFormats(ajv, list3, formats, exportName);
     if (opts.keywords)
       (0, limit_1.default)(ajv);
     return ajv;
@@ -99573,11 +99870,11 @@ var require_dist2 = __commonJS((exports, module2) => {
       throw new Error(`Unknown format "${name26}"`);
     return f;
   };
-  function addFormats(ajv, list2, fs5, exportName) {
+  function addFormats(ajv, list3, fs5, exportName) {
     var _a26;
     var _b16;
     (_a26 = (_b16 = ajv.opts.code).formats) !== null && _a26 !== undefined || (_b16.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
-    for (const f of list2)
+    for (const f of list3)
       ajv.addFormat(f, fs5[f]);
   }
   module2.exports = exports = formatsPlugin;
@@ -103892,19 +104189,19 @@ var init_readFile = __esm(() => {
 });
 
 // src/core/agents/offSecAgent/tools/listFiles.ts
-import { readdir, stat } from "fs/promises";
+import { readdir as readdir2, stat } from "fs/promises";
 import { join as join12, relative } from "path";
 async function listRecursive(dir, maxEntries) {
   const results = [];
   let total = 0;
   async function walk(current) {
-    let entries;
+    let entries2;
     try {
-      entries = await readdir(current, { withFileTypes: true });
+      entries2 = await readdir2(current, { withFileTypes: true });
     } catch {
       return;
     }
-    for (const entry of entries) {
+    for (const entry of entries2) {
       total++;
       const fullPath = join12(current, entry.name);
       if (entry.isDirectory()) {
@@ -103967,8 +104264,8 @@ Each directory entry is suffixed with "/" for easy identification.`,
             totalFound: total > MAX_RECURSIVE ? total : undefined
           };
         }
-        const entries = await readdir(dir, { withFileTypes: true });
-        const fullPaths = entries.map((e) => {
+        const entries2 = await readdir2(dir, { withFileTypes: true });
+        const fullPaths = entries2.map((e) => {
           const name26 = join12(dir, e.name);
           return e.isDirectory() ? `${name26}/` : name26;
         });
@@ -103976,11 +104273,11 @@ Each directory entry is suffixed with "/" for easy identification.`,
         const relPaths = toRelative(dir, capped);
         return {
           success: true,
-          error: entries.length > MAX_NON_RECURSIVE ? `Showing ${MAX_NON_RECURSIVE} of ${entries.length} entries` : "",
+          error: entries2.length > MAX_NON_RECURSIVE ? `Showing ${MAX_NON_RECURSIVE} of ${entries2.length} entries` : "",
           files: relPaths,
           directory: dir,
           count: relPaths.length,
-          totalFound: entries.length > MAX_NON_RECURSIVE ? entries.length : undefined
+          totalFound: entries2.length > MAX_NON_RECURSIVE ? entries2.length : undefined
         };
       } catch (err) {
         return {
@@ -104982,6 +105279,13 @@ When to use delegate_to_auth_subagent vs authenticate_session:
             tokens = { ...stored.tokens };
           }
         }
+        const subagentId = "auth-agent";
+        const cbs = ctx4.subagentCallbacks;
+        cbs?.onSubagentSpawn?.({
+          subagentId,
+          input: { target, reason },
+          status: "pending"
+        });
         console.log(`
 \uD83D\uDD10 Delegating to authentication subagent...`);
         console.log(`   Target: ${target}`);
@@ -105033,6 +105337,12 @@ When to use delegate_to_auth_subagent vs authenticate_session:
           ctx4.session.credentialManager.addFromAuthCredentials(credentials);
         }
         const { runAuthenticationAgent: runAuthenticationAgent3 } = await Promise.resolve().then(() => (init_authentication(), exports_authentication));
+        const subagentCallbacks = cbs ? {
+          onTextDelta: (d2) => cbs.onTextDelta?.({ ...d2, subagentId }),
+          onToolCall: (d2) => cbs.onToolCall?.({ ...d2, subagentId }),
+          onToolResult: (d2) => cbs.onToolResult?.({ ...d2, subagentId }),
+          onError: (e) => cbs.onError?.(e)
+        } : undefined;
         const result = await runAuthenticationAgent3({
           target,
           session: ctx4.session,
@@ -105040,7 +105350,15 @@ When to use delegate_to_auth_subagent vs authenticate_session:
           model: ctx4.model,
           authConfig: ctx4.authConfig,
           abortSignal: ctx4.abortSignal,
-          callbacks: ctx4.callbacks
+          callbacks: {
+            ...ctx4.callbacks,
+            subagentCallbacks
+          }
+        });
+        cbs?.onSubagentComplete?.({
+          subagentId,
+          input: { target, reason },
+          status: result.success ? "completed" : "failed"
         });
         if (result.success) {
           const sessionInfoPath = join16(ctx4.session.rootPath, "session-info.json");
@@ -105088,6 +105406,11 @@ To make authenticated requests, use the returned values:
 Auth data saved to: ${result.authDataPath}` : ""}` : `Authentication subagent failed. ${result.summary}${result.authBarrier ? ` Barrier: ${result.authBarrier.type} - ${result.authBarrier.details}` : ""}`
         };
       } catch (error40) {
+        ctx4.subagentCallbacks?.onSubagentComplete?.({
+          subagentId: "auth-agent",
+          input: { target, reason },
+          status: "failed"
+        });
         const errorMessage = error40 instanceof Error ? error40.message : String(error40);
         return {
           success: false,
@@ -106170,6 +106493,11 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
         onToolResult: (d2) => cbs.onToolResult?.({ ...d2, subagentId }),
         onError: (e) => cbs.onError?.(e)
       } : undefined;
+      cbs?.onSubagentSpawn?.({
+        subagentId,
+        input: { target, cwd },
+        status: "pending"
+      });
       if (cwd) {
         try {
           const { WhiteboxAttackSurfaceAgent: WhiteboxAttackSurfaceAgent2 } = await Promise.resolve().then(() => (init_agent2(), exports_agent));
@@ -106193,6 +106521,11 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
           })));
           console.log(`
 ✓ Whitebox attack surface complete: ${targets.length} targets from ${result.apps.length} apps`);
+          cbs?.onSubagentComplete?.({
+            subagentId,
+            input: { target, cwd },
+            status: "completed"
+          });
           return {
             success: true,
             mode: "whitebox",
@@ -106204,6 +106537,11 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
         } catch (error40) {
           const errorMsg = error40 instanceof Error ? error40.message : String(error40);
           console.error(`✗ Whitebox attack surface agent failed: ${errorMsg}`);
+          cbs?.onSubagentComplete?.({
+            subagentId,
+            input: { target, cwd },
+            status: "failed"
+          });
           return {
             success: false,
             targets: [],
@@ -106230,6 +106568,11 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
         const targetCount = result.targets.length;
         console.log(`
 ✓ Blackbox attack surface complete: ${targetCount} targets identified`);
+        cbs?.onSubagentComplete?.({
+          subagentId,
+          input: { target },
+          status: "completed"
+        });
         return {
           success: true,
           mode: "blackbox",
@@ -106248,6 +106591,11 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
       } catch (error40) {
         const errorMsg = error40 instanceof Error ? error40.message : String(error40);
         console.error(`✗ Blackbox attack surface agent failed: ${errorMsg}`);
+        cbs?.onSubagentComplete?.({
+          subagentId,
+          input: { target },
+          status: "failed"
+        });
         return {
           success: false,
           targets: [],
@@ -106878,6 +107226,215 @@ var init_provideComparisonResults = __esm(() => {
   init_zod();
 });
 
+// src/core/memory/index.ts
+function storageKey(category, id) {
+  return [MEMORIES_PREFIX, category, id];
+}
+function slugify2(text2) {
+  return text2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function makeId(title) {
+  const slug = slugify2(title);
+  const ts = Date.now().toString(36);
+  return slug ? `${slug}-${ts}` : ts;
+}
+function validateId(id) {
+  if (id.includes("/") || id.includes("\\") || id.includes("..")) {
+    throw new Error("Invalid memory id: contains path traversal characters");
+  }
+}
+async function addMemory(input) {
+  const category = input.category ?? "general";
+  const id = makeId(input.title);
+  const now2 = new Date().toISOString();
+  const memory = {
+    id,
+    category,
+    title: input.title,
+    content: input.content,
+    tags: input.tags ?? [],
+    createdAt: now2,
+    updatedAt: now2
+  };
+  await write2(storageKey(category, id), memory);
+  return memory;
+}
+async function getMemory(category, id) {
+  validateId(id);
+  try {
+    return await read2(storageKey(category, id));
+  } catch (e) {
+    if (e instanceof NotFoundError)
+      return null;
+    throw e;
+  }
+}
+async function listMemories(opts) {
+  const prefix = opts?.category ? [MEMORIES_PREFIX, opts.category] : [MEMORIES_PREFIX];
+  const keys = await list(prefix);
+  const summaries = [];
+  for (const key of keys) {
+    try {
+      const memory = await read2(key);
+      if (opts?.tag && !memory.tags.includes(opts.tag))
+        continue;
+      summaries.push({
+        id: memory.id,
+        category: memory.category,
+        title: memory.title,
+        tags: memory.tags,
+        createdAt: memory.createdAt
+      });
+    } catch {}
+  }
+  summaries.sort((a, b2) => new Date(b2.createdAt).getTime() - new Date(a.createdAt).getTime());
+  return summaries;
+}
+var MEMORY_CATEGORIES, MEMORIES_PREFIX = "memories";
+var init_memory = __esm(() => {
+  init_storage();
+  MEMORY_CATEGORIES = ["app", "framework", "general"];
+});
+
+// src/core/agents/offSecAgent/tools/addMemory.ts
+function addMemory2(_ctx) {
+  return tool({
+    description: `Save a piece of knowledge to persistent memory.
+
+Memories are stored across sessions in ~/.pensar/memories/ and survive restarts.
+They are organised into categories:
+  - "app"       — application-specific notes (e.g. target quirks, endpoints)
+  - "framework" — framework-specific notes (e.g. Rails tricks, Django patterns)
+  - "general"   — catch-all (default when category is omitted)
+
+Use this to record reusable techniques, target-specific notes, credential
+patterns, useful payloads, or any information worth remembering for future
+engagements.`,
+    inputSchema: addMemoryInputSchema,
+    execute: async ({
+      title,
+      content,
+      category,
+      tags
+    }) => {
+      try {
+        const memory = await addMemory({ title, content, category, tags });
+        return {
+          success: true,
+          error: "",
+          id: memory.id,
+          category: memory.category,
+          title: memory.title
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+  });
+}
+var addMemoryInputSchema;
+var init_addMemory = __esm(() => {
+  init_dist5();
+  init_zod();
+  init_memory();
+  addMemoryInputSchema = exports_external.object({
+    title: exports_external.string().describe("Short, descriptive title for the memory (used to generate id)"),
+    content: exports_external.string().describe("Free-form text content to persist as a memory"),
+    category: exports_external.enum(MEMORY_CATEGORIES).optional().describe('Storage category: "app" for application-specific knowledge, ' + '"framework" for framework-specific knowledge, or omit for the ' + '"general" catch-all'),
+    tags: exports_external.array(exports_external.string()).optional().describe("Optional tags for categorisation and filtering"),
+    toolCallDescription: exports_external.string().describe("A concise, human-readable description of what this tool call is doing (e.g., 'Saving XSS payload pattern')")
+  });
+});
+
+// src/core/agents/offSecAgent/tools/listMemories.ts
+function listMemories2(_ctx) {
+  return tool({
+    description: `List saved memories, optionally filtered by category and/or tag.
+
+Returns lightweight summaries (id, category, title, tags, createdAt) sorted by
+most recent first. Use the returned category + id with get_memory to retrieve
+full content.`,
+    inputSchema: listMemoriesInputSchema,
+    execute: async ({ category, tag }) => {
+      try {
+        const memories = await listMemories({ category, tag });
+        return {
+          success: true,
+          error: "",
+          memories,
+          count: memories.length
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: err instanceof Error ? err.message : String(err),
+          memories: [],
+          count: 0
+        };
+      }
+    }
+  });
+}
+var listMemoriesInputSchema;
+var init_listMemories = __esm(() => {
+  init_dist5();
+  init_zod();
+  init_memory();
+  listMemoriesInputSchema = exports_external.object({
+    category: exports_external.enum(MEMORY_CATEGORIES).optional().describe('Filter by category: "app", "framework", or "general". ' + "Omit to list memories across all categories."),
+    tag: exports_external.string().optional().describe("Optional tag to filter memories by (exact match)"),
+    toolCallDescription: exports_external.string().describe("A concise, human-readable description of what this tool call is doing (e.g., 'Listing stored recon notes')")
+  });
+});
+
+// src/core/agents/offSecAgent/tools/getMemory.ts
+function getMemory2(_ctx) {
+  return tool({
+    description: `Retrieve the full content of a memory by its category and id.
+
+Use list_memories first to discover available memories, then call this tool
+with the category and id from that listing to fetch full content.`,
+    inputSchema: getMemoryInputSchema,
+    execute: async ({ category, id }) => {
+      try {
+        const memory = await getMemory(category, id);
+        if (!memory) {
+          return {
+            success: false,
+            error: `Memory not found: ${category}/${id}`,
+            memory: null
+          };
+        }
+        return {
+          success: true,
+          error: "",
+          memory
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: err instanceof Error ? err.message : String(err),
+          memory: null
+        };
+      }
+    }
+  });
+}
+var getMemoryInputSchema;
+var init_getMemory = __esm(() => {
+  init_dist5();
+  init_zod();
+  init_memory();
+  getMemoryInputSchema = exports_external.object({
+    category: exports_external.enum(MEMORY_CATEGORIES).describe('The memory category: "app", "framework", or "general" (returned by list_memories)'),
+    id: exports_external.string().describe("The unique memory id (returned by list_memories)"),
+    toolCallDescription: exports_external.string().describe("A concise, human-readable description of what this tool call is doing (e.g., 'Retrieving SQL injection cheatsheet')")
+  });
+});
+
 // src/core/agents/offSecAgent/tools/email/listInboxes.ts
 function emailListInboxes(ctx4) {
   return tool({
@@ -129707,7 +130264,7 @@ var require_libmime = __commonJS((exports, module2) => {
       return response;
     }
     buildHeaderParam(key, data, maxLength, fromCharset) {
-      let list2 = [];
+      let list3 = [];
       let encodedStr = typeof data === "string" ? data : this.decode(data, fromCharset);
       let encodedStrArr;
       let chr, ord;
@@ -129726,13 +130283,13 @@ var require_libmime = __commonJS((exports, module2) => {
           ];
         }
         encodedStr = encodedStr.replace(new RegExp(".{" + maxLength + "}", "g"), (str) => {
-          list2.push({
+          list3.push({
             line: str
           });
           return "";
         });
         if (encodedStr) {
-          list2.push({
+          list3.push({
             line: encodedStr
           });
         }
@@ -129763,7 +130320,7 @@ var require_libmime = __commonJS((exports, module2) => {
             chr = chr === " " ? chr : this.safeEncodeURIComponent(chr);
             if (chr !== encodedStr[i]) {
               if ((this.safeEncodeURIComponent(line) + chr).length >= maxLength) {
-                list2.push({
+                list3.push({
                   line,
                   encoded: isEncoded
                 });
@@ -129778,7 +130335,7 @@ var require_libmime = __commonJS((exports, module2) => {
             }
           }
           if ((line + chr).length >= maxLength) {
-            list2.push({
+            list3.push({
               line,
               encoded: isEncoded
             });
@@ -129794,13 +130351,13 @@ var require_libmime = __commonJS((exports, module2) => {
           }
         }
         if (line) {
-          list2.push({
+          list3.push({
             line,
             encoded: isEncoded
           });
         }
       }
-      return list2.map((item, i2) => ({
+      return list3.map((item, i2) => ({
         key: key + "*" + i2 + (item.encoded ? "*" : ""),
         value: item.line
       }));
@@ -131165,7 +131722,7 @@ var require_addressparser = __commonJS((exports, module2) => {
       };
     }
     tokenize() {
-      let list2 = [];
+      let list3 = [];
       for (let i = 0, len = this.str.length;i < len; i++) {
         let chr = this.str.charAt(i);
         let nextChr = i < len - 1 ? this.str.charAt(i + 1) : null;
@@ -131174,10 +131731,10 @@ var require_addressparser = __commonJS((exports, module2) => {
       this.list.forEach((node) => {
         node.value = (node.value || "").toString().trim();
         if (node.value) {
-          list2.push(node);
+          list3.push(node);
         }
       });
-      return list2;
+      return list3;
     }
     checkChar(chr, nextChr) {
       if (this.escaped) {} else if (chr === this.operatorExpecting) {
@@ -131258,8 +131815,8 @@ var require_addressparser = __commonJS((exports, module2) => {
     });
     if (options.flatten) {
       let addresses2 = [];
-      let walkAddressList = (list2) => {
-        list2.forEach((address2) => {
+      let walkAddressList = (list3) => {
+        list3.forEach((address2) => {
           if (address2.group) {
             return walkAddressList(address2.group);
           } else {
@@ -140602,30 +141159,30 @@ var require_html_to_text = __commonJS((exports) => {
       if (!(this._stackItem instanceof ListStackItem)) {
         throw new Error("Can't add a list item to something that is not a list! Check the formatter.");
       }
-      const list2 = this._stackItem;
-      const prefixLength = Math.max(prefix.length, list2.maxPrefixLength);
-      const maxLineLength = Math.max(20, list2.inlineTextBuilder.maxLineLength - prefixLength);
-      this._stackItem = new ListItemStackItem(this.options, list2, {
+      const list3 = this._stackItem;
+      const prefixLength = Math.max(prefix.length, list3.maxPrefixLength);
+      const maxLineLength = Math.max(20, list3.inlineTextBuilder.maxLineLength - prefixLength);
+      this._stackItem = new ListItemStackItem(this.options, list3, {
         prefix,
         maxLineLength,
-        leadingLineBreaks: list2.interRowLineBreaks
+        leadingLineBreaks: list3.interRowLineBreaks
       });
     }
     closeListItem() {
       const listItem = this._popStackItem();
-      const list2 = listItem.next;
-      const prefixLength = Math.max(listItem.prefix.length, list2.maxPrefixLength);
+      const list3 = listItem.next;
+      const prefixLength = Math.max(listItem.prefix.length, list3.maxPrefixLength);
       const spacing = `
 ` + " ".repeat(prefixLength);
-      const prefix = list2.prefixAlign === "right" ? listItem.prefix.padStart(prefixLength) : listItem.prefix.padEnd(prefixLength);
+      const prefix = list3.prefixAlign === "right" ? listItem.prefix.padStart(prefixLength) : listItem.prefix.padEnd(prefixLength);
       const text2 = prefix + getText(listItem).replace(/\n/g, spacing);
-      addText(list2, text2, listItem.leadingLineBreaks, Math.max(listItem.stashedLineBreaks, list2.interRowLineBreaks));
+      addText(list3, text2, listItem.leadingLineBreaks, Math.max(listItem.stashedLineBreaks, list3.interRowLineBreaks));
     }
     closeList({ trailingLineBreaks = 2 } = {}) {
-      const list2 = this._popStackItem();
-      const text2 = getText(list2);
+      const list3 = this._popStackItem();
+      const text2 = getText(list3);
       if (text2) {
-        addText(this._stackItem, text2, list2.leadingLineBreaks, trailingLineBreaks);
+        addText(this._stackItem, text2, list3.leadingLineBreaks, trailingLineBreaks);
       }
     }
     openTable() {
@@ -140780,9 +141337,9 @@ var require_html_to_text = __commonJS((exports) => {
     if (!dict || Object.keys(dict).length === 0) {
       return;
     }
-    const entries = Object.entries(dict).filter(([, v2]) => v2 !== false);
-    const regex = new RegExp(entries.map(([c]) => `(${unicodeEscape([...c][0])})`).join("|"), "g");
-    const values = entries.map(([, v2]) => v2);
+    const entries2 = Object.entries(dict).filter(([, v2]) => v2 !== false);
+    const regex = new RegExp(entries2.map(([c]) => `(${unicodeEscape([...c][0])})`).join("|"), "g");
+    const values = entries2.map(([, v2]) => v2);
     const replacer = (m2, ...cgs) => values[cgs.findIndex((cg) => cg)];
     return (str) => str.replace(regex, replacer);
   }
@@ -141967,15 +142524,15 @@ var require_index_cjs2 = __commonJS((exports, module2) => {
     this.__last_index__ = m2.index + m2[0].length + len;
     return createMatch(this, 0);
   };
-  LinkifyIt.prototype.tlds = function tlds(list2, keepOld) {
-    list2 = Array.isArray(list2) ? list2 : [list2];
+  LinkifyIt.prototype.tlds = function tlds(list3, keepOld) {
+    list3 = Array.isArray(list3) ? list3 : [list3];
     if (!keepOld) {
-      this.__tlds__ = list2.slice();
+      this.__tlds__ = list3.slice();
       this.__tlds_replaced__ = true;
       compile(this);
       return this;
     }
-    this.__tlds__ = this.__tlds__.concat(list2).sort().filter(function(el, idx, arr) {
+    this.__tlds__ = this.__tlds__.concat(list3).sort().filter(function(el, idx, arr) {
       return el !== arr[idx - 1];
     }).reverse();
     compile(this);
@@ -145295,7 +145852,7 @@ var require_common2 = __commonJS((exports, module2) => {
 var require_browser = __commonJS((exports, module2) => {
   exports.formatArgs = formatArgs;
   exports.save = save;
-  exports.load = load;
+  exports.load = load2;
   exports.useColors = useColors;
   exports.storage = localstorage();
   exports.destroy = (() => {
@@ -145425,7 +145982,7 @@ var require_browser = __commonJS((exports, module2) => {
       }
     } catch (error40) {}
   }
-  function load() {
+  function load2() {
     let r;
     try {
       r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
@@ -145459,7 +146016,7 @@ var require_node3 = __commonJS((exports, module2) => {
   exports.log = log2;
   exports.formatArgs = formatArgs;
   exports.save = save;
-  exports.load = load;
+  exports.load = load2;
   exports.useColors = useColors;
   exports.destroy = util4.deprecate(() => {}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
   exports.colors = [6, 2, 3, 4, 5, 1];
@@ -145599,7 +146156,7 @@ var require_node3 = __commonJS((exports, module2) => {
       delete process.env.DEBUG;
     }
   }
-  function load() {
+  function load2() {
     return process.env.DEBUG;
   }
   function init2(debug) {
@@ -161065,8 +161622,8 @@ var require_object_inspect = __commonJS((exports, module2) => {
   function weakCollectionOf(type) {
     return type + " { ? }";
   }
-  function collectionOf(type, size, entries, indent) {
-    var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
+  function collectionOf(type, size, entries2, indent) {
+    var joinedEntries = indent ? indentedJoin(entries2, indent) : $join.call(entries2, ", ");
     return type + " (" + size + ") {" + joinedEntries + "}";
   }
   function singleLineValues(xs) {
@@ -161148,15 +161705,15 @@ var require_object_inspect = __commonJS((exports, module2) => {
 var require_side_channel_list = __commonJS((exports, module2) => {
   var inspect = require_object_inspect();
   var $TypeError = require_type();
-  var listGetNode = function(list2, key, isDelete) {
-    var prev = list2;
+  var listGetNode = function(list3, key, isDelete) {
+    var prev = list3;
     var curr;
     for (;(curr = prev.next) != null; prev = curr) {
       if (curr.key === key) {
         prev.next = curr.next;
         if (!isDelete) {
-          curr.next = list2.next;
-          list2.next = curr;
+          curr.next = list3.next;
+          list3.next = curr;
         }
         return curr;
       }
@@ -162375,9 +162932,9 @@ var require_stringify3 = __commonJS((exports, module2) => {
     }
   };
   var isArray = Array.isArray;
-  var push = Array.prototype.push;
+  var push2 = Array.prototype.push;
   var pushToArray = function(arr, valueOrArray) {
-    push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
+    push2.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
   };
   var toISO = Date.prototype.toISOString;
   var defaultFormat = formats["default"];
@@ -170227,9 +170784,9 @@ var require_caller = __commonJS((exports, module2) => {
     if (!Array.isArray(stack)) {
       return;
     }
-    const entries = stack.slice(2);
+    const entries2 = stack.slice(2);
     const fileNames = [];
-    for (const entry of entries) {
+    for (const entry of entries2) {
       if (!entry) {
         continue;
       }
@@ -182143,10 +182700,10 @@ var require_tools2 = __commonJS((exports, module2) => {
       }
       return tools.normalizePath(connection, a) === tools.normalizePath(connection, b2);
     },
-    updateCapabilities(list2) {
+    updateCapabilities(list3) {
       let map3 = new Map;
-      if (list2 && Array.isArray(list2)) {
-        list2.forEach((val) => {
+      if (list3 && Array.isArray(list3)) {
+        list3.forEach((val) => {
           if (typeof val.value !== "string") {
             return false;
           }
@@ -182435,8 +182992,8 @@ var require_tools2 = __commonJS((exports, module2) => {
         }
         return obj.value;
       };
-      let processAddresses = function(list2) {
-        return [].concat(list2 || []).map((addr) => {
+      let processAddresses = function(list3) {
+        return [].concat(list3 || []).map((addr) => {
           let address = (getStrValue(addr[2]) || "") + "@" + (getStrValue(addr[3]) || "");
           if (address === "@") {
             address = "";
@@ -182705,17 +183262,17 @@ var require_tools2 = __commonJS((exports, module2) => {
         if (first === second) {
           return first;
         }
-        let list2 = [];
+        let list3 = [];
         if (first < second) {
           for (let i2 = first;i2 <= second; i2++) {
-            list2.push(i2);
+            list3.push(i2);
           }
         } else {
           for (let i2 = first;i2 >= second; i2--) {
-            list2.push(i2);
+            list3.push(i2);
           }
         }
-        return list2;
+        return list3;
       });
     },
     getDecoder(charset) {
@@ -182725,22 +183282,22 @@ var require_tools2 = __commonJS((exports, module2) => {
       }
       return iconv.decodeStream(charset);
     },
-    packMessageRange(list2) {
-      if (!Array.isArray(list2)) {
-        list2 = [].concat(list2 || []);
+    packMessageRange(list3) {
+      if (!Array.isArray(list3)) {
+        list3 = [].concat(list3 || []);
       }
-      if (!list2.length) {
+      if (!list3.length) {
         return "";
       }
-      list2.sort((a, b2) => a - b2);
-      let last = list2[list2.length - 1];
+      list3.sort((a, b2) => a - b2);
+      let last = list3[list3.length - 1];
       let result = [[last]];
-      for (let i2 = list2.length - 2;i2 >= 0; i2--) {
-        if (list2[i2] === list2[i2 + 1] - 1) {
-          result[0].unshift(list2[i2]);
+      for (let i2 = list3.length - 2;i2 >= 0; i2--) {
+        if (list3[i2] === list3[i2 + 1] - 1) {
+          result[0].unshift(list3[i2]);
           continue;
         }
-        result.unshift([list2[i2]]);
+        result.unshift([list3[i2]]);
       }
       result = result.map((item) => {
         if (item.length === 1) {
@@ -183296,7 +183853,7 @@ var require_list = __commonJS((exports, module2) => {
     let listCommand = connection.capabilities.has("XLIST") && !connection.capabilities.has("SPECIAL-USE") ? "XLIST" : "LIST";
     let response;
     try {
-      let entries = [];
+      let entries2 = [];
       let statusMap = new Map;
       let returnArgs = [];
       let statusQueryAttributes = [];
@@ -183382,7 +183939,7 @@ var require_list = __commonJS((exports, module2) => {
               if (specialUseFlag) {
                 addSpecialUseMatch(entry, specialUseFlag, flagSource);
               }
-              entries.push(entry);
+              entries2.push(entry);
             },
             STATUS: async (untagged) => {
               let statusPath = normalizePath(connection, decodePath(connection, untagged.attributes[0] && untagged.attributes[0].value || ""));
@@ -183427,13 +183984,13 @@ var require_list = __commonJS((exports, module2) => {
       let normalizedReference = normalizePath(connection, reference || "");
       await runList(normalizedReference, normalizePath(connection, mailbox || "", true));
       if (options.listOnly) {
-        return entries;
+        return entries2;
       }
       if (normalizedReference && !specialUseMatches["\\Inbox"]) {
         await runList("", "INBOX");
       }
       if (options.statusQuery) {
-        for (let entry of entries) {
+        for (let entry of entries2) {
           if (!entry.flags.has("\\Noselect") && !entry.flags.has("\\NonExistent")) {
             if (statusMap.has(entry.path)) {
               entry.status = statusMap.get(entry.path);
@@ -183469,7 +184026,7 @@ var require_list = __commonJS((exports, module2) => {
             entry.parentPath = entry.delimiter && entry.path ? entry.path.substr(0, entry.path.lastIndexOf(entry.delimiter)) : "";
             entry.parent = entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path];
             entry.name = entry.parent.pop();
-            let existing = entries.find((existing2) => existing2.path === entry.path);
+            let existing = entries2.find((existing2) => existing2.path === entry.path);
             if (existing) {
               existing.subscribed = true;
               entry.flags.forEach((flag) => existing.flags.add(flag));
@@ -183492,11 +184049,11 @@ var require_list = __commonJS((exports, module2) => {
           sortedEntries[0].entry.specialUseSource = sortedEntries[0].source;
         }
       }
-      let inboxEntry = entries.find((entry) => entry.specialUse === "\\Inbox");
+      let inboxEntry = entries2.find((entry) => entry.specialUse === "\\Inbox");
       if (inboxEntry && !inboxEntry.subscribed) {
         inboxEntry.subscribed = true;
       }
-      return entries.sort((a, b2) => {
+      return entries2.sort((a, b2) => {
         if (a.specialUse && !b2.specialUse) {
           return -1;
         }
@@ -184346,10 +184903,10 @@ var require_search_compiler = __commonJS((exports, module2) => {
                 }
                 break;
               }
-              let genOrTree = (list2) => {
+              let genOrTree = (list3) => {
                 let group = false;
                 let groups = [];
-                list2.forEach((entry, i2) => {
+                list3.forEach((entry, i2) => {
                   if (i2 % 2 === 0) {
                     group = [entry];
                   } else {
@@ -184573,9 +185130,9 @@ var require_append = __commonJS((exports, module2) => {
         }
       }
       if (map3.seq && !map3.uid) {
-        let list2 = await connection.search({ seq: map3.seq }, { uid: true });
-        if (list2 && list2.length) {
-          map3.uid = list2[0];
+        let list3 = await connection.search({ seq: map3.seq }, { uid: true });
+        if (list3 && list3.length) {
+          map3.uid = list3[0];
         }
       }
       return map3;
@@ -184628,8 +185185,8 @@ var require_status2 = __commonJS((exports, module2) => {
         untagged: {
           STATUS: async (untagged) => {
             let updateCurrent = connection.state === connection.states.SELECTED && path6 === connection.mailbox.path;
-            let list2 = untagged.attributes && Array.isArray(untagged.attributes[1]) ? untagged.attributes[1] : false;
-            if (!list2) {
+            let list3 = untagged.attributes && Array.isArray(untagged.attributes[1]) ? untagged.attributes[1] : false;
+            if (!list3) {
               return;
             }
             const STATUS_FIELD_MAP = {
@@ -184663,7 +185220,7 @@ var require_status2 = __commonJS((exports, module2) => {
               }
             };
             let key;
-            list2.forEach((entry, i2) => {
+            list3.forEach((entry, i2) => {
               if (i2 % 2 === 0) {
                 key = entry && typeof entry.value === "string" ? entry.value : false;
                 return;
@@ -186612,7 +187169,7 @@ var init_imap_flow = __esm(() => {
         return false;
       }
       let finished = false;
-      let push = false;
+      let push2 = false;
       let rowQueue = [];
       let getNext = () => new Promise((resolve4, reject) => {
         let check2 = () => {
@@ -186627,8 +187184,8 @@ var init_imap_flow = __esm(() => {
           if (finished) {
             return resolve4(null);
           }
-          push = () => {
-            push = false;
+          push2 = () => {
+            push2 = false;
             check2();
           };
         };
@@ -186645,19 +187202,19 @@ var init_imap_flow = __esm(() => {
               next
             }
           });
-          if (typeof push === "function") {
-            push();
+          if (typeof push2 === "function") {
+            push2();
           }
         }
       }).then(() => {
         finished = true;
-        if (typeof push === "function") {
-          push();
+        if (typeof push2 === "function") {
+          push2();
         }
       }).catch((err) => {
         rowQueue.push({ err });
-        if (typeof push === "function") {
-          push();
+        if (typeof push2 === "function") {
+          push2();
         }
       });
       let res;
@@ -188182,6 +188739,9 @@ function createAllTools(ctx4) {
     spawn_pentest_swarm: spawnPentestSwarm(ctx4),
     spawn_coding_agent: spawnCodingAgent(ctx4),
     provide_comparison_results: provideComparisonResults(ctx4),
+    add_memory: addMemory2(ctx4),
+    list_memories: listMemories2(ctx4),
+    get_memory: getMemory2(ctx4),
     ...createEmailToolset(ctx4),
     email_list_inboxes: emailListInboxes(ctx4),
     email_list_messages: emailListMessages(ctx4),
@@ -188217,6 +188777,9 @@ var init_tools = __esm(() => {
   init_spawnPentestSwarm();
   init_spawnCodingAgent();
   init_provideComparisonResults();
+  init_addMemory();
+  init_listMemories();
+  init_getMemory();
   init_email();
   init_browserTools();
   init_executeCommand();
@@ -188243,6 +188806,9 @@ var init_tools = __esm(() => {
   init_spawnPentestSwarm();
   init_spawnCodingAgent();
   init_provideComparisonResults();
+  init_addMemory();
+  init_listMemories();
+  init_getMemory();
   init_email();
   init_listInboxes();
   init_listMessages();
@@ -188276,6 +188842,9 @@ var init_tools = __esm(() => {
     "spawn_pentest_swarm",
     "spawn_coding_agent",
     "provide_comparison_results",
+    "add_memory",
+    "list_memories",
+    "get_memory",
     "email_list_inboxes",
     "email_list_messages",
     "email_get_message",
@@ -189402,6 +189971,82 @@ var init_agent4 = __esm(() => {
   };
 });
 
+// src/core/session/execution-metrics.ts
+import { existsSync as existsSync23, readFileSync as readFileSync10, writeFileSync as writeFileSync15 } from "fs";
+import { join as join24 } from "path";
+function toNonNegativeInteger(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+function normalizeTokenUsage(value) {
+  const inputTokens = toNonNegativeInteger(value?.inputTokens);
+  const outputTokens = toNonNegativeInteger(value?.outputTokens);
+  const derivedTotal = inputTokens + outputTokens;
+  const explicitTotal = toNonNegativeInteger(value?.totalTokens);
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: explicitTotal > 0 ? explicitTotal : derivedTotal
+  };
+}
+function metricsPath(sessionRootPath) {
+  return join24(sessionRootPath, EXECUTION_METRICS_FILENAME);
+}
+function sessionJsonPath(sessionRootPath) {
+  return join24(sessionRootPath, "session.json");
+}
+function readExecutionMetrics(sessionRootPath) {
+  const path6 = metricsPath(sessionRootPath);
+  if (!existsSync23(path6))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync10(path6, "utf-8"));
+    return {
+      tokenUsage: normalizeTokenUsage(parsed.tokenUsage),
+      runtime: typeof parsed.runtime === "string" ? parsed.runtime : undefined,
+      updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date().toISOString()
+    };
+  } catch {
+    return null;
+  }
+}
+function writeSessionJsonTokenTotals(sessionRootPath, tokenUsage) {
+  const path6 = sessionJsonPath(sessionRootPath);
+  if (!existsSync23(path6))
+    return;
+  try {
+    const parsed = JSON.parse(readFileSync10(path6, "utf-8"));
+    parsed.tokensIn = tokenUsage.inputTokens;
+    parsed.tokensOut = tokenUsage.outputTokens;
+    writeFileSync15(path6, JSON.stringify(parsed, null, 2));
+  } catch {}
+}
+function writeExecutionMetrics(input) {
+  const existing = readExecutionMetrics(input.sessionRootPath);
+  const nextTokenUsage = input.tokenUsage ? normalizeTokenUsage(input.tokenUsage) : existing?.tokenUsage ?? {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0
+  };
+  const next = {
+    tokenUsage: nextTokenUsage,
+    runtime: input.runtime ?? existing?.runtime,
+    updatedAt: new Date().toISOString()
+  };
+  writeFileSync15(metricsPath(input.sessionRootPath), JSON.stringify(next, null, 2), "utf-8");
+  writeSessionJsonTokenTotals(input.sessionRootPath, next.tokenUsage);
+  return next;
+}
+function formatDurationHmsFromMs(durationMs) {
+  const totalSeconds = Math.max(0, Math.floor(durationMs / 1000));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  return `${hours}h${minutes}m${seconds}s`;
+}
+var EXECUTION_METRICS_FILENAME = "execution-metrics.json";
+var init_execution_metrics = () => {};
+
 // src/core/utils/concurrency.ts
 async function runWithBoundedConcurrency(items, concurrency, fn) {
   const results = new Array(items.length).fill(null);
@@ -189439,7 +190084,15 @@ async function runWithBoundedConcurrency(items, concurrency, fn) {
 
 // src/core/workflows/whiteboxAttackSurface.ts
 async function runWhiteboxAttackSurfaceWorkflow(input) {
-  const { codebasePath, model, session, authConfig, abortSignal, callbacks } = input;
+  const {
+    codebasePath,
+    model,
+    session,
+    authConfig,
+    abortSignal,
+    callbacks,
+    onStepFinish
+  } = input;
   const appsAgent = new CodeAgent({
     codebasePath,
     objective: buildAppsDiscoveryObjective(codebasePath),
@@ -189449,6 +190102,7 @@ async function runWhiteboxAttackSurfaceWorkflow(input) {
     authConfig,
     abortSignal,
     callbacks,
+    onStepFinish: (event) => onStepFinish?.(event),
     responseSchema: AppsDiscoveryResultSchema
   });
   const appsResult = await appsAgent.consume({
@@ -189492,6 +190146,7 @@ async function runWhiteboxAttackSurfaceWorkflow(input) {
       authConfig,
       abortSignal,
       callbacks,
+      onStepFinish: (event) => onStepFinish?.(event),
       responseSchema: EndpointsDiscoveryResultSchema
     });
     try {
@@ -189756,8 +190411,18 @@ __export(exports_pentest, {
   runPentestSwarm: () => runPentestSwarm,
   DEFAULT_CONCURRENCY: () => DEFAULT_CONCURRENCY3
 });
-import { existsSync as existsSync23, readdirSync as readdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync15 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync24, readdirSync as readdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync16 } from "fs";
+import { join as join25 } from "path";
+function addUsageTotals(totals, usage) {
+  if (!usage)
+    return;
+  const inputTokens = usage.inputTokens ?? 0;
+  const outputTokens = usage.outputTokens ?? 0;
+  const totalTokens = usage.totalTokens ?? inputTokens + outputTokens;
+  totals.inputTokens += inputTokens;
+  totals.outputTokens += outputTokens;
+  totals.totalTokens += totalTokens;
+}
 async function runPentestSwarm(input) {
   const {
     targets,
@@ -189768,17 +190433,19 @@ async function runPentestSwarm(input) {
     findingsRegistry,
     subagentCallbacks,
     onError,
-    concurrency = DEFAULT_CONCURRENCY3
+    concurrency = DEFAULT_CONCURRENCY3,
+    onStepFinish
   } = input;
   const manifestEntries = buildManifestEntries(targets);
   writeAgentManifest(session, manifestEntries);
   const results = await runWithBoundedConcurrency(targets, concurrency, async (target, index) => {
     const subagentId = `pentest-agent-${index + 1}`;
     let lastMessages = [];
-    const onStepFinish = (e2) => {
+    const handleStepFinish = (e2) => {
       if (e2.response.messages) {
         lastMessages = e2.response.messages;
       }
+      onStepFinish?.(e2);
     };
     const wrappedCallbacks = subagentCallbacks ? {
       onTextDelta: (d2) => subagentCallbacks.onTextDelta?.({ ...d2, subagentId }),
@@ -189800,7 +190467,7 @@ async function runPentestSwarm(input) {
         authConfig,
         abortSignal,
         findingsRegistry,
-        onStepFinish
+        onStepFinish: handleStepFinish
       });
       const result = await agent.consume({
         onError: (e2) => onError?.(e2),
@@ -189842,74 +190509,98 @@ async function runPentestSwarm(input) {
 }
 async function runPentestWorkflow(input) {
   const { target, cwd, model, session, authConfig, abortSignal, callbacks } = input;
-  const mode = cwd ? "whitebox" : "blackbox";
-  let swarmTargets;
-  if (mode === "whitebox") {
-    swarmTargets = await runWhiteboxPhase({
-      codebasePath: cwd,
-      baseTarget: target,
+  const startedAt = Date.now();
+  const tokenUsageTotals = {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0
+  };
+  const onStepFinish = (event) => {
+    addUsageTotals(tokenUsageTotals, event.usage);
+  };
+  try {
+    const mode = cwd ? "whitebox" : "blackbox";
+    let swarmTargets;
+    if (mode === "whitebox") {
+      swarmTargets = await runWhiteboxPhase({
+        codebasePath: cwd,
+        baseTarget: target,
+        model,
+        session,
+        authConfig,
+        abortSignal,
+        callbacks,
+        onStepFinish
+      });
+    } else {
+      swarmTargets = await runBlackboxPhase({
+        target,
+        model,
+        session,
+        authConfig,
+        abortSignal,
+        callbacks,
+        onStepFinish
+      });
+    }
+    if (swarmTargets.length === 0) {
+      const report2 = buildPentestReport([], {
+        target,
+        model,
+        sessionId: session.id,
+        mode
+      });
+      const mdPath2 = join25(session.rootPath, REPORT_FILENAME_MD);
+      const jsonPath2 = join25(session.rootPath, REPORT_FILENAME_JSON);
+      writeFileSync16(mdPath2, renderMarkdown(report2));
+      writeFileSync16(jsonPath2, renderJson(report2));
+      return {
+        findings: [],
+        findingsPath: session.findingsPath,
+        pocsPath: session.pocsPath,
+        reportPath: mdPath2
+      };
+    }
+    const findingsRegistry = FindingsRegistry.fromDirectory(session.findingsPath, {
       model,
-      session,
-      authConfig,
-      abortSignal,
-      callbacks
+      authConfig
     });
-  } else {
-    swarmTargets = await runBlackboxPhase({
-      target,
+    await runPentestSwarm({
+      targets: swarmTargets,
       model,
       session,
       authConfig,
       abortSignal,
-      callbacks
+      findingsRegistry,
+      subagentCallbacks: callbacks?.subagentCallbacks,
+      onError: (e2) => callbacks?.onError?.(e2),
+      onStepFinish
     });
-  }
-  if (swarmTargets.length === 0) {
-    const report2 = buildPentestReport([], {
+    const findings = loadFindings2(session.findingsPath);
+    const report = buildPentestReport(findings, {
       target,
       model,
       sessionId: session.id,
       mode
     });
-    const mdPath2 = join24(session.rootPath, REPORT_FILENAME_MD);
-    const jsonPath2 = join24(session.rootPath, REPORT_FILENAME_JSON);
-    writeFileSync15(mdPath2, renderMarkdown(report2));
-    writeFileSync15(jsonPath2, renderJson(report2));
+    const mdPath = join25(session.rootPath, REPORT_FILENAME_MD);
+    const jsonPath = join25(session.rootPath, REPORT_FILENAME_JSON);
+    writeFileSync16(mdPath, renderMarkdown(report));
+    writeFileSync16(jsonPath, renderJson(report));
     return {
-      findings: [],
+      findings,
       findingsPath: session.findingsPath,
       pocsPath: session.pocsPath,
-      reportPath: mdPath2
+      reportPath: mdPath
     };
+  } finally {
+    const runtime = formatDurationHmsFromMs(Date.now() - startedAt);
+    writeExecutionMetrics({
+      sessionRootPath: session.rootPath,
+      tokenUsage: tokenUsageTotals,
+      runtime
+    });
   }
-  const findingsRegistry = FindingsRegistry.fromDirectory(session.findingsPath, { model, authConfig });
-  await runPentestSwarm({
-    targets: swarmTargets,
-    model,
-    session,
-    authConfig,
-    abortSignal,
-    findingsRegistry,
-    subagentCallbacks: callbacks?.subagentCallbacks,
-    onError: (e2) => callbacks?.onError?.(e2)
-  });
-  const findings = loadFindings2(session.findingsPath);
-  const report = buildPentestReport(findings, {
-    target,
-    model,
-    sessionId: session.id,
-    mode
-  });
-  const mdPath = join24(session.rootPath, REPORT_FILENAME_MD);
-  const jsonPath = join24(session.rootPath, REPORT_FILENAME_JSON);
-  writeFileSync15(mdPath, renderMarkdown(report));
-  writeFileSync15(jsonPath, renderJson(report));
-  return {
-    findings,
-    findingsPath: session.findingsPath,
-    pocsPath: session.pocsPath,
-    reportPath: mdPath
-  };
 }
 async function runWhiteboxPhase(opts) {
   const workflowInput = {
@@ -189918,7 +190609,8 @@ async function runWhiteboxPhase(opts) {
     session: opts.session,
     authConfig: opts.authConfig,
     abortSignal: opts.abortSignal,
-    callbacks: opts.callbacks
+    callbacks: opts.callbacks,
+    onStepFinish: opts.onStepFinish
   };
   const result = await runWhiteboxAttackSurfaceWorkflow(workflowInput);
   return result.apps.flatMap((app) => [...app.pages, ...app.apiEndpoints].map((ep) => ({
@@ -189939,6 +190631,7 @@ async function runBlackboxPhase(opts) {
       if (e2.response.messages) {
         lastMessages = e2.response.messages;
       }
+      opts.onStepFinish?.(e2);
     }
   };
   const agent = new BlackboxAttackSurfaceAgent(agentInput);
@@ -189972,12 +190665,12 @@ async function runBlackboxPhase(opts) {
   }
 }
 function loadFindings2(findingsPath) {
-  if (!existsSync23(findingsPath)) {
+  if (!existsSync24(findingsPath)) {
     return [];
   }
   return readdirSync5(findingsPath).filter((f3) => f3.endsWith(".json")).map((f3) => {
     try {
-      const content = readFileSync10(join24(findingsPath, f3), "utf-8");
+      const content = readFileSync11(join25(findingsPath, f3), "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -189991,6 +190684,7 @@ var init_pentest = __esm(() => {
   init_registry();
   init_report();
   init_persistence();
+  init_execution_metrics();
   init_whiteboxAttackSurface();
 });
 
@@ -191049,13 +191743,13 @@ https://github.com/highlightjs/highlight.js/issues/2277`);
         return origin.returnEnd ? 0 : lexeme.length;
       }
       function processContinuations() {
-        const list2 = [];
+        const list3 = [];
         for (let current = top;current !== language; current = current.parent) {
           if (current.scope) {
-            list2.unshift(current.scope);
+            list3.unshift(current.scope);
           }
         }
-        list2.forEach((item) => emitter.openNode(item));
+        list3.forEach((item) => emitter.openNode(item));
       }
       let lastMatch = {};
       function processLexeme(textBeforeMatch, match) {
@@ -196627,7 +197321,7 @@ var require_coffeescript = __commonJS((exports, module2) => {
       "function",
       "static"
     ];
-    const excluding = (list2) => (kw) => !list2.includes(kw);
+    const excluding = (list3) => (kw) => !list3.includes(kw);
     const KEYWORDS$1 = {
       keyword: KEYWORDS.concat(COFFEE_KEYWORDS).filter(excluding(NOT_VALID_KEYWORDS)),
       literal: LITERALS.concat(COFFEE_LITERALS),
@@ -210081,8 +210775,8 @@ var require_javascript = __commonJS((exports, module2) => {
       match: /\b[A-Z][A-Z_0-9]+\b/,
       className: "variable.constant"
     };
-    function noneOf(list2) {
-      return regex.concat("(?!", list2.join("|"), ")");
+    function noneOf(list3) {
+      return regex.concat("(?!", list3.join("|"), ")");
     }
     const FUNCTION_CALL = {
       match: regex.concat(/\b/, noneOf([
@@ -232685,8 +233379,8 @@ var require_sql = __commonJS((exports, module2) => {
       relevance: 0,
       keywords: { built_in: FUNCTIONS }
     };
-    function kws_to_regex(list2) {
-      return regex.concat(/\b/, regex.either(...list2.map((kw) => {
+    function kws_to_regex(list3) {
+      return regex.concat(/\b/, regex.either(...list3.map((kw) => {
         return kw.replace(/\s+/, "\\s+");
       })), /\b/);
     }
@@ -232695,13 +233389,13 @@ var require_sql = __commonJS((exports, module2) => {
       match: kws_to_regex(COMBOS),
       relevance: 0
     };
-    function reduceRelevancy(list2, {
+    function reduceRelevancy(list3, {
       exceptions,
       when
     } = {}) {
       const qualifyFn = when;
       exceptions = exceptions || [];
-      return list2.map((item) => {
+      return list3.map((item) => {
         if (item.match(/\|\d+$/) || exceptions.includes(item)) {
           return item;
         } else if (qualifyFn(item)) {
@@ -236386,8 +237080,8 @@ var require_typescript = __commonJS((exports, module2) => {
       match: /\b[A-Z][A-Z_0-9]+\b/,
       className: "variable.constant"
     };
-    function noneOf(list2) {
-      return regex.concat("(?!", list2.join("|"), ")");
+    function noneOf(list3) {
+      return regex.concat("(?!", list3.join("|"), ")");
     }
     const FUNCTION_CALL = {
       match: regex.concat(/\b/, noneOf([
@@ -266598,7 +267292,7 @@ var useTerminalDimensions = () => {
 };
 
 // src/tui/index.tsx
-var import_react87 = __toESM(require_react(), 1);
+var import_react86 = __toESM(require_react(), 1);
 
 // src/tui/components/footer.tsx
 import os6 from "os";
@@ -266766,239 +267460,7 @@ function create(prefix, descending2, timestamp) {
 
 // src/core/session/index.ts
 init_installation();
-
-// src/core/storage/index.ts
-import os3 from "os";
-import path3 from "path";
-import fs3 from "fs/promises";
-init_zod();
-
-// src/util/errors.ts
-init_zod();
-
-class NamedError extends Error {
-  static create(name, data) {
-    const schema2 = zod_default.object({
-      name: zod_default.literal(name),
-      data
-    });
-    const result = class extends NamedError {
-      data;
-      static Schema = schema2;
-      name = name;
-      constructor(data2, options) {
-        super(name, options);
-        this.data = data2;
-        this.name = name;
-      }
-      static isInstance(input) {
-        return typeof input === "object" && input !== null && "name" in input && input.name === name;
-      }
-      schema() {
-        return schema2;
-      }
-      toObject() {
-        return {
-          name,
-          data: this.data
-        };
-      }
-    };
-    Object.defineProperty(result, "name", { value: name });
-    return result;
-  }
-  static Unknown = NamedError.create("UnknownError", zod_default.object({
-    message: zod_default.string()
-  }));
-}
-
-// src/util/lock.ts
-var locks = new Map;
-function getLock(key) {
-  if (!locks.has(key)) {
-    locks.set(key, {
-      readers: 0,
-      writer: false,
-      waitingReaders: [],
-      waitingWriters: []
-    });
-  }
-  return locks.get(key);
-}
-function processQueue(key) {
-  const lock = locks.get(key);
-  if (!lock || lock.writer || lock.readers > 0)
-    return;
-  if (lock.waitingWriters.length > 0) {
-    const nextWriter = lock.waitingWriters.shift();
-    nextWriter();
-    return;
-  }
-  while (lock.waitingReaders.length > 0) {
-    const nextReader = lock.waitingReaders.shift();
-    nextReader();
-  }
-  if (lock.readers === 0 && !lock.writer && lock.waitingReaders.length === 0 && lock.waitingWriters.length === 0) {
-    locks.delete(key);
-  }
-}
-async function read(key) {
-  const lock = getLock(key);
-  return new Promise((resolve3) => {
-    if (!lock.writer && lock.waitingWriters.length === 0) {
-      lock.readers++;
-      resolve3({
-        [Symbol.dispose]: () => {
-          lock.readers--;
-          processQueue(key);
-        }
-      });
-    } else {
-      lock.waitingReaders.push(() => {
-        lock.readers++;
-        resolve3({
-          [Symbol.dispose]: () => {
-            lock.readers--;
-            processQueue(key);
-          }
-        });
-      });
-    }
-  });
-}
-async function write(key) {
-  const lock = getLock(key);
-  return new Promise((resolve3) => {
-    if (!lock.writer && lock.readers === 0) {
-      lock.writer = true;
-      resolve3({
-        [Symbol.dispose]: () => {
-          lock.writer = false;
-          processQueue(key);
-        }
-      });
-    } else {
-      lock.waitingWriters.push(() => {
-        lock.writer = true;
-        resolve3({
-          [Symbol.dispose]: () => {
-            lock.writer = false;
-            processQueue(key);
-          }
-        });
-      });
-    }
-  });
-}
-
-// src/core/storage/index.ts
-var NotFoundError = NamedError.create("NotFoundError", zod_default.object({
-  message: zod_default.string()
-}));
-async function remove(key) {
-  const dir = path3.join(os3.homedir(), ".pensar");
-  const target = path3.join(dir, ...key) + ".json";
-  return withErrorHandling(async () => {
-    await fs3.unlink(target).catch(() => {});
-  });
-}
-async function write2(key, content, ext) {
-  const dir = path3.join(os3.homedir(), ".pensar");
-  const target = path3.join(dir, ...key) + (ext ? ext : ".json");
-  return withErrorHandling(async () => {
-    let __stack = [];
-    try {
-      const _2 = __using(__stack, await write(target), 0);
-      await fs3.mkdir(path3.dirname(target), { recursive: true });
-      await fs3.writeFile(target, JSON.stringify(content, null, 2), "utf-8");
-    } catch (_catch) {
-      var _err = _catch, _hasErr = 1;
-    } finally {
-      __callDispose(__stack, _err, _hasErr);
-    }
-  });
-}
-async function createDir(key) {
-  const dir = path3.join(os3.homedir(), ".pensar");
-  const target = path3.join(dir, ...key);
-  return withErrorHandling(async () => {
-    let __stack = [];
-    try {
-      const _2 = __using(__stack, await write(target), 0);
-      await fs3.mkdir(target, { recursive: true });
-    } catch (_catch) {
-      var _err = _catch, _hasErr = 1;
-    } finally {
-      __callDispose(__stack, _err, _hasErr);
-    }
-  });
-}
-async function writeRaw(key, content) {
-  const dir = path3.join(os3.homedir(), ".pensar");
-  const target = path3.join(dir, ...key);
-  return withErrorHandling(async () => {
-    let __stack = [];
-    try {
-      const _2 = __using(__stack, await write(target), 0);
-      const parentDir = path3.dirname(target);
-      await fs3.mkdir(parentDir, { recursive: true });
-      await fs3.writeFile(target, content, "utf-8");
-    } catch (_catch) {
-      var _err = _catch, _hasErr = 1;
-    } finally {
-      __callDispose(__stack, _err, _hasErr);
-    }
-  });
-}
-async function read2(key, ext) {
-  const dir = path3.join(os3.homedir(), ".pensar");
-  const target = path3.join(dir, ...key) + (ext ? ext : ".json");
-  return withErrorHandling(async () => {
-    let __stack = [];
-    try {
-      const _2 = __using(__stack, await read(target), 0);
-      const text = await fs3.readFile(target, "utf-8");
-      const result = ext ? text : JSON.parse(text);
-      return result;
-    } catch (_catch) {
-      var _err = _catch, _hasErr = 1;
-    } finally {
-      __callDispose(__stack, _err, _hasErr);
-    }
-  });
-}
-async function update2(key, fn, ext) {
-  const dir = path3.join(os3.homedir(), ".pensar");
-  const target = path3.join(dir, ...key) + (ext ? ext : ".json");
-  return withErrorHandling(async () => {
-    let __stack = [];
-    try {
-      const _2 = __using(__stack, await write(target), 0);
-      const text = await fs3.readFile(target, "utf-8");
-      const content = ext ? text : JSON.parse(text);
-      fn(content);
-      await fs3.writeFile(target, JSON.stringify(content, null, 2), "utf-8");
-      return content;
-    } catch (_catch) {
-      var _err = _catch, _hasErr = 1;
-    } finally {
-      __callDispose(__stack, _err, _hasErr);
-    }
-  });
-}
-async function withErrorHandling(body) {
-  return body().catch((e) => {
-    if (!(e instanceof Error))
-      throw e;
-    const errnoExcpetion = e;
-    if (errnoExcpetion.code === "ENOENT") {
-      throw new NotFoundError({
-        message: `Resource not found: ${errnoExcpetion.path}`
-      });
-    }
-    throw e;
-  });
-}
+init_storage();
 
 // src/core/services/rateLimiter/index.ts
 function sleep(ms) {
@@ -267293,7 +267755,7 @@ async function update3(id, editor) {
   console.info("updated session", result);
   return result;
 }
-async function* list() {
+async function* list2() {
   const sessionsDir = getSessionsDir();
   let entries;
   try {
@@ -267428,7 +267890,7 @@ var sessions = {
   create: create2,
   get: get2,
   update: update3,
-  list,
+  list: list2,
   remove: remove2,
   updateMessage,
   removeMessage,
@@ -267557,9 +268019,9 @@ function AgentProvider({ children }) {
       }
       const byProvider = new Map;
       for (const m2 of available) {
-        const list2 = byProvider.get(m2.provider) || [];
-        list2.push(m2);
-        byProvider.set(m2.provider, list2);
+        const list3 = byProvider.get(m2.provider) || [];
+        list3.push(m2);
+        byProvider.set(m2.provider, list3);
       }
       let selectedModel = null;
       for (const provider of PROVIDER_PREFERENCE) {
@@ -267856,7 +268318,6 @@ function useInput() {
 }
 
 // src/tui/components/footer.tsx
-var import_react17 = __toESM(require_react(), 1);
 function formatTokenCount(count) {
   if (count >= 1e6) {
     return `${(count / 1e6).toFixed(1)}M`;
@@ -267871,7 +268332,7 @@ function Footer({
 }) {
   cwd = "~" + cwd.split(os6.homedir()).pop() || "";
   const { colors: colors2 } = useTheme();
-  const { model, tokenUsage, hasExecuted, thinking, isExecuting } = useAgent();
+  const { model, isExecuting } = useAgent();
   const session = useSession();
   const route = useRoute();
   const { isInputEmpty } = useInput();
@@ -267952,10 +268413,9 @@ function Footer({
 }
 function AgentStatus() {
   const { colors: colors2 } = useTheme();
-  const { tokenUsage, hasExecuted, thinking, isExecuting } = useAgent();
-  import_react17.useEffect(() => {
-    console.log(tokenUsage);
-  }, [tokenUsage]);
+  const route = useRoute();
+  const { tokenUsage, hasExecuted, thinking } = useAgent();
+  const tokenLabel = route.data.type === "operator" ? `${formatTokenCount(tokenUsage.outputTokens)}↑ ${formatTokenCount(tokenUsage.inputTokens)}↓` : `↓${formatTokenCount(tokenUsage.inputTokens)} ↑${formatTokenCount(tokenUsage.outputTokens)} Σ${formatTokenCount(tokenUsage.totalTokens)}`;
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
     flexDirection: "row",
     gap: 1,
@@ -267968,7 +268428,7 @@ function AgentStatus() {
           }, undefined, false, undefined, this),
           /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
             fg: colors2.text,
-            children: `↓${formatTokenCount(tokenUsage.inputTokens)} ↑${formatTokenCount(tokenUsage.outputTokens)} Σ${formatTokenCount(tokenUsage.totalTokens)}`
+            children: tokenLabel
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
@@ -267989,7 +268449,7 @@ function AgentStatus() {
 }
 
 // src/tui/context/command.tsx
-var import_react18 = __toESM(require_react(), 1);
+var import_react17 = __toESM(require_react(), 1);
 
 // src/tui/command-router.ts
 class CommandRouter {
@@ -268751,9 +269211,9 @@ async function skillExists(slug) {
 }
 
 // src/tui/context/command.tsx
-var CommandContext = import_react18.createContext(null);
+var CommandContext = import_react17.createContext(null);
 function useCommand() {
-  const context = import_react18.useContext(CommandContext);
+  const context = import_react17.useContext(CommandContext);
   if (!context) {
     throw new Error("useCommand must be used within CommandProvider");
   }
@@ -268764,8 +269224,8 @@ function CommandProvider({
   onOpenSessionsDialog
 }) {
   const route = useRoute();
-  const [skills, setSkills] = import_react18.useState([]);
-  const ctx3 = import_react18.useMemo(() => {
+  const [skills, setSkills] = import_react17.useState([]);
+  const ctx3 = import_react17.useMemo(() => {
     const ctx4 = {
       route: route.data,
       navigate: route.navigate,
@@ -268773,33 +269233,33 @@ function CommandProvider({
     };
     return ctx4;
   }, [route, onOpenSessionsDialog]);
-  const refreshSkills = import_react18.useCallback(async () => {
+  const refreshSkills = import_react17.useCallback(async () => {
     const loaded = await loadSkills();
     setSkills(loaded);
   }, []);
-  import_react18.useEffect(() => {
+  import_react17.useEffect(() => {
     refreshSkills();
   }, [route.data]);
-  const router = import_react18.useMemo(() => {
+  const router = import_react17.useMemo(() => {
     const router2 = new CommandRouter;
     for (const commandDef of commandRegistry) {
       router2.registerWithContext(commandDef, ctx3);
     }
     return router2;
   }, []);
-  const skillSlugMap = import_react18.useMemo(() => {
+  const skillSlugMap = import_react17.useMemo(() => {
     const map = new Map;
     for (const skill of skills) {
       map.set(slugify(skill.name), skill);
     }
     return map;
   }, [skills]);
-  const resolveSkillContent = import_react18.useCallback((input) => {
+  const resolveSkillContent = import_react17.useCallback((input) => {
     const trimmed = input.trim().replace(/^\/+/, "").toLowerCase();
     const skill = skillSlugMap.get(trimmed);
     return skill?.content ?? null;
   }, [skillSlugMap]);
-  const autocompleteOptions = import_react18.useMemo(() => {
+  const autocompleteOptions = import_react17.useMemo(() => {
     const routerCommands = router.getAllCommands();
     const options = [];
     for (const cmd of routerCommands) {
@@ -268823,10 +269283,10 @@ function CommandProvider({
     }
     return options;
   }, [router, skills]);
-  const executeCommand = import_react18.useCallback(async (input) => {
+  const executeCommand = import_react17.useCallback(async (input) => {
     return await router.execute(input, ctx3);
   }, [router, ctx3]);
-  const value = import_react18.useMemo(() => ({
+  const value = import_react17.useMemo(() => ({
     router,
     autocompleteOptions,
     executeCommand,
@@ -268849,24 +269309,24 @@ function CommandProvider({
 }
 
 // src/tui/components/commands/sessions-display.tsx
-var import_react23 = __toESM(require_react(), 1);
+var import_react22 = __toESM(require_react(), 1);
 
 // src/tui/context/focus.tsx
-var import_react19 = __toESM(require_react(), 1);
-var FocusContext = import_react19.createContext(undefined);
+var import_react18 = __toESM(require_react(), 1);
+var FocusContext = import_react18.createContext(undefined);
 function FocusProvider({ children }) {
-  const promptRef = import_react19.useRef(null);
-  const refocusPrompt = import_react19.useCallback(() => {
+  const promptRef = import_react18.useRef(null);
+  const refocusPrompt = import_react18.useCallback(() => {
     setTimeout(() => {
       promptRef.current?.focus();
     }, 1);
   }, []);
-  const focusPrompt = import_react19.useCallback(() => promptRef.current?.focus(), []);
-  const blurPrompt = import_react19.useCallback(() => promptRef.current?.blur(), []);
-  const resetPrompt = import_react19.useCallback(() => promptRef.current?.reset(), []);
-  const setPromptValue = import_react19.useCallback((value) => promptRef.current?.setValue(value), []);
-  const getPromptValue = import_react19.useCallback(() => promptRef.current?.getValue() ?? "", []);
-  const registerPromptRef = import_react19.useCallback((ref) => {
+  const focusPrompt = import_react18.useCallback(() => promptRef.current?.focus(), []);
+  const blurPrompt = import_react18.useCallback(() => promptRef.current?.blur(), []);
+  const resetPrompt = import_react18.useCallback(() => promptRef.current?.reset(), []);
+  const setPromptValue = import_react18.useCallback((value) => promptRef.current?.setValue(value), []);
+  const getPromptValue = import_react18.useCallback(() => promptRef.current?.getValue() ?? "", []);
+  const registerPromptRef = import_react18.useCallback((ref) => {
     promptRef.current = ref;
   }, []);
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(FocusContext.Provider, {
@@ -268884,7 +269344,7 @@ function FocusProvider({ children }) {
   }, undefined, false, undefined, this);
 }
 function useFocus() {
-  const context = import_react19.useContext(FocusContext);
+  const context = import_react18.useContext(FocusContext);
   if (!context) {
     throw new Error("useFocus must be used within FocusProvider");
   }
@@ -268916,7 +269376,7 @@ function openSessionReport(sessionRootPath) {
 }
 
 // src/tui/context/dialog.tsx
-var import_react21 = __toESM(require_react(), 1);
+var import_react20 = __toESM(require_react(), 1);
 function Dialog({ size = "medium", onClose, children }) {
   const dimensions = useTerminalDimensions();
   const renderer = useRenderer();
@@ -268953,14 +269413,14 @@ function Dialog({ size = "medium", onClose, children }) {
     }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
-var DialogContext = import_react21.createContext(null);
+var DialogContext = import_react20.createContext(null);
 function DialogProvider({ children }) {
-  const [stack, setStack] = import_react21.useState([]);
-  const [size, setSize] = import_react21.useState("medium");
-  const [externalDialogOpen, setExternalDialogOpen] = import_react21.useState(false);
+  const [stack, setStack] = import_react20.useState([]);
+  const [size, setSize] = import_react20.useState("medium");
+  const [externalDialogOpen, setExternalDialogOpen] = import_react20.useState(false);
   const renderer = useRenderer();
-  const focusRef = import_react21.useRef(null);
-  const refocus = import_react21.useCallback(() => {
+  const focusRef = import_react20.useRef(null);
+  const refocus = import_react20.useCallback(() => {
     setTimeout(() => {
       const focus = focusRef.current;
       if (!focus)
@@ -268982,7 +269442,7 @@ function DialogProvider({ children }) {
       focus.focus();
     }, 1);
   }, [renderer]);
-  const clear = import_react21.useCallback(() => {
+  const clear = import_react20.useCallback(() => {
     for (const item of stack) {
       if (item.onClose)
         item.onClose();
@@ -268991,7 +269451,7 @@ function DialogProvider({ children }) {
     setStack([]);
     refocus();
   }, [stack, refocus]);
-  const replace = import_react21.useCallback((element, onClose) => {
+  const replace = import_react20.useCallback((element, onClose) => {
     if (stack.length === 0) {
       focusRef.current = renderer.currentFocusedRenderable;
     }
@@ -269036,7 +269496,7 @@ function DialogProvider({ children }) {
   }, undefined, true, undefined, this);
 }
 function useDialog() {
-  const value = import_react21.useContext(DialogContext);
+  const value = import_react20.useContext(DialogContext);
   if (!value) {
     throw new Error("useDialog must be used within a DialogProvider");
   }
@@ -269044,10 +269504,10 @@ function useDialog() {
 }
 
 // src/tui/utils/scroll.ts
-function scrollToIndex(scrollBox, index, list2, getId) {
-  if (!scrollBox || list2.length === 0)
+function scrollToIndex(scrollBox, index, list3, getId) {
+  if (!scrollBox || list3.length === 0)
     return;
-  const item = list2[index];
+  const item = list3[index];
   if (!item)
     return;
   const target = findChildById(scrollBox, getId(item));
@@ -269057,7 +269517,7 @@ function scrollToIndex(scrollBox, index, list2, getId) {
     scrollBox.scrollTo(0);
     return;
   }
-  if (index === list2.length - 1) {
+  if (index === list3.length - 1) {
     scrollBox.scrollTo(Infinity);
     return;
   }
@@ -269099,7 +269559,7 @@ function findChildById(scrollBox, id) {
 }
 
 // src/tui/hooks/use-sessions-list.ts
-var import_react22 = __toESM(require_react(), 1);
+var import_react21 = __toESM(require_react(), 1);
 import { existsSync as existsSync7, readdirSync } from "fs";
 import { join as join3 } from "path";
 init_report();
@@ -269116,10 +269576,10 @@ function checkHasReport(rootPath) {
   return existsSync7(join3(rootPath, REPORT_FILENAME_MD));
 }
 function useSessionsList() {
-  const [allSessions, setAllSessions] = import_react22.useState([]);
-  const [loading, setLoading] = import_react22.useState(true);
-  const [searchTerm, setSearchTerm] = import_react22.useState("");
-  const loadSessions = import_react22.useCallback(async () => {
+  const [allSessions, setAllSessions] = import_react21.useState([]);
+  const [loading, setLoading] = import_react21.useState(true);
+  const [searchTerm, setSearchTerm] = import_react21.useState("");
+  const loadSessions = import_react21.useCallback(async () => {
     setLoading(true);
     try {
       const enriched = [];
@@ -269142,10 +269602,10 @@ function useSessionsList() {
       setLoading(false);
     }
   }, []);
-  import_react22.useEffect(() => {
+  import_react21.useEffect(() => {
     loadSessions();
   }, [loadSessions]);
-  const deleteSession = import_react22.useCallback(async (id) => {
+  const deleteSession = import_react21.useCallback(async (id) => {
     await sessions.remove({ sessionId: id });
     await loadSessions();
   }, [loadSessions]);
@@ -269204,10 +269664,10 @@ function useSessionsList() {
 function SessionsDisplay({ onClose }) {
   const { colors: colors2 } = useTheme();
   const { refocusPrompt } = useFocus();
-  const [selectedIndex, setSelectedIndex] = import_react23.useState(0);
-  const [statusMessage, setStatusMessage] = import_react23.useState("");
+  const [selectedIndex, setSelectedIndex] = import_react22.useState(0);
+  const [statusMessage, setStatusMessage] = import_react22.useState("");
   const route = useRoute();
-  const scroll = import_react23.useRef(null);
+  const scroll = import_react22.useRef(null);
   const {
     groupedSessions,
     visualOrderSessions,
@@ -269223,7 +269683,7 @@ function SessionsDisplay({ onClose }) {
       setTimeout(() => setStatusMessage(""), 2000);
     }
   }
-  import_react23.useEffect(() => {
+  import_react22.useEffect(() => {
     if (visualOrderSessions.length > 0 && selectedIndex >= visualOrderSessions.length) {
       setSelectedIndex(visualOrderSessions.length - 1);
     } else if (visualOrderSessions.length === 0) {
@@ -269495,7 +269955,7 @@ function SessionsDisplay({ onClose }) {
 }
 
 // src/tui/components/commands/config-dialog.tsx
-var import_react26 = __toESM(require_react(), 1);
+var import_react25 = __toESM(require_react(), 1);
 
 // src/tui/components/alert-dialog.tsx
 function AlertDialog({
@@ -269582,8 +270042,8 @@ function AlertDialog({
 init_config2();
 function ConfigDialog() {
   const route = useRoute();
-  const [open, setOpen] = import_react26.useState(false);
-  import_react26.useEffect(() => {
+  const [open, setOpen] = import_react25.useState(false);
+  import_react25.useEffect(() => {
     if (route.data.type === "base" && route.data.path === "config") {
       setOpen(true);
     } else {
@@ -269597,8 +270057,8 @@ function ConfigDialog() {
       path: "home"
     });
   };
-  const [appConfig, setAppConfig] = import_react26.useState(null);
-  import_react26.useEffect(() => {
+  const [appConfig, setAppConfig] = import_react25.useState(null);
+  import_react25.useEffect(() => {
     async function getConfig() {
       const _appConfig = await config.get();
       setAppConfig(_appConfig);
@@ -269668,15 +270128,15 @@ function ConfigForm({ appConfig }) {
 }
 
 // src/tui/components/chat/index.tsx
-var import_react38 = __toESM(require_react(), 1);
+var import_react37 = __toESM(require_react(), 1);
 
 // src/tui/context/config.tsx
 init_config2();
-var import_react27 = __toESM(require_react(), 1);
-var ctx3 = import_react27.createContext(null);
+var import_react26 = __toESM(require_react(), 1);
+var ctx3 = import_react26.createContext(null);
 function ConfigProvider({ children, config: config2 }) {
-  const [appConfig, setAppConfig] = import_react27.useState(config2);
-  const value = import_react27.useMemo(() => ({
+  const [appConfig, setAppConfig] = import_react26.useState(config2);
+  const value = import_react26.useMemo(() => ({
     data: appConfig,
     update: async (newConfig) => {
       await config.update(newConfig);
@@ -269696,7 +270156,7 @@ function ConfigProvider({ children, config: config2 }) {
   }, undefined, false, undefined, this);
 }
 var useConfig = () => {
-  const config2 = import_react27.useContext(ctx3);
+  const config2 = import_react26.useContext(ctx3);
   if (!config2) {
     throw new Error("useConfig must be called within a ConfigProvider");
   }
@@ -269704,10 +270164,10 @@ var useConfig = () => {
 };
 
 // src/tui/components/chat/home-view.tsx
-var import_react32 = __toESM(require_react(), 1);
+var import_react31 = __toESM(require_react(), 1);
 
 // src/tui/components/chat/petri-animation.tsx
-var import_react28 = __toESM(require_react(), 1);
+var import_react27 = __toESM(require_react(), 1);
 
 // src/tui/components/chat/lib/play-core/num.ts
 function clamp(x2, min, max) {
@@ -269803,8 +270263,8 @@ function stopGlobalTick2() {
   }
 }
 function useGlobalTick2() {
-  const [, setTick] = import_react28.useState(0);
-  import_react28.useEffect(() => {
+  const [, setTick] = import_react27.useState(0);
+  import_react27.useEffect(() => {
     const listener = () => setTick((t2) => t2 + 1);
     globalListeners2.add(listener);
     startGlobalTick2();
@@ -269832,16 +270292,16 @@ function PetriAnimation({
   const dimensions = useTerminalDimensions();
   const tick = useGlobalTick2();
   const { colors: colors2 } = useTheme();
-  const simulationRef = import_react28.useRef(null);
-  const [frame, setFrame] = import_react28.useState([]);
-  const gradientColors = import_react28.useMemo(() => generateGradient(colors2.primary, 9), [colors2.primary]);
-  const actualHeight = import_react28.useMemo(() => {
+  const simulationRef = import_react27.useRef(null);
+  const [frame, setFrame] = import_react27.useState([]);
+  const gradientColors = import_react27.useMemo(() => generateGradient(colors2.primary, 9), [colors2.primary]);
+  const actualHeight = import_react27.useMemo(() => {
     if (typeof height === "number" && height <= 1) {
       return Math.floor(dimensions.height * height);
     }
     return typeof height === "number" ? height : Math.floor(dimensions.height * 0.4);
   }, [height, dimensions.height]);
-  const actualWidth = import_react28.useMemo(() => {
+  const actualWidth = import_react27.useMemo(() => {
     if (typeof width === "number" && width <= 1) {
       return Math.floor(dimensions.width * width);
     }
@@ -269850,7 +270310,7 @@ function PetriAnimation({
     }
     return typeof width === "number" ? width : dimensions.width;
   }, [width, dimensions.width]);
-  import_react28.useEffect(() => {
+  import_react27.useEffect(() => {
     if (actualWidth <= 0 || actualHeight <= 0)
       return;
     if (!simulationRef.current) {
@@ -269859,7 +270319,7 @@ function PetriAnimation({
       simulationRef.current.resize(actualWidth, actualHeight);
     }
   }, [actualWidth, actualHeight]);
-  import_react28.useEffect(() => {
+  import_react27.useEffect(() => {
     if (simulationRef.current) {
       simulationRef.current.step();
       setFrame(simulationRef.current.render());
@@ -269885,8 +270345,8 @@ function getRowColor(rowIdx, totalRows, gradient) {
 }
 
 // src/tui/components/shared/prompt-input.tsx
-var import_react30 = __toESM(require_react(), 1);
-var PromptInput = import_react30.forwardRef(function PromptInput2({
+var import_react29 = __toESM(require_react(), 1);
+var PromptInput = import_react29.forwardRef(function PromptInput2({
   width,
   minHeight = 1,
   maxHeight = 6,
@@ -269903,20 +270363,26 @@ var PromptInput = import_react30.forwardRef(function PromptInput2({
   maxSuggestions = 10,
   enableCommands = false,
   onCommandExecute,
+  commandHistory = [],
   showPromptIndicator = false
 }, ref) {
   const { colors: colors2 } = useTheme();
   const { inputValue, setInputValue } = useInput();
   const { registerPromptRef } = useFocus();
-  const textareaRef = import_react30.useRef(null);
-  const [selectedSuggestionIndex, setSelectedSuggestionIndex] = import_react30.useState(-1);
-  const selectedIndexRef = import_react30.useRef(selectedSuggestionIndex);
-  const suggestionsRef = import_react30.useRef([]);
-  const onCommandExecuteRef = import_react30.useRef(onCommandExecute);
+  const textareaRef = import_react29.useRef(null);
+  const [selectedSuggestionIndex, setSelectedSuggestionIndex] = import_react29.useState(-1);
+  const [historyIndex, setHistoryIndex] = import_react29.useState(-1);
+  const savedInputRef = import_react29.useRef("");
+  const historyRef = import_react29.useRef(commandHistory);
+  historyRef.current = commandHistory;
+  const isNavigatingHistoryRef = import_react29.useRef(false);
+  const selectedIndexRef = import_react29.useRef(selectedSuggestionIndex);
+  const suggestionsRef = import_react29.useRef([]);
+  const onCommandExecuteRef = import_react29.useRef(onCommandExecute);
   onCommandExecuteRef.current = onCommandExecute;
-  const onSubmitRef = import_react30.useRef(onSubmit);
+  const onSubmitRef = import_react29.useRef(onSubmit);
   onSubmitRef.current = onSubmit;
-  const suggestions = import_react30.useMemo(() => {
+  const suggestions = import_react29.useMemo(() => {
     if (!enableAutocomplete || !autocompleteOptions || !inputValue)
       return [];
     const input = inputValue.toLowerCase().trim();
@@ -269924,16 +270390,16 @@ var PromptInput = import_react30.forwardRef(function PromptInput2({
       return [];
     return autocompleteOptions.filter((opt) => opt.value.toLowerCase().includes(input) || opt.label.toLowerCase().includes(input)).slice(0, maxSuggestions);
   }, [enableAutocomplete, autocompleteOptions, inputValue, maxSuggestions]);
-  import_react30.useEffect(() => {
+  import_react29.useEffect(() => {
     suggestionsRef.current = suggestions;
   }, [suggestions]);
-  import_react30.useEffect(() => {
+  import_react29.useEffect(() => {
     selectedIndexRef.current = selectedSuggestionIndex;
   }, [selectedSuggestionIndex]);
-  import_react30.useEffect(() => {
+  import_react29.useEffect(() => {
     setSelectedSuggestionIndex(suggestions.length > 0 ? 0 : -1);
   }, [suggestions.length]);
-  const imperativeRef = import_react30.useRef({
+  const imperativeRef = import_react29.useRef({
     focus: () => textareaRef.current?.focus(),
     blur: () => textareaRef.current?.blur(),
     reset: () => {
@@ -269948,37 +270414,85 @@ var PromptInput = import_react30.forwardRef(function PromptInput2({
     getValue: () => inputValue,
     getTextareaRef: () => textareaRef.current
   });
-  import_react30.useEffect(() => {
+  import_react29.useEffect(() => {
     imperativeRef.current.getValue = () => inputValue;
   }, [inputValue]);
-  import_react30.useImperativeHandle(ref, () => imperativeRef.current, []);
-  import_react30.useEffect(() => {
+  import_react29.useImperativeHandle(ref, () => imperativeRef.current, []);
+  import_react29.useEffect(() => {
     registerPromptRef(imperativeRef.current);
     return () => registerPromptRef(null);
   }, [registerPromptRef]);
   useKeyboard((key) => {
-    if (!focused || suggestions.length === 0)
+    if (!focused)
       return;
-    if (key.name === "up") {
-      setSelectedSuggestionIndex((prev) => prev <= 0 ? suggestions.length - 1 : prev - 1);
+    if (suggestions.length > 0) {
+      if (key.name === "up") {
+        setSelectedSuggestionIndex((prev) => prev <= 0 ? suggestions.length - 1 : prev - 1);
+        return;
+      }
+      if (key.name === "down") {
+        setSelectedSuggestionIndex((prev) => prev >= suggestions.length - 1 ? 0 : prev + 1);
+        return;
+      }
+      if (key.name === "tab") {
+        key.preventDefault?.();
+        const currentSelectedIndex = selectedIndexRef.current;
+        if (currentSelectedIndex >= 0 && currentSelectedIndex < suggestions.length) {
+          const selected = suggestions[currentSelectedIndex];
+          if (selected) {
+            textareaRef.current?.setText(selected.value);
+            setInputValue(selected.value);
+            setSelectedSuggestionIndex(-1);
+            textareaRef.current?.gotoLineEnd();
+          }
+        }
+        return;
+      }
       return;
     }
-    if (key.name === "down") {
-      setSelectedSuggestionIndex((prev) => prev >= suggestions.length - 1 ? 0 : prev + 1);
+    const history = historyRef.current;
+    if (history.length === 0)
+      return;
+    if (key.name === "up") {
+      setHistoryIndex((prev) => {
+        if (prev === -1) {
+          savedInputRef.current = textareaRef.current?.plainText ?? "";
+        }
+        const next = Math.min(prev + 1, history.length - 1);
+        const entry = history[history.length - 1 - next];
+        if (entry !== undefined) {
+          isNavigatingHistoryRef.current = true;
+          textareaRef.current?.setText(entry);
+          setInputValue(entry);
+          isNavigatingHistoryRef.current = false;
+          setTimeout(() => textareaRef.current?.gotoLineEnd(), 0);
+        }
+        return next;
+      });
       return;
     }
-    if (key.name === "tab") {
-      key.preventDefault?.();
-      const currentSelectedIndex = selectedIndexRef.current;
-      if (currentSelectedIndex >= 0 && currentSelectedIndex < suggestions.length) {
-        const selected = suggestions[currentSelectedIndex];
-        if (selected) {
-          textareaRef.current?.setText(selected.value);
-          setInputValue(selected.value);
-          setSelectedSuggestionIndex(-1);
-          textareaRef.current?.gotoLineEnd();
+    if (key.name === "down") {
+      setHistoryIndex((prev) => {
+        if (prev <= 0) {
+          const saved = savedInputRef.current;
+          isNavigatingHistoryRef.current = true;
+          textareaRef.current?.setText(saved);
+          setInputValue(saved);
+          isNavigatingHistoryRef.current = false;
+          setTimeout(() => textareaRef.current?.gotoLineEnd(), 0);
+          return -1;
         }
-      }
+        const next = prev - 1;
+        const entry = history[history.length - 1 - next];
+        if (entry !== undefined) {
+          isNavigatingHistoryRef.current = true;
+          textareaRef.current?.setText(entry);
+          setInputValue(entry);
+          isNavigatingHistoryRef.current = false;
+          setTimeout(() => textareaRef.current?.gotoLineEnd(), 0);
+        }
+        return next;
+      });
       return;
     }
   });
@@ -270004,13 +270518,18 @@ var PromptInput = import_react30.forwardRef(function PromptInput2({
       setInputValue("");
       textareaRef.current?.setText("");
       setSelectedSuggestionIndex(-1);
+      setHistoryIndex(-1);
       return;
     }
+    setHistoryIndex(-1);
     onSubmitRef.current?.(valueToSubmit);
   };
   const handleContentChange = () => {
     const text = textareaRef.current?.plainText ?? "";
     setInputValue(text);
+    if (historyIndex !== -1 && !isNavigatingHistoryRef.current) {
+      setHistoryIndex(-1);
+    }
   };
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
     flexDirection: "column",
@@ -270092,6 +270611,45 @@ var PromptInput = import_react30.forwardRef(function PromptInput2({
   }, undefined, true, undefined, this);
 });
 
+// src/core/history.ts
+init_storage();
+var STORAGE_KEY = ["command-history"];
+var MAX_ENTRIES = 500;
+var entries = null;
+var loadPromise = null;
+async function ensureLoaded() {
+  if (entries !== null)
+    return entries;
+  if (!loadPromise) {
+    loadPromise = (async () => {
+      try {
+        const data = await read2(STORAGE_KEY);
+        entries = Array.isArray(data) ? data : [];
+      } catch {
+        entries = [];
+      }
+    })();
+  }
+  await loadPromise;
+  return entries;
+}
+async function load() {
+  return ensureLoaded();
+}
+async function push(entry) {
+  const history = await ensureLoaded();
+  if (history[history.length - 1] === entry)
+    return;
+  history.push(entry);
+  if (history.length > MAX_ENTRIES) {
+    history.splice(0, history.length - MAX_ENTRIES);
+  }
+  write2(STORAGE_KEY, history).catch(() => {});
+}
+function getEntries() {
+  return entries ?? [];
+}
+
 // src/tui/components/chat/home-view.tsx
 function HomeView({ onNavigate, onStartSession }) {
   const { colors: colors2 } = useTheme();
@@ -270101,27 +270659,37 @@ function HomeView({ onNavigate, onStartSession }) {
   const { executeCommand, autocompleteOptions, resolveSkillContent, skills } = useCommand();
   const { setInputValue } = useInput();
   const { promptRef } = useFocus();
-  const [hintMessage, setHintMessage] = import_react32.useState(null);
-  const launchOperator = import_react32.useCallback((message, options) => {
+  const [hintMessage, setHintMessage] = import_react31.useState(null);
+  const [commandHistory, setCommandHistory] = import_react31.useState(getEntries);
+  import_react31.useEffect(() => {
+    load().then(setCommandHistory);
+  }, []);
+  const launchOperator = import_react31.useCallback((message, options) => {
     route.navigate({
       type: "operator",
       initialMessage: message,
       initialConfig: { requireApproval: options?.requireApproval ?? true }
     });
   }, [route]);
-  const handleSubmit = import_react32.useCallback((value) => {
+  const pushHistory = import_react31.useCallback((entry) => {
+    push(entry).then(() => setCommandHistory([...getEntries()]));
+  }, []);
+  const handleSubmit = import_react31.useCallback((value) => {
     if (!value.trim())
       return;
+    pushHistory(value.trim());
     launchOperator(value.trim());
-  }, [launchOperator]);
-  import_react32.useEffect(() => {
+  }, [launchOperator, pushHistory]);
+  import_react31.useEffect(() => {
     if (!hintMessage)
       return;
     const timer = setTimeout(() => setHintMessage(null), 3000);
     return () => clearTimeout(timer);
   }, [hintMessage]);
-  const handleCommandExecute = import_react32.useCallback(async (command) => {
-    const parts = command.trim().replace(/^\/+/, "").split(/\s+/);
+  const handleCommandExecute = import_react31.useCallback(async (command) => {
+    const trimmed = command.trim();
+    pushHistory(trimmed);
+    const parts = trimmed.replace(/^\/+/, "").split(/\s+/);
     const slug = parts[0]?.toLowerCase() ?? "";
     const args = parts.slice(1);
     const autopilot = args.includes("--autopilot");
@@ -270131,7 +270699,7 @@ function HomeView({ onNavigate, onStartSession }) {
       return;
     }
     await executeCommand(command);
-  }, [resolveSkillContent, launchOperator, executeCommand]);
+  }, [resolveSkillContent, launchOperator, executeCommand, pushHistory]);
   const skillItems = skills.slice(0, 5).map((s) => ({
     cmd: `/${slugify(s.name)}`,
     desc: s.description || "skill"
@@ -270272,6 +270840,7 @@ function HomeView({ onNavigate, onStartSession }) {
             autocompleteOptions,
             enableCommands: true,
             onCommandExecute: handleCommandExecute,
+            commandHistory,
             showPromptIndicator: true
           }, undefined, false, undefined, this),
           hintMessage && /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
@@ -270333,10 +270902,10 @@ function HomeView({ onNavigate, onStartSession }) {
 }
 
 // src/tui/components/chat/config-view.tsx
-var import_react36 = __toESM(require_react(), 1);
+var import_react35 = __toESM(require_react(), 1);
 
 // src/tui/components/model-picker/ModelPicker.tsx
-var import_react34 = __toESM(require_react(), 1);
+var import_react33 = __toESM(require_react(), 1);
 var providerNames = {
   anthropic: "Claude",
   openai: "OpenAI",
@@ -270365,18 +270934,18 @@ function ModelPicker({
   isModelUserSelected = false
 }) {
   const { colors: colors2 } = useTheme();
-  const [availableModels, setAvailableModels] = import_react34.useState([]);
-  const [searchQuery, setSearchQuery] = import_react34.useState("");
-  const [expandedProviders, setExpandedProviders] = import_react34.useState(new Set(["anthropic"]));
-  const [focusedIndex, setFocusedIndex] = import_react34.useState(0);
-  const [localUrl, setLocalUrl] = import_react34.useState(config2?.localModelUrl ?? "");
-  const [localModelName, setLocalModelName] = import_react34.useState(config2?.localModelName ?? "");
-  const [editingLocalField, setEditingLocalField] = import_react34.useState(null);
-  import_react34.useEffect(() => {
+  const [availableModels, setAvailableModels] = import_react33.useState([]);
+  const [searchQuery, setSearchQuery] = import_react33.useState("");
+  const [expandedProviders, setExpandedProviders] = import_react33.useState(new Set(["anthropic"]));
+  const [focusedIndex, setFocusedIndex] = import_react33.useState(0);
+  const [localUrl, setLocalUrl] = import_react33.useState(config2?.localModelUrl ?? "");
+  const [localModelName, setLocalModelName] = import_react33.useState(config2?.localModelName ?? "");
+  const [editingLocalField, setEditingLocalField] = import_react33.useState(null);
+  import_react33.useEffect(() => {
     setLocalUrl(config2?.localModelUrl ?? "");
     setLocalModelName(config2?.localModelName ?? "");
   }, [config2?.localModelUrl, config2?.localModelName]);
-  import_react34.useEffect(() => {
+  import_react33.useEffect(() => {
     if (config2) {
       const models = getAvailableModels(config2);
       setAvailableModels(models);
@@ -270388,7 +270957,7 @@ function ModelPicker({
       }
     }
   }, [config2, selectedModel.id]);
-  const groupedModels = import_react34.useMemo(() => {
+  const groupedModels = import_react33.useMemo(() => {
     const groups = {};
     const query = searchQuery.toLowerCase().trim();
     for (const m2 of availableModels) {
@@ -270402,7 +270971,7 @@ function ModelPicker({
     }
     return groups;
   }, [availableModels, searchQuery]);
-  const navigationItems = import_react34.useMemo(() => {
+  const navigationItems = import_react33.useMemo(() => {
     const items = [];
     for (const provider of providerOrder) {
       if (provider === "local") {
@@ -270431,16 +271000,16 @@ function ModelPicker({
     }
     return items;
   }, [groupedModels, expandedProviders]);
-  import_react34.useEffect(() => {
+  import_react33.useEffect(() => {
     const idx = navigationItems.findIndex((item) => item.type === "model" && item.model.id === selectedModel.id);
     if (idx !== -1) {
       setFocusedIndex(idx);
     }
   }, [selectedModel.id, navigationItems]);
-  import_react34.useEffect(() => {
+  import_react33.useEffect(() => {
     setFocusedIndex((prev) => Math.min(prev, Math.max(0, navigationItems.length - 1)));
   }, [navigationItems.length]);
-  const commitLocalConfig = import_react34.useCallback((url, modelName) => {
+  const commitLocalConfig = import_react33.useCallback((url, modelName) => {
     if (!onConfigUpdate)
       return;
     const update4 = {
@@ -270449,11 +271018,11 @@ function ModelPicker({
     };
     onConfigUpdate(update4);
   }, [onConfigUpdate]);
-  const finishEditing = import_react34.useCallback(() => {
+  const finishEditing = import_react33.useCallback(() => {
     setEditingLocalField(null);
     commitLocalConfig(localUrl, localModelName);
   }, [localUrl, localModelName, commitLocalConfig]);
-  const handleKeyboard = import_react34.useCallback((key) => {
+  const handleKeyboard = import_react33.useCallback((key) => {
     if (!focused)
       return false;
     if (editingLocalField) {
@@ -270718,16 +271287,16 @@ function ModelPicker({
 // src/tui/components/chat/config-view.tsx
 function ConfigView({ config: config2, onBack, onStart }) {
   const { colors: colors2 } = useTheme();
-  const [targetUrl, setTargetUrl] = import_react36.useState("https://");
-  const [strictScope, setStrictScope] = import_react36.useState(true);
-  const [selectedModel, setSelectedModel] = import_react36.useState({
+  const [targetUrl, setTargetUrl] = import_react35.useState("https://");
+  const [strictScope, setStrictScope] = import_react35.useState(true);
+  const [selectedModel, setSelectedModel] = import_react35.useState({
     id: "claude-sonnet-4-20250514",
     name: "Claude Sonnet 4",
     provider: "anthropic"
   });
-  const [isModelUserSelected, setIsModelUserSelected] = import_react36.useState(false);
-  const [focusedField, setFocusedField] = import_react36.useState("url");
-  import_react36.useEffect(() => {
+  const [isModelUserSelected, setIsModelUserSelected] = import_react35.useState(false);
+  const [focusedField, setFocusedField] = import_react35.useState("url");
+  import_react35.useEffect(() => {
     if (config2) {
       const models = getAvailableModels(config2);
       if (models.length > 0 && !isModelUserSelected) {
@@ -270773,7 +271342,7 @@ function ConfigView({ config: config2, onBack, onStart }) {
       return;
     }
   });
-  const handleModelSelect = import_react36.useCallback((model) => {
+  const handleModelSelect = import_react35.useCallback((model) => {
     setSelectedModel(model);
     setIsModelUserSelected(true);
   }, []);
@@ -270949,11 +271518,11 @@ function ChatApp({
 }) {
   const config2 = useConfig();
   const { model } = useAgent();
-  const [currentView, setCurrentView] = import_react38.useState(initialView);
-  const [activeSession, setActiveSession] = import_react38.useState(null);
-  const [sessionModel, setSessionModel] = import_react38.useState(model);
-  const [initialDirective, setInitialDirective] = import_react38.useState(undefined);
-  import_react38.useEffect(() => {
+  const [currentView, setCurrentView] = import_react37.useState(initialView);
+  const [activeSession, setActiveSession] = import_react37.useState(null);
+  const [sessionModel, setSessionModel] = import_react37.useState(model);
+  const [initialDirective, setInitialDirective] = import_react37.useState(undefined);
+  import_react37.useEffect(() => {
     if (initialSessionId) {
       sessions.get(initialSessionId).then((session) => {
         if (session) {
@@ -270963,7 +271532,7 @@ function ChatApp({
       });
     }
   }, [initialSessionId]);
-  const handleNavigate = import_react38.useCallback((view, options) => {
+  const handleNavigate = import_react37.useCallback((view, options) => {
     if (view === "chat" && options?.sessionId) {
       sessions.get(options.sessionId).then((session) => {
         if (session) {
@@ -270975,7 +271544,7 @@ function ChatApp({
       setCurrentView(view);
     }
   }, []);
-  const handleStartSession = import_react38.useCallback(async (directive) => {
+  const handleStartSession = import_react37.useCallback(async (directive) => {
     const session = await sessions.create({
       name: `exploration-${Date.now()}`,
       targets: []
@@ -270984,7 +271553,7 @@ function ChatApp({
     setInitialDirective(directive);
     setCurrentView("chat");
   }, []);
-  const handleConfigSubmit = import_react38.useCallback(async (configData) => {
+  const handleConfigSubmit = import_react37.useCallback(async (configData) => {
     const hostname = parseHostFromTarget(configData.targetUrl);
     const timestamp = new Date().toISOString().split("T")[0];
     const sessionName = `${hostname}-${timestamp}`;
@@ -271007,12 +271576,12 @@ function ChatApp({
     setSessionModel(configData.model);
     setCurrentView("chat");
   }, []);
-  const handleExitChat = import_react38.useCallback(() => {
+  const handleExitChat = import_react37.useCallback(() => {
     setCurrentView("home");
     setActiveSession(null);
     setInitialDirective(undefined);
   }, []);
-  const handleBackFromConfig = import_react38.useCallback(() => {
+  const handleBackFromConfig = import_react37.useCallback(() => {
     setCurrentView("home");
   }, []);
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
@@ -271044,7 +271613,7 @@ function parseHostFromTarget(target) {
 var chat_default = ChatApp;
 
 // src/tui/components/commands/operator-wizard.tsx
-var import_react39 = __toESM(require_react(), 1);
+var import_react38 = __toESM(require_react(), 1);
 var providerOrder2 = ["anthropic", "openai", "openrouter", "bedrock"];
 function HITLWizard(props) {
   const { colors: colors2 } = useTheme();
@@ -271052,18 +271621,18 @@ function HITLWizard(props) {
   const route = useRoute();
   const config2 = useConfig();
   const { model, setModel, isModelUserSelected } = useAgent();
-  const [currentStep, setCurrentStep] = import_react39.useState("config");
-  const [state, setState] = import_react39.useState(() => ({
+  const [currentStep, setCurrentStep] = import_react38.useState("config");
+  const [state, setState] = import_react38.useState(() => ({
     name: initialName || generateRandomName(),
     target: initialTarget || "",
     requireApproval: initialRequireApproval ?? true
   }));
-  const [focusedField, setFocusedField] = import_react39.useState(0);
-  const [error, setError] = import_react39.useState(null);
-  const [availableModels, setAvailableModels] = import_react39.useState([]);
-  const [modelSearchQuery, setModelSearchQuery] = import_react39.useState("");
-  const [expandedProviders, setExpandedProviders] = import_react39.useState(new Set(["anthropic"]));
-  import_react39.useEffect(() => {
+  const [focusedField, setFocusedField] = import_react38.useState(0);
+  const [error, setError] = import_react38.useState(null);
+  const [availableModels, setAvailableModels] = import_react38.useState([]);
+  const [modelSearchQuery, setModelSearchQuery] = import_react38.useState("");
+  const [expandedProviders, setExpandedProviders] = import_react38.useState(new Set(["anthropic"]));
+  import_react38.useEffect(() => {
     if (config2.data) {
       const models = getAvailableModels(config2.data);
       setAvailableModels(models);
@@ -271083,7 +271652,7 @@ function HITLWizard(props) {
       }
     }
   }, [config2.data, model.id, initialModel]);
-  const groupedModels = import_react39.useMemo(() => {
+  const groupedModels = import_react38.useMemo(() => {
     const groups = {};
     const query = modelSearchQuery.toLowerCase().trim();
     for (const m2 of availableModels) {
@@ -271096,7 +271665,7 @@ function HITLWizard(props) {
     }
     return groups;
   }, [availableModels, modelSearchQuery]);
-  const visibleModels = import_react39.useMemo(() => {
+  const visibleModels = import_react38.useMemo(() => {
     const result = [];
     for (const provider of providerOrder2) {
       const models = groupedModels[provider];
@@ -271364,11 +271933,11 @@ function HITLWizard(props) {
 }
 
 // src/tui/components/commands/web-wizard.tsx
-var import_react42 = __toESM(require_react(), 1);
+var import_react41 = __toESM(require_react(), 1);
 
 // src/tui/components/input.tsx
-var import_react41 = __toESM(require_react(), 1);
-var Input = import_react41.forwardRef(function Input2(opts, ref) {
+var import_react40 = __toESM(require_react(), 1);
+var Input = import_react40.forwardRef(function Input2(opts, ref) {
   const { colors: colors2 } = useTheme();
   const { label, focused = true, description, ...inputProps } = opts;
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
@@ -271422,10 +271991,10 @@ function WebWizard({
   const route = useRoute();
   const config2 = useConfig();
   const { model, setModel, isModelUserSelected } = useAgent();
-  const [availableModels, setAvailableModels] = import_react42.useState([]);
-  const [selectedModelIndex, setSelectedModelIndex] = import_react42.useState(0);
-  const [modelSearchQuery, setModelSearchQuery] = import_react42.useState("");
-  const [expandedProviders, setExpandedProviders] = import_react42.useState(new Set(["anthropic"]));
+  const [availableModels, setAvailableModels] = import_react41.useState([]);
+  const [selectedModelIndex, setSelectedModelIndex] = import_react41.useState(0);
+  const [modelSearchQuery, setModelSearchQuery] = import_react41.useState("");
+  const [expandedProviders, setExpandedProviders] = import_react41.useState(new Set(["anthropic"]));
   const providerNames2 = {
     anthropic: "Claude",
     openai: "OpenAI",
@@ -271433,7 +272002,7 @@ function WebWizard({
     bedrock: "Bedrock"
   };
   const providerOrder3 = ["anthropic", "openai", "openrouter", "bedrock"];
-  const groupedModels = import_react42.useMemo(() => {
+  const groupedModels = import_react41.useMemo(() => {
     const groups = {};
     const query = modelSearchQuery.toLowerCase().trim();
     for (const m2 of availableModels) {
@@ -271447,7 +272016,7 @@ function WebWizard({
     }
     return groups;
   }, [availableModels, modelSearchQuery]);
-  const visibleModels = import_react42.useMemo(() => {
+  const visibleModels = import_react41.useMemo(() => {
     const result = [];
     for (const provider of providerOrder3) {
       const models = groupedModels[provider];
@@ -271459,7 +272028,7 @@ function WebWizard({
     }
     return result;
   }, [groupedModels, expandedProviders]);
-  import_react42.useEffect(() => {
+  import_react41.useEffect(() => {
     if (config2.data) {
       const models = getAvailableModels(config2.data);
       setAvailableModels(models);
@@ -271488,8 +272057,8 @@ function WebWizard({
     }
   }, [config2.data, model.id, initialModel]);
   const initialStep = initialTarget ? "configure" : "target";
-  const [currentStep, setCurrentStep] = import_react42.useState(initialStep);
-  const [state, setState] = import_react42.useState(() => ({
+  const [currentStep, setCurrentStep] = import_react41.useState(initialStep);
+  const [state, setState] = import_react41.useState(() => ({
     name: initialName || generateRandomName(),
     target: initialTarget || "",
     sourceCodeAccess: false,
@@ -271511,14 +272080,14 @@ function WebWizard({
       customHeaders: initialCustomHeaders || {}
     }
   }));
-  const [targetFocusedField, setTargetFocusedField] = import_react42.useState(0);
-  const [focusedSection, setFocusedSection] = import_react42.useState(0);
-  const [focusedField, setFocusedField] = import_react42.useState(0);
-  const [hostInput, setHostInput] = import_react42.useState("");
-  const [portInput, setPortInput] = import_react42.useState("");
-  const [headerNameInput, setHeaderNameInput] = import_react42.useState("");
-  const [headerValueInput, setHeaderValueInput] = import_react42.useState("");
-  const [error, setError] = import_react42.useState(null);
+  const [targetFocusedField, setTargetFocusedField] = import_react41.useState(0);
+  const [focusedSection, setFocusedSection] = import_react41.useState(0);
+  const [focusedField, setFocusedField] = import_react41.useState(0);
+  const [hostInput, setHostInput] = import_react41.useState("");
+  const [portInput, setPortInput] = import_react41.useState("");
+  const [headerNameInput, setHeaderNameInput] = import_react41.useState("");
+  const [headerValueInput, setHeaderValueInput] = import_react41.useState("");
+  const [error, setError] = import_react41.useState(null);
   async function createSessionAndNavigate() {
     if (!state.target.trim())
       return;
@@ -272465,10 +273034,10 @@ function WebWizard({
 }
 
 // src/tui/components/commands/provider-manager.tsx
-var import_react48 = __toESM(require_react(), 1);
+var import_react47 = __toESM(require_react(), 1);
 init_config2();
 // src/tui/components/commands/provider-selection.tsx
-var import_react45 = __toESM(require_react(), 1);
+var import_react44 = __toESM(require_react(), 1);
 function ProviderSelection({
   onProviderSelected,
   onClose
@@ -272476,7 +273045,7 @@ function ProviderSelection({
   const { colors: colors2 } = useTheme();
   const route = useRoute();
   const _config = useConfig();
-  const [highlightedIndex, setHighlightedIndex] = import_react45.useState(0);
+  const [highlightedIndex, setHighlightedIndex] = import_react44.useState(0);
   const configuredProviders = getConfiguredProviders(_config.data);
   useKeyboard((key) => {
     if (key.name === "escape") {
@@ -272629,7 +273198,7 @@ function ProviderSelection({
 }
 
 // src/tui/components/commands/api-key-input.tsx
-var import_react47 = __toESM(require_react(), 1);
+var import_react46 = __toESM(require_react(), 1);
 function APIKeyInput({
   provider,
   providerName,
@@ -272637,7 +273206,7 @@ function APIKeyInput({
   onCancel
 }) {
   const { colors: colors2 } = useTheme();
-  const [apiKey, setApiKey] = import_react47.useState("");
+  const [apiKey, setApiKey] = import_react46.useState("");
   useKeyboard((key) => {
     if (key.name === "escape") {
       onCancel();
@@ -272753,8 +273322,8 @@ function APIKeyInput({
 function ProviderManager() {
   const route = useRoute();
   const _config = useConfig();
-  const [flowState, setFlowState] = import_react48.useState("selecting");
-  const [selectedProvider, setSelectedProvider] = import_react48.useState(null);
+  const [flowState, setFlowState] = import_react47.useState("selecting");
+  const [selectedProvider, setSelectedProvider] = import_react47.useState(null);
   const handleProviderSelected = (providerId) => {
     setSelectedProvider(providerId);
     setFlowState("inputting");
@@ -272818,7 +273387,7 @@ function ProviderManager() {
 init_config2();
 
 // src/tui/components/switch.tsx
-var import_react49 = __toESM(require_react(), 1);
+var import_react48 = __toESM(require_react(), 1);
 var CaseSymbol = Symbol("Switch.Case");
 var DefaultSymbol = Symbol("Switch.Default");
 function CaseComponent({
@@ -272841,8 +273410,8 @@ function SwitchComponent({
 }) {
   let matchedChild = null;
   let defaultChild = null;
-  import_react49.default.Children.forEach(children, (child) => {
-    if (import_react49.default.isValidElement(child)) {
+  import_react48.default.Children.forEach(children, (child) => {
+    if (import_react48.default.isValidElement(child)) {
       if (child.type[CaseSymbol]) {
         const caseChild = child;
         if (caseChild.props.when === condition) {
@@ -272955,8 +273524,8 @@ function ResponsibleUseDisclosure({
 }
 
 // src/tui/context/toast.tsx
-var import_react51 = __toESM(require_react(), 1);
-var ToastContext = import_react51.createContext(null);
+var import_react50 = __toESM(require_react(), 1);
+var ToastContext = import_react50.createContext(null);
 var nextId = 0;
 var DEFAULT_DURATION = {
   default: 3000,
@@ -272964,24 +273533,24 @@ var DEFAULT_DURATION = {
   error: 5000
 };
 function ToastProvider({ children }) {
-  const [toasts, setToasts] = import_react51.useState([]);
-  const dismiss = import_react51.useCallback((id) => {
+  const [toasts, setToasts] = import_react50.useState([]);
+  const dismiss = import_react50.useCallback((id) => {
     setToasts((prev) => prev.filter((t2) => t2.id !== id));
   }, []);
-  const toast = import_react51.useCallback((message, variant = "default", duration) => {
+  const toast = import_react50.useCallback((message, variant = "default", duration) => {
     const id = nextId++;
     const ms = duration ?? DEFAULT_DURATION[variant];
     setToasts((prev) => [...prev, { id, message, variant, duration: ms }]);
     setTimeout(() => dismiss(id), ms);
   }, [dismiss]);
-  const value = import_react51.useMemo(() => ({ toasts, toast, dismiss }), [toasts, toast, dismiss]);
+  const value = import_react50.useMemo(() => ({ toasts, toast, dismiss }), [toasts, toast, dismiss]);
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(ToastContext.Provider, {
     value,
     children
   }, undefined, false, undefined, this);
 }
 function useToast() {
-  const ctx4 = import_react51.useContext(ToastContext);
+  const ctx4 = import_react50.useContext(ToastContext);
   if (!ctx4)
     throw new Error("useToast() must be used within <ToastProvider>");
   return ctx4;
@@ -273054,11 +273623,11 @@ function ToastContainer() {
 }
 
 // src/tui/components/error-boundary.tsx
-var import_react53 = __toESM(require_react(), 1);
+var import_react52 = __toESM(require_react(), 1);
 var MAX_ERRORS = 3;
 var ERROR_WINDOW_MS = 5000;
 
-class ErrorBoundaryInner extends import_react53.default.Component {
+class ErrorBoundaryInner extends import_react52.default.Component {
   state = {
     hasError: false,
     errorTimestamps: [],
@@ -273089,10 +273658,10 @@ class ErrorBoundaryInner extends import_react53.default.Component {
 }
 function ErrorBoundary2({ children }) {
   const { toast } = useToast();
-  const handleError = import_react53.useCallback((message) => {
+  const handleError = import_react52.useCallback((message) => {
     toast(message, "error");
   }, [toast]);
-  return import_react53.default.createElement(ErrorBoundaryInner, { onError: handleError }, children);
+  return import_react52.default.createElement(ErrorBoundaryInner, { onError: handleError }, children);
 }
 
 // src/tui/index.tsx
@@ -273203,16 +273772,16 @@ function ShortcutsDialog({
 }
 
 // src/tui/components/commands/help-dialog.tsx
-var import_react55 = __toESM(require_react(), 1);
+var import_react54 = __toESM(require_react(), 1);
 function HelpDialog() {
   const { colors: colors2 } = useTheme();
   const { commands: commands2 } = useCommand();
   const route = useRoute();
   const dimensions = useTerminalDimensions();
-  const [selectedIndex, setSelectedIndex] = import_react55.useState(0);
-  const [showDetail, setShowDetail] = import_react55.useState(false);
-  const scrollboxRef = import_react55.useRef(null);
-  const commandsByCategory = import_react55.useMemo(() => {
+  const [selectedIndex, setSelectedIndex] = import_react54.useState(0);
+  const [showDetail, setShowDetail] = import_react54.useState(false);
+  const scrollboxRef = import_react54.useRef(null);
+  const commandsByCategory = import_react54.useMemo(() => {
     const grouped = {};
     for (const cmd of commands2) {
       const category = cmd.category || "Other";
@@ -273223,15 +273792,15 @@ function HelpDialog() {
     }
     return grouped;
   }, [commands2]);
-  const flatCommands = import_react55.useMemo(() => {
+  const flatCommands = import_react54.useMemo(() => {
     return commands2;
   }, [commands2]);
-  import_react55.useEffect(() => {
+  import_react54.useEffect(() => {
     if (selectedIndex >= flatCommands.length) {
       setSelectedIndex(Math.max(0, flatCommands.length - 1));
     }
   }, [flatCommands.length, selectedIndex]);
-  import_react55.useEffect(() => {
+  import_react54.useEffect(() => {
     scrollToIndex(scrollboxRef.current, selectedIndex, flatCommands, (cmd) => cmd.name);
   }, [selectedIndex, flatCommands]);
   const handleClose = () => {
@@ -273666,24 +274235,24 @@ function ModelsDisplay() {
 }
 
 // src/tui/components/commands/auth-flow.tsx
-var import_react58 = __toESM(require_react(), 1);
+var import_react57 = __toESM(require_react(), 1);
 init_config2();
 function AuthFlow() {
   const route = useRoute();
   const appConfig = useConfig();
   const isConnected = !!(appConfig.data.accessToken || appConfig.data.pensarAPIKey);
-  const [step, setStep] = import_react58.useState(isConnected ? "success" : "start");
-  const [error, setError] = import_react58.useState(null);
-  const [authMode, setAuthMode] = import_react58.useState(null);
-  const [deviceInfo, setDeviceInfo] = import_react58.useState(null);
-  const [legacyDeviceInfo, setLegacyDeviceInfo] = import_react58.useState(null);
-  const [workspaces, setWorkspaces] = import_react58.useState([]);
-  const [selectedWorkspace, setSelectedWorkspace] = import_react58.useState(null);
-  const [selectedIndex, setSelectedIndex] = import_react58.useState(0);
-  const [billingUrl, setBillingUrl] = import_react58.useState(null);
-  const [balance, setBalance] = import_react58.useState(null);
-  const pollingRef = import_react58.useRef(null);
-  const cancelledRef = import_react58.useRef(false);
+  const [step, setStep] = import_react57.useState(isConnected ? "success" : "start");
+  const [error, setError] = import_react57.useState(null);
+  const [authMode, setAuthMode] = import_react57.useState(null);
+  const [deviceInfo, setDeviceInfo] = import_react57.useState(null);
+  const [legacyDeviceInfo, setLegacyDeviceInfo] = import_react57.useState(null);
+  const [workspaces, setWorkspaces] = import_react57.useState([]);
+  const [selectedWorkspace, setSelectedWorkspace] = import_react57.useState(null);
+  const [selectedIndex, setSelectedIndex] = import_react57.useState(0);
+  const [billingUrl, setBillingUrl] = import_react57.useState(null);
+  const [balance, setBalance] = import_react57.useState(null);
+  const pollingRef = import_react57.useRef(null);
+  const cancelledRef = import_react57.useRef(false);
   const connectedWorkspace = appConfig.data.workspaceSlug ? { name: appConfig.data.workspaceSlug, slug: appConfig.data.workspaceSlug } : null;
   const goHome = () => {
     route.navigate({ type: "base", path: "home" });
@@ -273695,7 +274264,7 @@ function AuthFlow() {
       pollingRef.current = null;
     }
   };
-  import_react58.useEffect(() => {
+  import_react57.useEffect(() => {
     return cleanup;
   }, []);
   const openUrl = (url) => {
@@ -274297,14 +274866,14 @@ function AuthFlow() {
 }
 
 // src/tui/components/commands/credits-flow.tsx
-var import_react60 = __toESM(require_react(), 1);
+var import_react59 = __toESM(require_react(), 1);
 init_tokenRefresh();
 function CreditsFlow() {
   const route = useRoute();
   const appConfig = useConfig();
-  const [step, setStep] = import_react60.useState("loading");
-  const [credits, setCredits] = import_react60.useState(null);
-  const [error, setError] = import_react60.useState(null);
+  const [step, setStep] = import_react59.useState("loading");
+  const [credits, setCredits] = import_react59.useState(null);
+  const [error, setError] = import_react59.useState(null);
   const creditsUrl = `${getPensarConsoleUrl()}/credits`;
   const goHome = () => {
     route.navigate({ type: "base", path: "home" });
@@ -274362,7 +274931,7 @@ function CreditsFlow() {
       setStep("display");
     }
   };
-  import_react60.useEffect(() => {
+  import_react59.useEffect(() => {
     fetchBalance();
   }, []);
   useKeyboard((key) => {
@@ -274601,10 +275170,10 @@ function CreditsFlow() {
 }
 
 // src/tui/context/keybinding.tsx
-var import_react66 = __toESM(require_react(), 1);
+var import_react65 = __toESM(require_react(), 1);
 
 // src/tui/keybindings/keybind.tsx
-var import_react62 = __toESM(require_react(), 1);
+var import_react61 = __toESM(require_react(), 1);
 
 // src/tui/keybindings/actions.ts
 var movementActions = [
@@ -274856,7 +275425,7 @@ var allActions = [
 var actionsByKey = new Map(allActions.map((action) => [action.key, action]));
 var actionsById = new Map(allActions.map((action) => [action.id, action]));
 // src/tui/keybindings/keybind.tsx
-var LeaderKeyContext = import_react62.createContext(null);
+var LeaderKeyContext = import_react61.createContext(null);
 // src/tui/keybindings/registry.ts
 function createKeybindings(deps) {
   const {
@@ -275038,13 +275607,12 @@ function matchesKeybind(pressed, combo) {
 }
 
 // src/tui/context/keybinding.tsx
-var KeybindingContext = import_react66.createContext(undefined);
+var KeybindingContext = import_react65.createContext(undefined);
 function KeybindingProvider({
   children,
   deps
 }) {
   const { promptRef, refocusPrompt } = useFocus();
-  const { isInputEmpty } = useInput();
   const { setExternalDialogOpen } = useDialog();
   const registry = createKeybindings({
     ...deps,
@@ -275060,7 +275628,9 @@ function KeybindingProvider({
           if (binding.combo.toLowerCase().startsWith("shift") || binding.combo.toLowerCase() === "?") {
             const textareaRef = promptRef.current?.getTextareaRef();
             const isInputFocused = textareaRef && !textareaRef.isDestroyed && textareaRef.focused;
-            if (!isInputFocused || !isInputEmpty) {
+            const actualValue = promptRef.current?.getValue() ?? "";
+            const isPromptEmpty = actualValue.trim().length === 0;
+            if (!isInputFocused || !isPromptEmpty) {
               continue;
             }
           }
@@ -275077,10 +275647,10 @@ function KeybindingProvider({
 }
 
 // src/tui/components/pentest/pentest.tsx
-var import_react75 = __toESM(require_react(), 1);
+var import_react74 = __toESM(require_react(), 1);
 init_report();
-import { existsSync as existsSync24, readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync6, readFileSync as readFileSync12 } from "fs";
+import { join as join26 } from "path";
 
 // src/core/session/loader.ts
 init_persistence();
@@ -275217,7 +275787,7 @@ Found ${findings.length} vulnerabilities`);
 init_utils2();
 
 // src/tui/components/agent-display.tsx
-var import_react73 = __toESM(require_react(), 1);
+var import_react72 = __toESM(require_react(), 1);
 
 // node_modules/marked/lib/marked.esm.js
 function L2() {
@@ -276620,7 +277190,11 @@ var TOOL_SUMMARY_MAP = {
     return `${method} ${url2}`;
   },
   crawl: (args) => `crawl ${args.url || args.target || ""}`,
-  execute_command: (args) => `$ ${args.command || ""}`,
+  execute_command: (args) => {
+    const cmd = String(args.command || "").split(`
+`)[0];
+    return cmd.length > 80 ? `$ ${cmd.slice(0, 80)}…` : `$ ${cmd}`;
+  },
   read_file: (args) => `read ${args.path || ""}`,
   Read: (args) => `read ${args.path || args.file_path || ""}`,
   write_file: (args) => `write ${args.path || ""}`,
@@ -276656,6 +277230,7 @@ var TOOL_SUMMARY_MAP = {
     const targets = args.targets;
     return `pentest swarm ×${targets?.length ?? "?"}`;
   },
+  delegate_to_auth_subagent: (args) => `auth ${args.target || ""} — ${args.reason || ""}`,
   scratchpad: () => "note"
 };
 function getToolSummary(toolName, args) {
@@ -277343,14 +277918,14 @@ ${preview}${suffix}` : preview + suffix || "POC passed",
   return null;
 }
 // src/tui/components/shared/ascii-spinner.tsx
-var import_react67 = __toESM(require_react(), 1);
+var import_react66 = __toESM(require_react(), 1);
 var SPINNER_FRAMES = ["/", "-", "\\", "|"];
 var SPINNER_INTERVAL = 100;
 function AsciiSpinner({ label, fg: fg2 }) {
   const { colors: colors2 } = useTheme();
   const spinnerColor = fg2 ?? colors2.info;
-  const [frame, setFrame] = import_react67.useState(0);
-  import_react67.useEffect(() => {
+  const [frame, setFrame] = import_react66.useState(0);
+  import_react66.useEffect(() => {
     const interval = setInterval(() => {
       setFrame((f3) => (f3 + 1) % SPINNER_FRAMES.length);
     }, SPINNER_INTERVAL);
@@ -277362,20 +277937,21 @@ function AsciiSpinner({ label, fg: fg2 }) {
   }, undefined, false, undefined, this);
 }
 // src/tui/components/shared/tool-renderer.tsx
-var import_react68 = __toESM(require_react(), 1);
+var import_react67 = __toESM(require_react(), 1);
 var TOOLS_WITH_LOG_WINDOW = new Set([
   "execute_command",
   "run_attack_surface",
   "spawn_coding_agent",
-  "spawn_pentest_swarm"
+  "spawn_pentest_swarm",
+  "delegate_to_auth_subagent"
 ]);
-var ToolRenderer = import_react68.memo(function ToolRenderer2({
+var ToolRenderer = import_react67.memo(function ToolRenderer2({
   message,
   verbose = false,
   expandedLogs = false
 }) {
   const { colors: colors2 } = useTheme();
-  const [showOutput, setShowOutput] = import_react68.useState(false);
+  const [showOutput, setShowOutput] = import_react67.useState(false);
   if (!isToolMessage(message)) {
     return null;
   }
@@ -277504,8 +278080,8 @@ var ToolRenderer = import_react68.memo(function ToolRenderer2({
   }, undefined, true, undefined, this);
 });
 // src/tui/components/shared/message-renderer.tsx
-var import_react69 = __toESM(require_react(), 1);
-var MessageRenderer = import_react69.memo(function MessageRenderer2({
+var import_react68 = __toESM(require_react(), 1);
+var MessageRenderer = import_react68.memo(function MessageRenderer2({
   message,
   isStreaming = false,
   verbose = false,
@@ -277515,7 +278091,7 @@ var MessageRenderer = import_react69.memo(function MessageRenderer2({
 }) {
   const { colors: colors2 } = useTheme();
   const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
-  const displayContent = import_react69.useMemo(() => message.role === "assistant" ? markdownToStyledText(content, colors2) : content, [content, message.role, colors2]);
+  const displayContent = import_react68.useMemo(() => message.role === "assistant" ? markdownToStyledText(content, colors2) : content, [content, message.role, colors2]);
   if (isToolMessage(message)) {
     return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(ToolRenderer, {
       message,
@@ -277627,9 +278203,9 @@ var MessageRenderer = import_react69.memo(function MessageRenderer2({
   }, undefined, false, undefined, this);
 });
 // src/tui/components/shared/approval-prompt.tsx
-var import_react70 = __toESM(require_react(), 1);
+var import_react69 = __toESM(require_react(), 1);
 // src/tui/components/shared/message-reducer.ts
-var import_react72 = __toESM(require_react(), 1);
+var import_react71 = __toESM(require_react(), 1);
 // src/tui/components/agent-display.tsx
 function getStableKey(item, contextId = "root") {
   if ("messages" in item) {
@@ -277705,11 +278281,11 @@ function AgentDisplay({
     ]
   }, undefined, true, undefined, this);
 }
-var SubAgentDisplay = import_react73.memo(function SubAgentDisplay2({
+var SubAgentDisplay = import_react72.memo(function SubAgentDisplay2({
   subagent
 }) {
   const { colors: colors2 } = useTheme();
-  const [open, setOpen] = import_react73.useState(false);
+  const [open, setOpen] = import_react72.useState(false);
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
     height: open ? 40 : "auto",
     onMouseDown: () => setOpen(!open),
@@ -277764,7 +278340,7 @@ var SubAgentDisplay = import_react73.memo(function SubAgentDisplay2({
     ]
   }, undefined, true, undefined, this);
 });
-var AgentMessage = import_react73.memo(function AgentMessage2({
+var AgentMessage = import_react72.memo(function AgentMessage2({
   message
 }) {
   const { colors: colors2 } = useTheme();
@@ -277873,8 +278449,8 @@ var AgentMessage = import_react73.memo(function AgentMessage2({
 });
 function ToolDetails({ message }) {
   const { colors: colors2 } = useTheme();
-  const [showArgs, setShowArgs] = import_react73.useState(false);
-  const [showResult, setShowResult] = import_react73.useState(false);
+  const [showArgs, setShowArgs] = import_react72.useState(false);
+  const [showResult, setShowResult] = import_react72.useState(false);
   if (message.role !== "tool") {
     return null;
   }
@@ -277976,28 +278552,28 @@ function Pentest({ sessionId }) {
   const config3 = useConfig();
   const { model, setThinking, setIsExecuting, isExecuting } = useAgent();
   const { stack, externalDialogOpen } = useDialog();
-  const [session, setSession] = import_react75.useState(null);
-  const [error40, setError] = import_react75.useState(null);
-  const [phase, setPhase] = import_react75.useState("loading");
-  const [abortController, setAbortController] = import_react75.useState(null);
-  const [panelMessages, setPanelMessages] = import_react75.useState([]);
-  const panelTextRef = import_react75.useRef("");
-  const panelSourceRef = import_react75.useRef(null);
-  const [pentestAgents, setPentestAgents] = import_react75.useState({});
-  const pentestTextRefs = import_react75.useRef({});
-  const [assets, setAssets] = import_react75.useState([]);
-  const [viewMode, setViewMode] = import_react75.useState("overview");
-  const [selectedAgentId, setSelectedAgentId] = import_react75.useState(null);
-  const [focusedIndex, setFocusedIndex] = import_react75.useState(0);
-  const [showOrchestratorPanel, setShowOrchestratorPanel] = import_react75.useState(false);
-  const [startTime, setStartTime] = import_react75.useState(null);
-  const pentestAgentList = import_react75.useMemo(() => Object.values(pentestAgents).sort((a, b3) => a.createdAt.getTime() - b3.createdAt.getTime()), [pentestAgents]);
-  const selectedAgent = import_react75.useMemo(() => selectedAgentId ? pentestAgents[selectedAgentId] ?? null : null, [pentestAgents, selectedAgentId]);
+  const [session, setSession] = import_react74.useState(null);
+  const [error40, setError] = import_react74.useState(null);
+  const [phase, setPhase] = import_react74.useState("loading");
+  const [abortController, setAbortController] = import_react74.useState(null);
+  const [panelMessages, setPanelMessages] = import_react74.useState([]);
+  const panelTextRef = import_react74.useRef("");
+  const panelSourceRef = import_react74.useRef(null);
+  const [pentestAgents, setPentestAgents] = import_react74.useState({});
+  const pentestTextRefs = import_react74.useRef({});
+  const [assets, setAssets] = import_react74.useState([]);
+  const [viewMode, setViewMode] = import_react74.useState("overview");
+  const [selectedAgentId, setSelectedAgentId] = import_react74.useState(null);
+  const [focusedIndex, setFocusedIndex] = import_react74.useState(0);
+  const [showOrchestratorPanel, setShowOrchestratorPanel] = import_react74.useState(false);
+  const [startTime, setStartTime] = import_react74.useState(null);
+  const pentestAgentList = import_react74.useMemo(() => Object.values(pentestAgents).sort((a, b3) => a.createdAt.getTime() - b3.createdAt.getTime()), [pentestAgents]);
+  const selectedAgent = import_react74.useMemo(() => selectedAgentId ? pentestAgents[selectedAgentId] ?? null : null, [pentestAgents, selectedAgentId]);
   const { width: termWidth } = useTerminalDimensions();
   const gridAvailableWidth = showOrchestratorPanel ? Math.floor((termWidth - 4) / 2) - 2 : termWidth - ORCHESTRATOR_PANEL_WIDTH - GRID_OUTER_PADDING;
   const gridColumns = Math.max(1, Math.floor((gridAvailableWidth + GRID_GAP) / (CARD_MIN_WIDTH + GRID_GAP)));
-  import_react75.useEffect(() => {
-    async function load() {
+  import_react74.useEffect(() => {
+    async function load2() {
       try {
         const s2 = await sessions.get(sessionId);
         if (!s2) {
@@ -278041,21 +278617,21 @@ function Pentest({ sessionId }) {
         setPhase("error");
       }
     }
-    load();
+    load2();
   }, [sessionId]);
-  import_react75.useEffect(() => {
+  import_react74.useEffect(() => {
     if (!session)
       return;
-    const assetsPath = join25(session.rootPath, "assets");
+    const assetsPath = join26(session.rootPath, "assets");
     function readAssets() {
-      if (!existsSync24(assetsPath))
+      if (!existsSync25(assetsPath))
         return;
       try {
         const files = readdirSync6(assetsPath).filter((f3) => f3.endsWith(".json"));
         const loaded = [];
         for (const file2 of files) {
           try {
-            const content = readFileSync11(join25(assetsPath, file2), "utf-8");
+            const content = readFileSync12(join26(assetsPath, file2), "utf-8");
             loaded.push(JSON.parse(content));
           } catch {}
         }
@@ -278066,12 +278642,12 @@ function Pentest({ sessionId }) {
     const interval = setInterval(readAssets, 2000);
     return () => clearInterval(interval);
   }, [session]);
-  import_react75.useEffect(() => {
+  import_react74.useEffect(() => {
     return () => {
       abortController?.abort();
     };
   }, [abortController]);
-  const ensurePentestAgent = import_react75.useCallback((subagentId) => {
+  const ensurePentestAgent = import_react74.useCallback((subagentId) => {
     setPentestAgents((prev) => {
       if (prev[subagentId])
         return prev;
@@ -278088,7 +278664,7 @@ function Pentest({ sessionId }) {
       };
     });
   }, []);
-  const handleSubagentSpawn = import_react75.useCallback(({
+  const handleSubagentSpawn = import_react74.useCallback(({
     subagentId,
     input
   }) => {
@@ -278108,7 +278684,7 @@ function Pentest({ sessionId }) {
       }
     }));
   }, []);
-  const handleSubagentComplete = import_react75.useCallback(({ subagentId, status }) => {
+  const handleSubagentComplete = import_react74.useCallback(({ subagentId, status }) => {
     if (!subagentId.startsWith("pentest-agent-"))
       return;
     setPentestAgents((prev) => {
@@ -278121,7 +278697,7 @@ function Pentest({ sessionId }) {
       };
     });
   }, []);
-  const appendPanelText = import_react75.useCallback((source, text2) => {
+  const appendPanelText = import_react74.useCallback((source, text2) => {
     if (panelSourceRef.current !== source) {
       panelTextRef.current = "";
       panelSourceRef.current = source;
@@ -278146,7 +278722,7 @@ function Pentest({ sessionId }) {
       ];
     });
   }, []);
-  const appendPentestText = import_react75.useCallback((subagentId, text2) => {
+  const appendPentestText = import_react74.useCallback((subagentId, text2) => {
     ensurePentestAgent(subagentId);
     if (!pentestTextRefs.current[subagentId]) {
       pentestTextRefs.current[subagentId] = "";
@@ -278179,7 +278755,7 @@ function Pentest({ sessionId }) {
       };
     });
   }, [ensurePentestAgent]);
-  const addPanelToolCall = import_react75.useCallback((toolCallId, toolName, args) => {
+  const addPanelToolCall = import_react74.useCallback((toolCallId, toolName, args) => {
     panelTextRef.current = "";
     panelSourceRef.current = null;
     const description = typeof args?.toolCallDescription === "string" ? args.toolCallDescription : toolName;
@@ -278198,7 +278774,7 @@ function Pentest({ sessionId }) {
       return [...prev, msg];
     });
   }, []);
-  const addPentestToolCall = import_react75.useCallback((subagentId, toolCallId, toolName, args) => {
+  const addPentestToolCall = import_react74.useCallback((subagentId, toolCallId, toolName, args) => {
     pentestTextRefs.current[subagentId] = "";
     ensurePentestAgent(subagentId);
     const description = typeof args?.toolCallDescription === "string" ? args.toolCallDescription : toolName;
@@ -278243,12 +278819,12 @@ function Pentest({ sessionId }) {
       }
     ];
   };
-  const updatePanelToolResult = import_react75.useCallback((toolCallId, toolName, result) => {
+  const updatePanelToolResult = import_react74.useCallback((toolCallId, toolName, result) => {
     panelTextRef.current = "";
     panelSourceRef.current = null;
     setPanelMessages((prev) => toolResultUpdater(prev, toolCallId, toolName, result));
   }, []);
-  const updatePentestToolResult = import_react75.useCallback((subagentId, toolCallId, toolName, result) => {
+  const updatePentestToolResult = import_react74.useCallback((subagentId, toolCallId, toolName, result) => {
     pentestTextRefs.current[subagentId] = "";
     setPentestAgents((prev) => {
       const agent = prev[subagentId];
@@ -278263,7 +278839,7 @@ function Pentest({ sessionId }) {
       };
     });
   }, []);
-  const startPentest = import_react75.useCallback(async (s2) => {
+  const startPentest = import_react74.useCallback(async (s2) => {
     setPhase("discovery");
     setStartTime(new Date);
     setIsExecuting(true);
@@ -278360,7 +278936,7 @@ function Pentest({ sessionId }) {
     handleSubagentSpawn,
     handleSubagentComplete
   ]);
-  import_react75.useEffect(() => {
+  import_react74.useEffect(() => {
     if (phase === "completed") {
       setFocusedIndex(pentestAgentList.length);
     }
@@ -278423,7 +278999,7 @@ function Pentest({ sessionId }) {
       }
     }
   });
-  const openReport = import_react75.useCallback(() => {
+  const openReport = import_react74.useCallback(() => {
     if (!session)
       return;
     const err = openSessionReport(session.rootPath);
@@ -278608,7 +279184,7 @@ function OrchestratorPanel({
 }) {
   const { colors: colors2 } = useTheme();
   const isRunning = phase !== "loading" && phase !== "completed" && phase !== "error";
-  const assetSummary = import_react75.useMemo(() => {
+  const assetSummary = import_react74.useMemo(() => {
     const byType = {};
     for (const a of assets) {
       const key = a.assetType;
@@ -278851,13 +279427,13 @@ function AgentCardGrid({
   onSelectAgent
 }) {
   const { colors: colors2 } = useTheme();
-  const scrollRef = import_react75.useRef(null);
-  import_react75.useEffect(() => {
+  const scrollRef = import_react74.useRef(null);
+  import_react74.useEffect(() => {
     const agent = agents[focusedIndex];
     if (agent)
       scrollToChild(scrollRef.current, agent.id);
   }, [focusedIndex, agents]);
-  const rows = import_react75.useMemo(() => {
+  const rows = import_react74.useMemo(() => {
     const result = [];
     for (let i2 = 0;i2 < agents.length; i2 += gridColumns) {
       result.push(agents.slice(i2, i2 + gridColumns));
@@ -278914,14 +279490,14 @@ function AgentCard({
     completed: colors2.primary,
     failed: colors2.error
   }[agent.status];
-  const lastActivity = import_react75.useMemo(() => {
+  const lastActivity = import_react74.useMemo(() => {
     const last = agent.messages[agent.messages.length - 1];
     if (!last)
       return "Starting...";
     const text2 = typeof last.content === "string" ? last.content.replace(/\n/g, " ").trim() : "Working...";
     return text2.length > 50 ? text2.substring(0, 47) + "..." : text2;
   }, [agent.messages]);
-  const toolCalls = import_react75.useMemo(() => agent.messages.filter((m4) => m4.role === "tool").length, [agent.messages]);
+  const toolCalls = import_react74.useMemo(() => agent.messages.filter((m4) => m4.role === "tool").length, [agent.messages]);
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
     id: agent.id,
     flexGrow: 1,
@@ -279109,8 +279685,8 @@ function MetricsBar({
   isExecuting
 }) {
   const { colors: colors2 } = useTheme();
-  const [now2, setNow] = import_react75.useState(Date.now());
-  import_react75.useEffect(() => {
+  const [now2, setNow] = import_react74.useState(Date.now());
+  import_react74.useEffect(() => {
     if (!isExecuting)
       return;
     const interval = setInterval(() => setNow(Date.now()), 1000);
@@ -279253,7 +279829,7 @@ function MetricsBar({
 }
 
 // src/tui/components/operator-dashboard/index.tsx
-var import_react80 = __toESM(require_react(), 1);
+var import_react79 = __toESM(require_react(), 1);
 
 // src/core/api/offesecAgent.ts
 init_offensiveSecurityAgent();
@@ -279352,7 +279928,7 @@ function InlineApprovalPrompt2({ approval }) {
 }
 
 // src/tui/components/chat/loading-indicator.tsx
-var import_react77 = __toESM(require_react(), 1);
+var import_react76 = __toESM(require_react(), 1);
 var SPINNER_FRAMES2 = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 var SPINNER_INTERVAL2 = 80;
 var DOTS_FRAMES = ["", ".", "..", "..."];
@@ -279363,15 +279939,15 @@ function LoadingIndicator({
   toolName
 }) {
   const { colors: colors2 } = useTheme();
-  const [spinnerFrame, setSpinnerFrame] = import_react77.useState(0);
-  const [dotsFrame, setDotsFrame] = import_react77.useState(0);
-  import_react77.useEffect(() => {
+  const [spinnerFrame, setSpinnerFrame] = import_react76.useState(0);
+  const [dotsFrame, setDotsFrame] = import_react76.useState(0);
+  import_react76.useEffect(() => {
     const interval = setInterval(() => {
       setSpinnerFrame((f3) => (f3 + 1) % SPINNER_FRAMES2.length);
     }, SPINNER_INTERVAL2);
     return () => clearInterval(interval);
   }, []);
-  import_react77.useEffect(() => {
+  import_react76.useEffect(() => {
     const interval = setInterval(() => {
       setDotsFrame((f3) => (f3 + 1) % DOTS_FRAMES.length);
     }, DOTS_INTERVAL);
@@ -279625,7 +280201,7 @@ function MessageList({
 }
 
 // src/tui/components/chat/input-area.tsx
-var import_react78 = __toESM(require_react(), 1);
+var import_react77 = __toESM(require_react(), 1);
 function NormalInputAreaInner({
   value,
   onChange,
@@ -279640,21 +280216,22 @@ function NormalInputAreaInner({
   enableAutocomplete = false,
   autocompleteOptions = [],
   enableCommands = false,
-  onCommandExecute
+  onCommandExecute,
+  commandHistory = []
 }) {
   const { colors: colors2 } = useTheme();
   const { inputValue, setInputValue } = useInput();
-  const promptRef = import_react78.useRef(null);
-  const isExternalUpdate = import_react78.useRef(false);
+  const promptRef = import_react77.useRef(null);
+  const isExternalUpdate = import_react77.useRef(false);
   const isDisabled = status === "running";
-  import_react78.useEffect(() => {
+  import_react77.useEffect(() => {
     if (value !== inputValue) {
       isExternalUpdate.current = true;
       setInputValue(value);
       promptRef.current?.setValue(value);
     }
   }, [value]);
-  import_react78.useEffect(() => {
+  import_react77.useEffect(() => {
     if (isExternalUpdate.current) {
       isExternalUpdate.current = false;
       return;
@@ -279698,7 +280275,8 @@ function NormalInputAreaInner({
             enableAutocomplete,
             autocompleteOptions,
             enableCommands,
-            onCommandExecute
+            onCommandExecute,
+            commandHistory
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
@@ -279784,6 +280362,7 @@ function InputArea(props) {
     autocompleteOptions,
     enableCommands,
     onCommandExecute,
+    commandHistory,
     ...normalProps
   } = props;
   if (pendingApproval) {
@@ -279806,6 +280385,7 @@ function InputArea(props) {
       autocompleteOptions,
       enableCommands,
       onCommandExecute,
+      commandHistory,
       ...normalProps
     }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
@@ -279820,7 +280400,7 @@ function ApprovalInputArea2({
   lastDeclineNote
 }) {
   const { colors: colors2 } = useTheme();
-  const [focusedElement, setFocusedElement] = import_react78.useState(0);
+  const [focusedElement, setFocusedElement] = import_react77.useState(0);
   useKeyboard((key) => {
     if (key.name === "up") {
       setFocusedElement((prev) => Math.max(0, prev - 1));
@@ -279933,6 +280513,7 @@ function ApprovalInputArea2({
 
 // src/tui/components/operator-dashboard/index.tsx
 init_operator();
+init_execution_metrics();
 init_dist5();
 
 // src/tui/components/operator-dashboard/keyboard.ts
@@ -279948,8 +280529,8 @@ function shouldHandleOperatorCtrlC(key, status, inputValue) {
 }
 
 // src/tui/components/operator-dashboard/index.tsx
-import { existsSync as existsSync25, readFileSync as readFileSync12 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync13 } from "fs";
+import { join as join27 } from "path";
 function OperatorDashboard({
   sessionId,
   initialMessage,
@@ -279958,7 +280539,16 @@ function OperatorDashboard({
   const { colors: colors2 } = useTheme();
   const route = useRoute();
   const config3 = useConfig();
-  const { model, setModel, isModelUserSelected, setThinking, setIsExecuting } = useAgent();
+  const {
+    model,
+    setModel,
+    isModelUserSelected,
+    setThinking,
+    setIsExecuting,
+    tokenUsage,
+    addTokenUsage,
+    resetTokenUsage
+  } = useAgent();
   const {
     autocompleteOptions: allAutocompleteOptions,
     executeCommand: executeCommand2,
@@ -279972,32 +280562,40 @@ function OperatorDashboard({
     clear: clearDialog,
     setSize: setDialogSize
   } = useDialog();
-  const autocompleteOptions = import_react80.useMemo(() => {
+  const autocompleteOptions = import_react79.useMemo(() => {
     const allowedCommands = new Set(["/create-skill", "/models"]);
     const skillSlugs = new Set(skills.map((s2) => `/${slugify(s2.name)}`));
     return allAutocompleteOptions.filter((opt) => allowedCommands.has(opt.value) || skillSlugs.has(opt.value));
   }, [allAutocompleteOptions, skills]);
-  const [session, setSession] = import_react80.useState(null);
-  const [loading, setLoading] = import_react80.useState(true);
-  const [error40, setError] = import_react80.useState(null);
-  const [status, setStatus] = import_react80.useState("idle");
-  const abortControllerRef = import_react80.useRef(null);
-  const generationRef = import_react80.useRef(0);
-  const cancelHandleRef = import_react80.useRef({
+  const [session, setSession] = import_react79.useState(null);
+  const [loading, setLoading] = import_react79.useState(true);
+  const [error40, setError] = import_react79.useState(null);
+  const [status, setStatus] = import_react79.useState("idle");
+  const abortControllerRef = import_react79.useRef(null);
+  const generationRef = import_react79.useRef(0);
+  const cancelHandleRef = import_react79.useRef({
     cancel: () => false
   });
-  const commandCancelledRef = import_react80.useRef(false);
-  const [messages, setMessages] = import_react80.useState([]);
-  const textRef = import_react80.useRef("");
-  const conversationRef = import_react80.useRef([]);
-  const [inputValue, setInputValue] = import_react80.useState("");
-  const [operatorState, setOperatorState] = import_react80.useState(() => createInitialOperatorState("manual", true));
-  const approvalGateRef = import_react80.useRef(new ApprovalGate({ requireApproval: true }));
-  const [pendingApprovals, setPendingApprovals] = import_react80.useState([]);
-  const [lastApprovedAction, setLastApprovedAction] = import_react80.useState(null);
-  const [verboseMode, setVerboseMode] = import_react80.useState(false);
-  const [expandedLogs, setExpandedLogs] = import_react80.useState(false);
-  import_react80.useEffect(() => {
+  const commandCancelledRef = import_react79.useRef(false);
+  const [messages, setMessages] = import_react79.useState([]);
+  const textRef = import_react79.useRef("");
+  const conversationRef = import_react79.useRef([]);
+  const [inputValue, setInputValue] = import_react79.useState("");
+  const [commandHistory, setCommandHistory] = import_react79.useState(getEntries);
+  import_react79.useEffect(() => {
+    load().then(setCommandHistory);
+  }, []);
+  const [operatorState, setOperatorState] = import_react79.useState(() => createInitialOperatorState("manual", true));
+  const approvalGateRef = import_react79.useRef(new ApprovalGate({ requireApproval: true }));
+  const [pendingApprovals, setPendingApprovals] = import_react79.useState([]);
+  const [lastApprovedAction, setLastApprovedAction] = import_react79.useState(null);
+  const [verboseMode, setVerboseMode] = import_react79.useState(false);
+  const [expandedLogs, setExpandedLogs] = import_react79.useState(false);
+  const tokenUsageRef = import_react79.useRef(tokenUsage);
+  import_react79.useEffect(() => {
+    tokenUsageRef.current = tokenUsage;
+  }, [tokenUsage]);
+  import_react79.useEffect(() => {
     const gate = approvalGateRef.current;
     const onApprovalNeeded = () => {
       setPendingApprovals(gate.getPendingApprovals());
@@ -280019,7 +280617,7 @@ function OperatorDashboard({
       gate.off("approval-resolved", onApprovalResolved);
     };
   }, []);
-  import_react80.useEffect(() => {
+  import_react79.useEffect(() => {
     async function loadSession() {
       try {
         let s2;
@@ -280092,7 +280690,25 @@ function OperatorDashboard({
     }
     loadSession();
   }, [sessionId]);
-  const appendText = import_react80.useCallback((text2) => {
+  import_react79.useEffect(() => {
+    if (!session)
+      return;
+    resetTokenUsage();
+    tokenUsageRef.current = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    const metrics = readExecutionMetrics(session.rootPath);
+    const persisted = metrics?.tokenUsage;
+    if (persisted && (persisted.inputTokens > 0 || persisted.outputTokens > 0)) {
+      addTokenUsage(persisted.inputTokens, persisted.outputTokens);
+      tokenUsageRef.current = persisted;
+    }
+    try {
+      writeExecutionMetrics({
+        sessionRootPath: session.rootPath,
+        tokenUsage: tokenUsageRef.current
+      });
+    } catch {}
+  }, [session, addTokenUsage, resetTokenUsage]);
+  const appendText = import_react79.useCallback((text2) => {
     textRef.current += text2;
     const accumulated = textRef.current;
     setMessages((prev) => {
@@ -280108,7 +280724,7 @@ function OperatorDashboard({
       ];
     });
   }, []);
-  const addToolCall = import_react80.useCallback((toolCallId, toolName, args) => {
+  const addToolCall = import_react79.useCallback((toolCallId, toolName, args) => {
     textRef.current = "";
     setMessages((prev) => [
       ...prev,
@@ -280123,7 +280739,7 @@ function OperatorDashboard({
       }
     ]);
   }, []);
-  const updateToolResult = import_react80.useCallback((toolCallId, _toolName, result) => {
+  const updateToolResult = import_react79.useCallback((toolCallId, _toolName, result) => {
     textRef.current = "";
     setMessages((prev) => {
       const idx = prev.findIndex((m4) => isToolMessage(m4) && m4.toolCallId === toolCallId);
@@ -280134,10 +280750,10 @@ function OperatorDashboard({
       return updated;
     });
   }, []);
-  const cmdOutputBufRef = import_react80.useRef("");
-  const cmdFlushTimerRef = import_react80.useRef(null);
+  const cmdOutputBufRef = import_react79.useRef("");
+  const cmdFlushTimerRef = import_react79.useRef(null);
   const MAX_LOG_LINES = 200;
-  const flushCommandOutput = import_react80.useCallback(() => {
+  const flushCommandOutput = import_react79.useCallback(() => {
     const buf = cmdOutputBufRef.current;
     if (!buf)
       return;
@@ -280167,7 +280783,7 @@ function OperatorDashboard({
       return updated;
     });
   }, []);
-  const onCommandOutput = import_react80.useCallback((data) => {
+  const onCommandOutput = import_react79.useCallback((data) => {
     cmdOutputBufRef.current += data;
     if (!cmdFlushTimerRef.current) {
       cmdFlushTimerRef.current = setInterval(() => {
@@ -280175,7 +280791,7 @@ function OperatorDashboard({
       }, 150);
     }
   }, [flushCommandOutput]);
-  import_react80.useEffect(() => {
+  import_react79.useEffect(() => {
     return () => {
       if (cmdFlushTimerRef.current) {
         clearInterval(cmdFlushTimerRef.current);
@@ -280183,7 +280799,7 @@ function OperatorDashboard({
       }
     };
   }, []);
-  const appendLogToActiveTool = import_react80.useCallback((line) => {
+  const appendLogToActiveTool = import_react79.useCallback((line) => {
     setMessages((prev) => {
       const idx = prev.findLastIndex((m4) => isToolMessage(m4) && m4.status === "pending");
       if (idx === -1)
@@ -280198,13 +280814,13 @@ function OperatorDashboard({
       return updated;
     });
   }, []);
-  const handleApprove = import_react80.useCallback(() => {
+  const handleApprove = import_react79.useCallback(() => {
     const pending = approvalGateRef.current.getPendingApprovals();
     if (pending.length > 0) {
       approvalGateRef.current.approve(pending[0].id);
     }
   }, []);
-  const handleAutoApprove = import_react80.useCallback(() => {
+  const handleAutoApprove = import_react79.useCallback(() => {
     approvalGateRef.current.updateConfig({ requireApproval: false });
     setOperatorState((prev) => ({ ...prev, requireApproval: false }));
     const pending = approvalGateRef.current.getPendingApprovals();
@@ -280212,7 +280828,7 @@ function OperatorDashboard({
       approvalGateRef.current.approve(p.id);
     }
   }, []);
-  const runAgent = import_react80.useCallback(async (prompt) => {
+  const runAgent = import_react79.useCallback(async (prompt) => {
     if (!session)
       return;
     if (abortControllerRef.current) {
@@ -280250,6 +280866,25 @@ function OperatorDashboard({
         authConfig: buildAuthConfig(config3.data),
         approvalGate: approvalGateRef.current,
         commandCancelHandle: cancelHandleRef.current,
+        onStepFinish: (event) => {
+          const inputTokens = event.usage?.inputTokens ?? 0;
+          const outputTokens = event.usage?.outputTokens ?? 0;
+          if (inputTokens <= 0 && outputTokens <= 0)
+            return;
+          const nextUsage = {
+            inputTokens: tokenUsageRef.current.inputTokens + inputTokens,
+            outputTokens: tokenUsageRef.current.outputTokens + outputTokens,
+            totalTokens: tokenUsageRef.current.totalTokens + inputTokens + outputTokens
+          };
+          tokenUsageRef.current = nextUsage;
+          addTokenUsage(inputTokens, outputTokens);
+          try {
+            writeExecutionMetrics({
+              sessionRootPath: session.rootPath,
+              tokenUsage: nextUsage
+            });
+          } catch {}
+        },
         callbacks: {
           onTextDelta: (d3) => {
             setThinking(false);
@@ -280345,6 +280980,7 @@ function OperatorDashboard({
     model.id,
     config3.data,
     operatorState,
+    addTokenUsage,
     appendText,
     addToolCall,
     updateToolResult,
@@ -280354,7 +280990,7 @@ function OperatorDashboard({
     setThinking,
     setIsExecuting
   ]);
-  const handleSubmit = import_react80.useCallback((value) => {
+  const handleSubmit = import_react79.useCallback((value) => {
     if (!value.trim())
       return;
     const pending = approvalGateRef.current.getPendingApprovals();
@@ -280365,19 +281001,21 @@ function OperatorDashboard({
     }
     if (status === "running")
       return;
+    const trimmed = value.trim();
+    push(trimmed).then(() => setCommandHistory([...getEntries()]));
     setInputValue("");
-    runAgent(value.trim());
+    runAgent(trimmed);
   }, [status, runAgent]);
-  const initialMessageSentRef = import_react80.useRef(false);
-  const runAgentRef = import_react80.useRef(runAgent);
+  const initialMessageSentRef = import_react79.useRef(false);
+  const runAgentRef = import_react79.useRef(runAgent);
   runAgentRef.current = runAgent;
-  import_react80.useEffect(() => {
+  import_react79.useEffect(() => {
     if (!loading && session && initialMessage && !initialMessageSentRef.current) {
       initialMessageSentRef.current = true;
       runAgentRef.current(initialMessage);
     }
   }, [loading, session, initialMessage]);
-  const showModelPicker = import_react80.useCallback(() => {
+  const showModelPicker = import_react79.useCallback(() => {
     setDialogSize("large");
     showDialog(/* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
       flexDirection: "column",
@@ -280439,7 +281077,7 @@ function OperatorDashboard({
     clearDialog,
     setDialogSize
   ]);
-  const handleCommandExecute = import_react80.useCallback(async (command) => {
+  const handleCommandExecute = import_react79.useCallback(async (command) => {
     const commandLower = command.trim().replace(/^\/+/, "").toLowerCase();
     if (commandLower === "models" || commandLower === "model") {
       showModelPicker();
@@ -280458,7 +281096,7 @@ function OperatorDashboard({
     }
     await executeCommand2(command);
   }, [resolveSkillContent, handleSubmit, executeCommand2, showModelPicker]);
-  const handleAbort = import_react80.useCallback(() => {
+  const handleAbort = import_react79.useCallback(() => {
     if (!abortControllerRef.current)
       return;
     if (!commandCancelledRef.current && cancelHandleRef.current.cancel()) {
@@ -280483,9 +281121,9 @@ function OperatorDashboard({
     approvalGateRef.current.denyAll();
     if (session) {
       try {
-        const messagesPath = join26(session.rootPath, "messages.json");
-        if (existsSync25(messagesPath)) {
-          const raw = JSON.parse(readFileSync12(messagesPath, "utf-8"));
+        const messagesPath = join27(session.rootPath, "messages.json");
+        if (existsSync26(messagesPath)) {
+          const raw = JSON.parse(readFileSync13(messagesPath, "utf-8"));
           if (Array.isArray(raw) && raw.length > 0) {
             conversationRef.current = raw;
           }
@@ -280504,7 +281142,7 @@ function OperatorDashboard({
       ];
     });
   }, [session, setThinking, setIsExecuting]);
-  const toggleApproval = import_react80.useCallback(() => {
+  const toggleApproval = import_react79.useCallback(() => {
     setOperatorState((prev) => {
       const newVal = !prev.requireApproval;
       approvalGateRef.current.updateConfig({ requireApproval: newVal });
@@ -280686,7 +281324,8 @@ function OperatorDashboard({
         enableAutocomplete: true,
         autocompleteOptions,
         enableCommands: true,
-        onCommandExecute: handleCommandExecute
+        onCommandExecute: handleCommandExecute,
+        commandHistory
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
@@ -280717,7 +281356,7 @@ Session paths:
 }
 
 // src/tui/components/commands/theme-picker.tsx
-var import_react82 = __toESM(require_react(), 1);
+var import_react81 = __toESM(require_react(), 1);
 init_config2();
 function ThemePicker() {
   const dimensions = useTerminalDimensions();
@@ -280731,15 +281370,15 @@ function ThemePicker() {
     toggleMode,
     setMode
   } = useTheme();
-  const [selectedIndex, setSelectedIndex] = import_react82.useState(() => Math.max(0, availableThemes.indexOf(theme.name)));
-  const originalThemeRef = import_react82.useRef(theme.name);
-  const originalModeRef = import_react82.useRef(mode);
-  const handleClose = import_react82.useCallback(() => {
+  const [selectedIndex, setSelectedIndex] = import_react81.useState(() => Math.max(0, availableThemes.indexOf(theme.name)));
+  const originalThemeRef = import_react81.useRef(theme.name);
+  const originalModeRef = import_react81.useRef(mode);
+  const handleClose = import_react81.useCallback(() => {
     setTheme(originalThemeRef.current);
     setMode(originalModeRef.current);
     route.navigate({ type: "base", path: "home" });
   }, [setTheme, setMode, route]);
-  const handleConfirm = import_react82.useCallback(async () => {
+  const handleConfirm = import_react81.useCallback(async () => {
     const currentThemeName = availableThemes[selectedIndex];
     if (currentThemeName) {
       await config.update({ theme: currentThemeName });
@@ -280882,16 +281521,16 @@ function ThemePicker() {
 }
 
 // src/tui/components/commands/create-skill-wizard.tsx
-var import_react84 = __toESM(require_react(), 1);
+var import_react83 = __toESM(require_react(), 1);
 function CreateSkillWizard() {
   const { colors: colors2 } = useTheme();
   const route = useRoute();
-  const [step, setStep] = import_react84.useState("name");
-  const [name26, setName] = import_react84.useState("");
-  const [description, setDescription] = import_react84.useState("");
-  const [content, setContent] = import_react84.useState("");
-  const [error40, setError] = import_react84.useState(null);
-  const [confirmFocused, setConfirmFocused] = import_react84.useState(0);
+  const [step, setStep] = import_react83.useState("name");
+  const [name26, setName] = import_react83.useState("");
+  const [description, setDescription] = import_react83.useState("");
+  const [content, setContent] = import_react83.useState("");
+  const [error40, setError] = import_react83.useState(null);
+  const [confirmFocused, setConfirmFocused] = import_react83.useState(0);
   const slug = slugify(name26);
   async function handleSave() {
     if (!name26.trim() || !content.trim())
@@ -283768,13 +284407,13 @@ async function detectTerminalMode(timeoutMs = 1000) {
 
 // src/tui/index.tsx
 function App({ appConfig }) {
-  const [focusIndex, setFocusIndex] = import_react87.useState(0);
-  const [cwd, setCwd] = import_react87.useState(process.cwd());
-  const [ctrlCPressTime, setCtrlCPressTime] = import_react87.useState(null);
-  const [showExitWarning, setShowExitWarning] = import_react87.useState(false);
-  const [inputKey, setInputKey] = import_react87.useState(0);
-  const [showSessionsDialog, setShowSessionsDialog] = import_react87.useState(false);
-  const [showShortcutsDialog, setShowShortcutsDialog] = import_react87.useState(false);
+  const [focusIndex, setFocusIndex] = import_react86.useState(0);
+  const [cwd, setCwd] = import_react86.useState(process.cwd());
+  const [ctrlCPressTime, setCtrlCPressTime] = import_react86.useState(null);
+  const [showExitWarning, setShowExitWarning] = import_react86.useState(false);
+  const [inputKey, setInputKey] = import_react86.useState(0);
+  const [showSessionsDialog, setShowSessionsDialog] = import_react86.useState(false);
+  const [showShortcutsDialog, setShowShortcutsDialog] = import_react86.useState(false);
   const navigableItems = ["command-input"];
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(ConfigProvider, {
     config: appConfig,
@@ -283839,14 +284478,14 @@ function AppContent({
   const { toast } = useToast();
   const { refocusPrompt } = useFocus();
   const { setExternalDialogOpen } = useDialog();
-  import_react87.useEffect(() => {
+  import_react86.useEffect(() => {
     checkForUpdate().then(({ updateAvailable, currentVersion, latestVersion }) => {
       if (!updateAvailable)
         return;
       toast(`Update available: v${currentVersion} → v${latestVersion}. Run: pensar upgrade`, "warn", 8000);
     });
   }, []);
-  import_react87.useEffect(() => {
+  import_react86.useEffect(() => {
     if (route.data.type !== "base")
       return;
     if (!config3.data.responsibleUseAccepted && route.data.path !== "disclosure") {
@@ -283855,7 +284494,7 @@ function AppContent({
       route.navigate({ type: "base", path: "providers" });
     }
   }, [config3.data.responsibleUseAccepted, route.data]);
-  import_react87.useEffect(() => {
+  import_react86.useEffect(() => {
     if (showExitWarning) {
       const timer = setTimeout(() => {
         setShowExitWarning(false);