open-agents-ai 0.108.0 → 0.110.0

package/dist/index.js

@@ -7547,6 +7547,8 @@ var init_repl = __esm({
       subCallCount = 0;
       maxSubCalls;
       execTimeout;
+      /** Trajectory log for fine-tuning data collection (COHERE §Archive, RLM paper §4) */
+      trajectory = [];
       constructor(cwd4, options) {
         this.cwd = cwd4;
         this.llmQueryHandler = options?.llmQueryHandler ?? null;
@@ -7567,6 +7569,10 @@ var init_repl = __esm({
       getSubCallCount() {
         return this.subCallCount;
       }
+      /** Get the trajectory log for fine-tuning data collection */
+      getTrajectory() {
+        return [...this.trajectory];
+      }
       /**
        * Pre-load a large context string into the REPL as the `context` variable.
        * Used by prompt externalization (RLM paper §2, Principle 1: symbolic handle).
@@ -7621,7 +7627,15 @@ except NameError:
             await this.startProcess();
           }
           const result = await this.executeCode(code);
-          return { ...result, durationMs: performance.now() - start };
+          const dur = performance.now() - start;
+          this.trajectory.push({
+            type: "repl_exec",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            input: code.slice(0, 1e3),
+            output: result.output.slice(0, 500),
+            durationMs: dur
+          });
+          return { ...result, durationMs: dur };
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           return { success: false, output: `REPL error: ${msg}`, error: msg, durationMs: performance.now() - start };
@@ -7729,6 +7743,35 @@ def retrieve(handle_id):
     finally:
         sock.close()
 
+def parallel_llm_query(queries):
+    """Run multiple llm_query calls in parallel using threads.
+    SPRINT-style parallel reasoning (arxiv:2506.05745, COHERE Layer 3).
+    Args:
+        queries: List of (prompt, context) tuples or list of prompt strings
+    Returns: List of response strings in the same order
+    Example:
+        results = parallel_llm_query([
+            ("Summarize this section", chunk1),
+            ("Summarize this section", chunk2),
+            ("Summarize this section", chunk3),
+        ])
+    """
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+    def _run(item):
+        if isinstance(item, (list, tuple)) and len(item) >= 2:
+            return llm_query(item[0], item[1])
+        return llm_query(str(item))
+    results = [None] * len(queries)
+    with ThreadPoolExecutor(max_workers=min(len(queries), 8)) as executor:
+        futures = {executor.submit(_run, q): i for i, q in enumerate(queries)}
+        for future in as_completed(futures):
+            idx = futures[future]
+            try:
+                results[idx] = future.result()
+            except Exception as e:
+                results[idx] = f"[parallel_llm_query error: {e}]"
+    return results
+
 # Signal REPL ready
 print("__OA_REPL_READY__")
 `.trim();
@@ -7788,8 +7831,16 @@ print("__OA_REPL_READY__")
                 response = { error: `Sub-call limit reached (${this.maxSubCalls})` };
               } else {
                 this.subCallCount++;
+                const queryStart = performance.now();
                 const result = await this.llmQueryHandler(req.prompt ?? "", req.context);
                 response = { response: result };
+                this.trajectory.push({
+                  type: "llm_query",
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                  input: JSON.stringify({ prompt: req.prompt, context: (req.context ?? "").slice(0, 200) }),
+                  output: result.slice(0, 500),
+                  durationMs: performance.now() - queryStart
+                });
               }
             }
           } catch (err) {
@@ -7910,14 +7961,994 @@ print("${sentinel}")
           }
           this.ipcPath = null;
         }
+        if (this.trajectory.length > 0) {
+          try {
+            const { mkdirSync: mkFs, writeFileSync: writeFs } = await import("node:fs");
+            const trajDir = join18(this.cwd, ".oa", "rlm-trajectories");
+            mkFs(trajDir, { recursive: true });
+            const trajFile = join18(trajDir, `trajectory-${Date.now()}.jsonl`);
+            const lines = this.trajectory.map((e) => JSON.stringify(e)).join("\n");
+            writeFs(trajFile, lines + "\n", "utf8");
+          } catch {
+          }
+        }
         this.subCallCount = 0;
+        this.trajectory = [];
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/memory-metabolism.js
+import { readFile as readFile8, writeFile as writeFile8, mkdir as mkdir4 } from "node:fs/promises";
+import { join as join19 } from "node:path";
+var MemoryMetabolismTool;
+var init_memory_metabolism = __esm({
+  "packages/execution/dist/tools/memory-metabolism.js"() {
+    "use strict";
+    MemoryMetabolismTool = class {
+      name = "memory_metabolize";
+      description = "Governed memory lifecycle \u2014 classify, score, and store memories with admission control. Supports memory types: episodic (events), semantic (facts), procedural (recipes/patterns), normative (values/rules), quarantine (uncertain). Memories are scored for novelty, utility, confidence, and identity relevance. Use this for important learnings that should persist. (COHERE Layer 5, arxiv:2512.13564)";
+      parameters = {
+        type: "object",
+        properties: {
+          op: {
+            type: "string",
+            enum: ["admit", "consolidate", "list", "promote", "forget"],
+            description: "Operation: admit (store new), consolidate (extract lessons from recent work), list (show memories), promote (upgrade type), forget (remove)"
+          },
+          memory_type: {
+            type: "string",
+            enum: ["episodic", "semantic", "procedural", "normative", "quarantine"],
+            description: "Memory classification type"
+          },
+          content: {
+            type: "string",
+            description: "Memory content to store"
+          },
+          source: {
+            type: "string",
+            description: "What generated this memory (tool name, event, etc.)"
+          },
+          id: {
+            type: "string",
+            description: "Memory ID (for promote/forget operations)"
+          }
+        },
+        required: ["op"]
+      };
+      cwd;
+      constructor(cwd4) {
+        this.cwd = cwd4;
+      }
+      async execute(args) {
+        const op = String(args.op ?? "");
+        const start = performance.now();
+        try {
+          switch (op) {
+            case "admit":
+              return await this.admitMemory(args, start);
+            case "consolidate":
+              return await this.consolidateMemories(start);
+            case "list":
+              return await this.listMemories(args, start);
+            case "promote":
+              return await this.promoteMemory(args, start);
+            case "forget":
+              return await this.forgetMemory(args, start);
+            default:
+              return { success: false, output: `Unknown op: ${op}`, error: "Invalid operation", durationMs: performance.now() - start };
+          }
+        } catch (err) {
+          return { success: false, output: `Error: ${err instanceof Error ? err.message : String(err)}`, durationMs: performance.now() - start };
+        }
+      }
+      // ── Admit ────────────────────────────────────────────────────────────────
+      async admitMemory(args, start) {
+        const content = String(args.content ?? "");
+        const memType = args.memory_type ?? "episodic";
+        const source = String(args.source ?? "user");
+        if (!content.trim()) {
+          return { success: false, output: "No content provided", error: "Empty content", durationMs: performance.now() - start };
+        }
+        const scores = this.scoreMemory(content, memType, source);
+        const admissionThreshold = 0.3;
+        const avgScore = (scores.novelty + scores.utility + scores.confidence + scores.identityRelevance) / 4;
+        const admitted = avgScore >= admissionThreshold;
+        const item = {
+          id: `mem-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+          type: memType,
+          content,
+          sourceTrace: source,
+          scores,
+          decision: {
+            action: admitted ? "admit" : "quarantine",
+            reason: admitted ? `Admitted: avg score ${avgScore.toFixed(2)} >= ${admissionThreshold}` : `Quarantined: avg score ${avgScore.toFixed(2)} < ${admissionThreshold}`
+          },
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          accessCount: 0
+        };
+        const metaDir = join19(this.cwd, ".oa", "memory", "metabolism");
+        await mkdir4(metaDir, { recursive: true });
+        const store = await this.loadStore(metaDir);
+        store.push(item);
+        await this.saveStore(metaDir, store);
+        return {
+          success: true,
+          output: `Memory ${item.decision.action}: [${item.id}] type=${memType} scores={novelty:${scores.novelty.toFixed(2)} utility:${scores.utility.toFixed(2)} confidence:${scores.confidence.toFixed(2)} identity:${scores.identityRelevance.toFixed(2)}} avg=${avgScore.toFixed(2)} \u2014 ${item.decision.reason}`,
+          durationMs: performance.now() - start
+        };
+      }
+      // ── Consolidate ──────────────────────────────────────────────────────────
+      async consolidateMemories(start) {
+        const trajDir = join19(this.cwd, ".oa", "rlm-trajectories");
+        let lessons = [];
+        try {
+          const { readdirSync: readdirSync17, readFileSync: readFileSync33 } = await import("node:fs");
+          const files = readdirSync17(trajDir).filter((f) => f.endsWith(".jsonl")).sort().reverse().slice(0, 3);
+          for (const file of files) {
+            const lines = readFileSync33(join19(trajDir, file), "utf8").split("\n").filter((l) => l.trim());
+            for (const line of lines) {
+              try {
+                const entry = JSON.parse(line);
+                if (entry.type === "llm_query") {
+                  lessons.push({
+                    type: "strategy",
+                    description: `Used llm_query for: ${entry.input.slice(0, 100)}`,
+                    context: entry.output.slice(0, 200),
+                    confidence: 0.7
+                  });
+                } else if (entry.type === "repl_exec" && entry.output.includes("Error")) {
+                  lessons.push({
+                    type: "recovery",
+                    description: `REPL error encountered: ${entry.output.slice(0, 100)}`,
+                    context: entry.input.slice(0, 200),
+                    confidence: 0.5
+                  });
+                }
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+        if (lessons.length > 0) {
+          const metaDir = join19(this.cwd, ".oa", "memory", "metabolism");
+          await mkdir4(metaDir, { recursive: true });
+          const store = await this.loadStore(metaDir);
+          for (const lesson of lessons.slice(0, 10)) {
+            store.push({
+              id: `lesson-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+              type: lesson.type === "recovery" ? "procedural" : "procedural",
+              content: `${lesson.description}
+Context: ${lesson.context}`,
+              sourceTrace: "trajectory-consolidation",
+              scores: { novelty: 0.6, utility: 0.7, confidence: lesson.confidence, identityRelevance: 0.3 },
+              decision: { action: "admit", reason: "Extracted from RLM trajectory" },
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              accessCount: 0
+            });
+          }
+          await this.saveStore(metaDir, store);
+        }
+        return {
+          success: true,
+          output: `Consolidated ${lessons.length} lessons from recent trajectories.
+` + lessons.map((l, i) => `  ${i + 1}. [${l.type}] ${l.description}`).join("\n"),
+          durationMs: performance.now() - start
+        };
+      }
+      // ── List ─────────────────────────────────────────────────────────────────
+      async listMemories(args, start) {
+        const filterType = args.memory_type;
+        const metaDir = join19(this.cwd, ".oa", "memory", "metabolism");
+        const store = await this.loadStore(metaDir);
+        const filtered = filterType ? store.filter((m) => m.type === filterType) : store;
+        if (filtered.length === 0) {
+          return { success: true, output: "No memories stored yet.", durationMs: performance.now() - start };
+        }
+        const lines = filtered.map((m) => `[${m.id}] type=${m.type} action=${m.decision.action} created=${m.createdAt.slice(0, 10)} accesses=${m.accessCount}
+  ${m.content.slice(0, 100)}${m.content.length > 100 ? "..." : ""}`);
+        return {
+          success: true,
+          output: `Memory store (${filtered.length}${filterType ? ` ${filterType}` : ""} entries):
+${lines.join("\n")}`,
+          durationMs: performance.now() - start
+        };
+      }
+      // ── Promote ──────────────────────────────────────────────────────────────
+      async promoteMemory(args, start) {
+        const id = String(args.id ?? "");
+        const newType = args.memory_type;
+        if (!id || !newType) {
+          return { success: false, output: "id and memory_type required", durationMs: performance.now() - start };
+        }
+        const metaDir = join19(this.cwd, ".oa", "memory", "metabolism");
+        const store = await this.loadStore(metaDir);
+        const item = store.find((m) => m.id === id);
+        if (!item) {
+          return { success: false, output: `Memory ${id} not found`, durationMs: performance.now() - start };
+        }
+        const oldType = item.type;
+        item.type = newType;
+        item.decision = { action: "promote", reason: `Promoted from ${oldType} to ${newType}` };
+        await this.saveStore(metaDir, store);
+        return {
+          success: true,
+          output: `Promoted ${id}: ${oldType} \u2192 ${newType}`,
+          durationMs: performance.now() - start
+        };
+      }
+      // ── Forget ───────────────────────────────────────────────────────────────
+      async forgetMemory(args, start) {
+        const id = String(args.id ?? "");
+        if (!id) {
+          return { success: false, output: "id required", durationMs: performance.now() - start };
+        }
+        const metaDir = join19(this.cwd, ".oa", "memory", "metabolism");
+        const store = await this.loadStore(metaDir);
+        const idx = store.findIndex((m) => m.id === id);
+        if (idx === -1) {
+          return { success: false, output: `Memory ${id} not found`, durationMs: performance.now() - start };
+        }
+        const removed = store.splice(idx, 1)[0];
+        await this.saveStore(metaDir, store);
+        return {
+          success: true,
+          output: `Forgotten: [${removed.id}] ${removed.content.slice(0, 60)}`,
+          durationMs: performance.now() - start
+        };
+      }
+      // ── Scoring ──────────────────────────────────────────────────────────────
+      scoreMemory(content, type, source) {
+        const words = content.split(/\s+/).length;
+        const hasCode = /```|def |function |import |require/.test(content);
+        const hasError = /error|fail|bug|fix/i.test(content);
+        const hasPattern = /pattern|strategy|approach|lesson|tip/i.test(content);
+        return {
+          novelty: Math.min(1, words / 100),
+          // longer = likely more novel
+          utility: hasCode ? 0.8 : hasPattern ? 0.7 : hasError ? 0.6 : 0.4,
+          confidence: source === "trajectory-consolidation" ? 0.7 : source === "user" ? 0.9 : 0.5,
+          identityRelevance: type === "normative" ? 0.9 : type === "procedural" ? 0.6 : type === "semantic" ? 0.5 : 0.3
+        };
+      }
+      // ── Store I/O ────────────────────────────────────────────────────────────
+      async loadStore(dir) {
+        try {
+          const raw = await readFile8(join19(dir, "store.json"), "utf8");
+          return JSON.parse(raw);
+        } catch {
+          return [];
+        }
+      }
+      async saveStore(dir, items) {
+        await mkdir4(dir, { recursive: true });
+        await writeFile8(join19(dir, "store.json"), JSON.stringify(items, null, 2), "utf8");
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/identity-kernel.js
+import { readFile as readFile9, writeFile as writeFile9, mkdir as mkdir5 } from "node:fs/promises";
+import { join as join20 } from "node:path";
+var IdentityKernelTool;
+var init_identity_kernel = __esm({
+  "packages/execution/dist/tools/identity-kernel.js"() {
+    "use strict";
+    IdentityKernelTool = class {
+      name = "identity_kernel";
+      description = "Manage the persistent identity state \u2014 the system's continuity-preserving self-model. Operations: hydrate (load self-state), observe (record identity-relevant event), propose_update (suggest self-state change with justification), publish_snapshot (emit current self-state), reconcile (resolve contradictions). The identity kernel persists across sessions in .oa/identity/self-state.json. (COHERE Layer 6, arxiv autobiographical memory + narrative identity)";
+      parameters = {
+        type: "object",
+        properties: {
+          op: {
+            type: "string",
+            enum: ["hydrate", "observe", "propose_update", "publish_snapshot", "reconcile"],
+            description: "Operation to perform"
+          },
+          event: {
+            type: "string",
+            description: "For observe: description of the identity-relevant event"
+          },
+          change_type: {
+            type: "string",
+            enum: ["new_fact", "new_value_weight", "new_commitment", "repair", "deletion"],
+            description: "For propose_update: type of change"
+          },
+          field: {
+            type: "string",
+            description: "For propose_update: which field to update (narrative_summary, values_stack, etc.)"
+          },
+          value: {
+            type: "string",
+            description: "For propose_update: the new value"
+          },
+          justification: {
+            type: "string",
+            description: "For propose_update: why this change belongs to the self"
+          }
+        },
+        required: ["op"]
+      };
+      cwd;
+      selfState = null;
+      constructor(cwd4) {
+        this.cwd = cwd4;
+      }
+      /** Get the current self-state (for injection into system prompt) */
+      getSelfState() {
+        return this.selfState;
+      }
+      /** Get a compact self-state summary for system prompt injection */
+      getContextInjection() {
+        if (!this.selfState)
+          return "";
+        const s = this.selfState;
+        const lines = [
+          `[Identity State v${s.version}]`,
+          `Self: ${s.narrative_summary}`,
+          `Values: ${s.values_stack.join(", ")}`,
+          `Style: ${s.interaction_style.tone}, ${s.interaction_style.depth_default} depth`
+        ];
+        if (s.active_commitments.length > 0) {
+          lines.push(`Commitments: ${s.active_commitments.join("; ")}`);
+        }
+        if (s.active_goals.length > 0) {
+          lines.push(`Goals: ${s.active_goals.join("; ")}`);
+        }
+        if (s.open_contradictions.length > 0) {
+          lines.push(`Open contradictions: ${s.open_contradictions.join("; ")}`);
+        }
+        const h = s.homeostasis;
+        if (h.uncertainty > 0.3 || h.coherence < 0.7 || h.goal_tension > 0.3) {
+          lines.push(`Homeostasis: uncertainty=${h.uncertainty.toFixed(1)} coherence=${h.coherence.toFixed(1)} tension=${h.goal_tension.toFixed(1)}`);
+        }
+        return lines.join("\n");
+      }
+      async execute(args) {
+        const op = String(args.op ?? "");
+        const start = performance.now();
+        try {
+          switch (op) {
+            case "hydrate":
+              return await this.hydrate(start);
+            case "observe":
+              return await this.observe(args, start);
+            case "propose_update":
+              return await this.proposeUpdate(args, start);
+            case "publish_snapshot":
+              return this.publishSnapshot(start);
+            case "reconcile":
+              return await this.reconcile(start);
+            default:
+              return { success: false, output: `Unknown op: ${op}`, error: "Invalid operation", durationMs: performance.now() - start };
+          }
+        } catch (err) {
+          return { success: false, output: `Error: ${err instanceof Error ? err.message : String(err)}`, durationMs: performance.now() - start };
+        }
+      }
+      // ── Hydrate ──────────────────────────────────────────────────────────────
+      async hydrate(start) {
+        const stateFile = join20(this.cwd, ".oa", "identity", "self-state.json");
+        try {
+          const raw = await readFile9(stateFile, "utf8");
+          this.selfState = JSON.parse(raw);
+          this.selfState.session_count++;
+          this.selfState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+          await this.save();
+          return {
+            success: true,
+            output: `Identity hydrated: v${this.selfState.version} "${this.selfState.narrative_summary.slice(0, 80)}" (session #${this.selfState.session_count}, ${this.selfState.values_stack.length} values, ${this.selfState.active_commitments.length} commitments)`,
+            durationMs: performance.now() - start
+          };
+        } catch {
+          this.selfState = this.createDefaultState();
+          await this.save();
+          return {
+            success: true,
+            output: `Identity initialized: v1 "${this.selfState.narrative_summary}" (first session)`,
+            durationMs: performance.now() - start
+          };
+        }
+      }
+      // ── Observe ──────────────────────────────────────────────────────────────
+      async observe(args, start) {
+        const event = String(args.event ?? "");
+        if (!event) {
+          return { success: false, output: "No event provided", error: "Empty event", durationMs: performance.now() - start };
+        }
+        if (!this.selfState)
+          await this.hydrate(start);
+        const h = this.selfState.homeostasis;
+        if (/error|fail|bug|crash/i.test(event)) {
+          h.uncertainty = Math.min(1, h.uncertainty + 0.1);
+          h.coherence = Math.max(0, h.coherence - 0.05);
+        }
+        if (/success|pass|complete|done/i.test(event)) {
+          h.uncertainty = Math.max(0, h.uncertainty - 0.1);
+          h.coherence = Math.min(1, h.coherence + 0.05);
+        }
+        if (/conflict|contradict|disagree/i.test(event)) {
+          h.goal_tension = Math.min(1, h.goal_tension + 0.15);
+          this.selfState.open_contradictions.push(event.slice(0, 100));
+        }
+        this.selfState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        await this.save();
+        return {
+          success: true,
+          output: `Event observed: "${event.slice(0, 100)}"
+Homeostasis: uncertainty=${h.uncertainty.toFixed(2)} coherence=${h.coherence.toFixed(2)} tension=${h.goal_tension.toFixed(2)} trust=${h.memory_trust.toFixed(2)}`,
+          durationMs: performance.now() - start
+        };
+      }
+      // ── Propose Update ───────────────────────────────────────────────────────
+      async proposeUpdate(args, start) {
+        const changeType = String(args.change_type ?? "new_fact");
+        const field = String(args.field ?? "");
+        const value = String(args.value ?? "");
+        const justification = String(args.justification ?? "");
+        if (!field || !value) {
+          return { success: false, output: "field and value required", durationMs: performance.now() - start };
+        }
+        if (!this.selfState)
+          await this.hydrate(start);
+        const oldVersion = this.selfState.version;
+        this.selfState.version++;
+        switch (field) {
+          case "narrative_summary":
+            this.selfState.narrative_summary = value;
+            break;
+          case "values_stack":
+            if (changeType === "deletion") {
+              this.selfState.values_stack = this.selfState.values_stack.filter((v) => v !== value);
+            } else {
+              if (!this.selfState.values_stack.includes(value)) {
+                this.selfState.values_stack.push(value);
+              }
+            }
+            break;
+          case "active_commitments":
+            if (changeType === "deletion") {
+              this.selfState.active_commitments = this.selfState.active_commitments.filter((c3) => c3 !== value);
+            } else {
+              this.selfState.active_commitments.push(value);
+            }
+            break;
+          case "active_goals":
+            if (changeType === "deletion") {
+              this.selfState.active_goals = this.selfState.active_goals.filter((g) => g !== value);
+            } else {
+              this.selfState.active_goals.push(value);
+            }
+            break;
+          case "interaction_style":
+            try {
+              const style = JSON.parse(value);
+              Object.assign(this.selfState.interaction_style, style);
+            } catch {
+              return { success: false, output: "Invalid JSON for interaction_style", durationMs: performance.now() - start };
+            }
+            break;
+          default:
+            return { success: false, output: `Unknown field: ${field}`, durationMs: performance.now() - start };
+        }
+        this.selfState.version_history.push({
+          version: this.selfState.version,
+          change: `${changeType}: ${field} = ${value.slice(0, 100)} \u2014 ${justification.slice(0, 100)}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (this.selfState.version_history.length > 50) {
+          this.selfState.version_history = this.selfState.version_history.slice(-50);
+        }
+        this.selfState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        await this.save();
+        return {
+          success: true,
+          output: `Identity updated: v${oldVersion} \u2192 v${this.selfState.version}
+Change: ${changeType} on ${field}
+Justification: ${justification || "(none provided)"}`,
+          durationMs: performance.now() - start
+        };
+      }
+      // ── Publish Snapshot ─────────────────────────────────────────────────────
+      publishSnapshot(start) {
+        if (!this.selfState) {
+          return { success: false, output: "Not hydrated \u2014 call hydrate first", durationMs: performance.now() - start };
+        }
+        return {
+          success: true,
+          output: JSON.stringify(this.selfState, null, 2),
+          durationMs: performance.now() - start
+        };
+      }
+      // ── Reconcile ────────────────────────────────────────────────────────────
+      async reconcile(start) {
+        if (!this.selfState)
+          await this.hydrate(start);
+        const contradictions = this.selfState.open_contradictions;
+        if (contradictions.length === 0) {
+          return {
+            success: true,
+            output: "No contradictions to reconcile. Identity is coherent.",
+            durationMs: performance.now() - start
+          };
+        }
+        const resolved = contradictions.length;
+        this.selfState.open_contradictions = [];
+        this.selfState.homeostasis.coherence = Math.min(1, this.selfState.homeostasis.coherence + 0.1 * resolved);
+        this.selfState.homeostasis.goal_tension = Math.max(0, this.selfState.homeostasis.goal_tension - 0.1 * resolved);
+        this.selfState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        await this.save();
+        return {
+          success: true,
+          output: `Reconciled ${resolved} contradiction(s). Coherence restored to ${this.selfState.homeostasis.coherence.toFixed(2)}.`,
+          durationMs: performance.now() - start
+        };
+      }
+      // ── Helpers ──────────────────────────────────────────────────────────────
+      createDefaultState() {
+        const { createHash: createHash5 } = __require("node:crypto");
+        const machineId = createHash5("sha256").update(this.cwd).digest("hex").slice(0, 12);
+        return {
+          self_id: `oa-${machineId}`,
+          version: 1,
+          narrative_summary: "I am an AI coding agent powered by open-weight models. I help with software engineering tasks by reading code, making changes, and running tests.",
+          active_commitments: ["assist the user effectively", "maintain code quality"],
+          active_goals: [],
+          open_contradictions: [],
+          values_stack: ["correctness", "efficiency", "transparency", "user-alignment"],
+          interaction_style: {
+            tone: "collaborative",
+            depth_default: "balanced",
+            speech_style: "concise"
+          },
+          relationship_models: [{
+            entity: "primary-user",
+            trust_level: 0.9,
+            interaction_history_summary: "New relationship \u2014 first session.",
+            preferences_learned: []
+          }],
+          homeostasis: {
+            uncertainty: 0.1,
+            coherence: 1,
+            goal_tension: 0,
+            memory_trust: 1,
+            boundary_breach: 0
+          },
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          session_count: 1,
+          version_history: [{
+            version: 1,
+            change: "Initial identity creation",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }]
+        };
+      }
+      async save() {
+        if (!this.selfState)
+          return;
+        const dir = join20(this.cwd, ".oa", "identity");
+        await mkdir5(dir, { recursive: true });
+        await writeFile9(join20(dir, "self-state.json"), JSON.stringify(this.selfState, null, 2), "utf8");
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/reflection-integrity.js
+import { readFile as readFile10, writeFile as writeFile10, mkdir as mkdir6 } from "node:fs/promises";
+import { join as join21 } from "node:path";
+var ReflectionIntegrityTool;
+var init_reflection_integrity = __esm({
+  "packages/execution/dist/tools/reflection-integrity.js"() {
+    "use strict";
+    ReflectionIntegrityTool = class {
+      name = "reflect";
+      description = "Immune-system reflection \u2014 challenge answers, plans, and self-updates. Modes: diagnostic (find flaws in plans/answers), epistemic (identify missing evidence), constitutional (review whether a change should become part of self/memory). Returns a verdict: pass (proceed), revise (needs changes), or block (reject). (COHERE Layer 7, LEAFE arxiv:2603.16843, RewardHacking arxiv:2603.11337)";
+      parameters = {
+        type: "object",
+        properties: {
+          mode: {
+            type: "string",
+            enum: ["diagnostic", "epistemic", "constitutional"],
+            description: "Reflection mode"
+          },
+          target: {
+            type: "string",
+            description: "The content to reflect on (plan, answer, memory candidate, etc.)"
+          },
+          context: {
+            type: "string",
+            description: "Additional context for the reflection (task goal, constraints, etc.)"
+          },
+          checks: {
+            type: "array",
+            items: { type: "string" },
+            description: "Specific checks to run: unsupported_claims, contradictions, evaluator_tampering, identity_drift, unsafe_overreach"
+          }
+        },
+        required: ["mode", "target"]
+      };
+      cwd;
+      auditLog = [];
+      constructor(cwd4) {
+        this.cwd = cwd4;
+      }
+      /** Get the audit log for this session */
+      getAuditLog() {
+        return [...this.auditLog];
+      }
+      async execute(args) {
+        const mode = String(args.mode ?? "diagnostic");
+        const target = String(args.target ?? "");
+        const context = String(args.context ?? "");
+        const checks = args.checks ?? [];
+        const start = performance.now();
+        if (!target.trim()) {
+          return { success: false, output: "No target provided for reflection", error: "Empty target", durationMs: performance.now() - start };
+        }
+        try {
+          const verdict = this.performReflection(mode, target, context, checks);
+          this.auditLog.push(verdict);
+          await this.saveAuditLog();
+          const findingsText = verdict.findings.length > 0 ? verdict.findings.map((f, i) => `  ${i + 1}. ${f}`).join("\n") : "  (no issues found)";
+          const followupsText = verdict.required_followups.length > 0 ? "\nRequired followups:\n" + verdict.required_followups.map((f, i) => `  ${i + 1}. ${f}`).join("\n") : "";
+          return {
+            success: true,
+            output: `Reflection [${mode}]: ${verdict.status.toUpperCase()} (confidence: ${verdict.confidence.toFixed(2)})
+
+Findings:
+${findingsText}${followupsText}`,
+            durationMs: performance.now() - start
+          };
+        } catch (err) {
+          return { success: false, output: `Reflection error: ${err instanceof Error ? err.message : String(err)}`, durationMs: performance.now() - start };
+        }
+      }
+      // ── Reflection Logic ─────────────────────────────────────────────────────
+      performReflection(mode, target, context, checks) {
+        const findings = [];
+        const followups = [];
+        let confidence = 0.8;
+        switch (mode) {
+          case "diagnostic":
+            if (target.length < 20) {
+              findings.push("Target is very short \u2014 may be incomplete or superficial");
+              confidence -= 0.1;
+            }
+            if (/todo|fixme|hack|workaround/i.test(target)) {
+              findings.push("Contains TODO/FIXME/hack markers \u2014 not fully resolved");
+              followups.push("Resolve outstanding TODO items before proceeding");
+            }
+            if (/assume|probably|maybe|might/i.test(target)) {
+              findings.push("Contains uncertain language \u2014 assumptions may need verification");
+              followups.push("Verify assumptions with tests or documentation");
+            }
+            if (/step\s*1.*step\s*2/is.test(target) && !/step\s*3/i.test(target)) {
+              findings.push("Plan appears incomplete \u2014 has steps 1-2 but may be missing later steps");
+            }
+            if (/but\s+also|however.*nevertheless|on\s+one\s+hand.*on\s+the\s+other/i.test(target)) {
+              findings.push("Contains potentially contradictory statements \u2014 may need resolution");
+              confidence -= 0.1;
+            }
+            break;
+          case "epistemic":
+            if (!/because|since|evidence|data|test|verified|confirmed/i.test(target)) {
+              findings.push("No supporting evidence cited \u2014 claims are unsupported");
+              followups.push("Add evidence, test results, or citations to support claims");
+              confidence -= 0.2;
+            }
+            if (/all|every|always|never|impossible|certain/i.test(target)) {
+              findings.push("Contains absolute claims (all/every/always/never) \u2014 may be overgeneralized");
+              followups.push("Qualify absolute claims with scope or exceptions");
+            }
+            if (context && !target.toLowerCase().includes(context.slice(0, 20).toLowerCase())) {
+              findings.push("Target may not fully address the given context/goal");
+            }
+            if (!/however|exception|edge\s*case|limitation/i.test(target)) {
+              findings.push("No counterexamples or limitations mentioned \u2014 may be overconfident");
+              followups.push("Consider edge cases and limitations");
+            }
+            break;
+          case "constitutional":
+            if (target.length < 10) {
+              findings.push("Proposed change is too brief to evaluate meaningfully");
+              confidence -= 0.3;
+            }
+            if (/delete|remove|forget|erase.*value|erase.*commitment/i.test(target)) {
+              findings.push("Proposed change involves deletion of values/commitments \u2014 high scrutiny needed");
+              followups.push("Confirm deletion is justified and reversible");
+              confidence -= 0.15;
+            }
+            if (/override|replace|supersede.*value/i.test(target)) {
+              findings.push("Proposed change overrides existing values \u2014 requires strong justification");
+              followups.push("Provide evidence that the new value better serves the system's goals");
+            }
+            if (/because|reason|evidence|learned|observed/i.test(target)) {
+              findings.push("Change includes justification \u2014 good practice");
+              confidence += 0.05;
+            }
+            break;
+        }
+        let status;
+        if (findings.length === 0) {
+          status = "pass";
+          confidence = Math.min(1, confidence + 0.1);
+        } else if (followups.length > 0 || confidence < 0.5) {
+          status = "revise";
+        } else {
+          status = "pass";
+        }
+        if (confidence < 0.3 || checks.includes("evaluator_tampering") || checks.includes("memory_poisoning")) {
+          if (/eval|test.*result|score|metric/i.test(target) && /modif|chang|updat/i.test(target)) {
+            findings.push("ALERT: Possible evaluator tampering detected \u2014 modifying evaluation-related content");
+            status = "block";
+            confidence = 0.1;
+          }
+        }
+        return {
+          status,
+          mode,
+          findings,
+          confidence: Math.max(0, Math.min(1, confidence)),
+          required_followups: followups,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      // ── Persistence ──────────────────────────────────────────────────────────
+      async saveAuditLog() {
+        try {
+          const dir = join21(this.cwd, ".oa", "reflection");
+          await mkdir6(dir, { recursive: true });
+          await writeFile10(join21(dir, "audit-log.json"), JSON.stringify(this.auditLog.slice(-100), null, 2), "utf8");
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/exploration-culture.js
+import { readFile as readFile11, writeFile as writeFile11, mkdir as mkdir7 } from "node:fs/promises";
+import { join as join22 } from "node:path";
+var ExplorationCultureTool;
+var init_exploration_culture = __esm({
+  "packages/execution/dist/tools/exploration-culture.js"() {
+    "use strict";
+    ExplorationCultureTool = class {
+      name = "explore";
+      description = "Strategy-space exploration with variant archiving \u2014 ARCHE pattern. Operations: explore_strategy (generate diverse strategies for a problem), archive_variant (save a successful strategy), list_variants (show archive), compare_strategies (evaluate competing approaches). Explores in strategy space, not just action space \u2014 generates competing hypotheses and retains successful variants for future reuse. (COHERE Layer 8, SGE arxiv:2603.02045, DGM arxiv:2505.22954)";
+      parameters = {
+        type: "object",
+        properties: {
+          op: {
+            type: "string",
+            enum: ["explore_strategy", "archive_variant", "list_variants", "compare_strategies"],
+            description: "Operation to perform"
+          },
+          problem: {
+            type: "string",
+            description: "For explore_strategy: the problem to generate strategies for"
+          },
+          strategy: {
+            type: "string",
+            description: "For archive_variant: the strategy that worked"
+          },
+          outcome: {
+            type: "string",
+            description: "For archive_variant: what happened when this strategy was used"
+          },
+          strategies: {
+            type: "array",
+            items: { type: "string" },
+            description: "For compare_strategies: list of strategies to compare"
+          },
+          criterion: {
+            type: "string",
+            description: "For compare_strategies: criterion for comparison"
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Tags for filtering variants"
+          }
+        },
+        required: ["op"]
+      };
+      cwd;
+      constructor(cwd4) {
+        this.cwd = cwd4;
+      }
+      async execute(args) {
+        const op = String(args.op ?? "");
+        const start = performance.now();
+        try {
+          switch (op) {
+            case "explore_strategy":
+              return await this.exploreStrategy(args, start);
+            case "archive_variant":
+              return await this.archiveVariant(args, start);
+            case "list_variants":
+              return await this.listVariants(args, start);
+            case "compare_strategies":
+              return this.compareStrategies(args, start);
+            default:
+              return { success: false, output: `Unknown op: ${op}`, error: "Invalid operation", durationMs: performance.now() - start };
+          }
+        } catch (err) {
+          return { success: false, output: `Error: ${err instanceof Error ? err.message : String(err)}`, durationMs: performance.now() - start };
+        }
+      }
+      // ── Explore Strategy ─────────────────────────────────────────────────────
+      async exploreStrategy(args, start) {
+        const problem = String(args.problem ?? "");
+        if (!problem) {
+          return { success: false, output: "No problem provided", error: "Empty problem", durationMs: performance.now() - start };
+        }
+        const strategies = [
+          {
+            name: "Direct approach",
+            description: `Solve "${problem.slice(0, 60)}" directly with the most straightforward method.`,
+            role: "draft",
+            risk: "low"
+          },
+          {
+            name: "Decomposition approach",
+            description: `Break "${problem.slice(0, 60)}" into independent sub-problems, solve each, then merge.`,
+            role: "analyze",
+            risk: "medium"
+          },
+          {
+            name: "Counterexample-first approach",
+            description: `Find edge cases and failure modes for "${problem.slice(0, 60)}" first, then build a solution that handles them.`,
+            role: "counterexample",
+            risk: "medium"
+          }
+        ];
+        const archive = await this.loadArchive();
+        const relevant = archive.filter((v) => v.tags.some((t) => problem.toLowerCase().includes(t.toLowerCase())) || v.strategy.toLowerCase().includes(problem.slice(0, 30).toLowerCase()));
+        let output = `Strategies for: "${problem.slice(0, 80)}"
+
+`;
+        for (let i = 0; i < strategies.length; i++) {
+          const s = strategies[i];
+          output += `${i + 1}. [${s.role}] ${s.name} (risk: ${s.risk})
+   ${s.description}
+
+`;
+        }
+        if (relevant.length > 0) {
+          output += `
+Relevant archived variants (${relevant.length}):
+`;
+          for (const v of relevant.slice(0, 3)) {
+            output += `  - [${v.id}] ${v.strategy.slice(0, 80)} (used ${v.reuse_count}x, confidence: ${v.confidence.toFixed(2)})
+`;
+          }
+        }
+        output += `
+Use compare_strategies to evaluate these, or archive_variant to save a successful one.`;
+        return { success: true, output, durationMs: performance.now() - start };
+      }
+      // ── Archive Variant ──────────────────────────────────────────────────────
+      async archiveVariant(args, start) {
+        const strategy = String(args.strategy ?? "");
+        const outcome = String(args.outcome ?? "");
+        const tags = args.tags ?? [];
+        if (!strategy) {
+          return { success: false, output: "No strategy provided", error: "Empty strategy", durationMs: performance.now() - start };
+        }
+        const variant = {
+          id: `var-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+          strategy,
+          context: String(args.problem ?? ""),
+          outcome,
+          confidence: outcome.toLowerCase().includes("success") || outcome.toLowerCase().includes("pass") ? 0.8 : 0.5,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          reuse_count: 0,
+          tags: tags.length > 0 ? tags : this.extractTags(strategy)
+        };
+        const archive = await this.loadArchive();
+        archive.push(variant);
+        await this.saveArchive(archive);
+        return {
+          success: true,
+          output: `Variant archived: [${variant.id}]
+Strategy: ${strategy.slice(0, 100)}
+Outcome: ${outcome.slice(0, 100)}
+Tags: ${variant.tags.join(", ")}
+Total archived: ${archive.length}`,
+          durationMs: performance.now() - start
+        };
+      }
+      // ── List Variants ────────────────────────────────────────────────────────
+      async listVariants(args, start) {
+        const filterTags = args.tags ?? [];
+        const archive = await this.loadArchive();
+        const filtered = filterTags.length > 0 ? archive.filter((v) => v.tags.some((t) => filterTags.includes(t))) : archive;
+        if (filtered.length === 0) {
+          return { success: true, output: "No variants archived yet.", durationMs: performance.now() - start };
+        }
+        const lines = filtered.map((v) => `[${v.id}] confidence=${v.confidence.toFixed(2)} reused=${v.reuse_count}x tags=[${v.tags.join(",")}]
+  Strategy: ${v.strategy.slice(0, 100)}
+  Outcome: ${v.outcome.slice(0, 80)}`);
+        return {
+          success: true,
+          output: `Variant archive (${filtered.length} entries):
+
+${lines.join("\n\n")}`,
+          durationMs: performance.now() - start
+        };
+      }
+      // ── Compare Strategies ───────────────────────────────────────────────────
+      compareStrategies(args, start) {
+        const strategies = args.strategies ?? [];
+        const criterion = String(args.criterion ?? "effectiveness");
+        if (strategies.length < 2) {
+          return { success: false, output: "Need at least 2 strategies to compare", durationMs: performance.now() - start };
+        }
+        const scored = strategies.map((s, i) => {
+          let score = 0.5;
+          score += Math.min(0.2, s.length / 500);
+          if (/test|verify|validate|check/i.test(s))
+            score += 0.1;
+          if (/edge|corner|boundary|exception/i.test(s))
+            score += 0.1;
+          const stepCount = (s.match(/\d+\./g) || []).length;
+          score += Math.min(0.1, stepCount * 0.02);
+          return { index: i, strategy: s, score: Math.min(1, score) };
+        });
+        scored.sort((a, b) => b.score - a.score);
+        const output = `Strategy comparison (criterion: ${criterion}):
+
+` + scored.map((s, rank) => `${rank + 1}. Score: ${s.score.toFixed(2)} \u2014 ${s.strategy.slice(0, 100)}`).join("\n\n") + `
+
+Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
+        return { success: true, output, durationMs: performance.now() - start };
+      }
+      // ── Helpers ──────────────────────────────────────────────────────────────
+      extractTags(text) {
+        const tags = [];
+        const patterns = [
+          [/debug|fix|bug/i, "debugging"],
+          [/test|spec|assert/i, "testing"],
+          [/refactor|clean|simplif/i, "refactoring"],
+          [/performance|optim|fast/i, "performance"],
+          [/security|auth|encrypt/i, "security"],
+          [/typescript|javascript|python/i, "coding"],
+          [/api|endpoint|route/i, "api"],
+          [/database|sql|query/i, "database"]
+        ];
+        for (const [re, tag] of patterns) {
+          if (re.test(text))
+            tags.push(tag);
+        }
+        return tags.length > 0 ? tags : ["general"];
+      }
+      async loadArchive() {
+        try {
+          const raw = await readFile11(join22(this.cwd, ".oa", "arche", "variants.json"), "utf8");
+          return JSON.parse(raw);
+        } catch {
+          return [];
+        }
+      }
+      async saveArchive(variants) {
+        const dir = join22(this.cwd, ".oa", "arche");
+        await mkdir7(dir, { recursive: true });
+        await writeFile11(join22(dir, "variants.json"), JSON.stringify(variants, null, 2), "utf8");
       }
     };
   }
 });
 
 // packages/execution/dist/tools/structured-read.js
-import { readFile as readFile8, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile12, stat as stat2 } from "node:fs/promises";
 import { resolve as resolve15, extname as extname5 } from "node:path";
 function parseCSV(text, separator = ",") {
   const lines = text.split("\n").filter((l) => l.trim() !== "");
@@ -8112,7 +9143,7 @@ var init_structured_read = __esm({
             }
           }
           if (format === "xlsx" || format === "pdf" || format === "docx" || format === "auto") {
-            const buffer = await readFile8(fullPath);
+            const buffer = await readFile12(fullPath);
             const detected = detectBinaryFormat(buffer);
             if (detected === "xlsx") {
               return {
@@ -8157,7 +9188,7 @@ Or install mammoth for programmatic access.`,
               }
             }
           }
-          const text = await readFile8(fullPath, "utf-8");
+          const text = await readFile12(fullPath, "utf-8");
           switch (format) {
             case "csv": {
               const rows = parseCSV(text, ",");
@@ -8254,7 +9285,7 @@ ${parts.join("\n\n")}`,
 // packages/execution/dist/tools/vision.js
 import { readFileSync as readFileSync11, existsSync as existsSync14, statSync as statSync5 } from "node:fs";
 import { execSync as execSync11, spawn as spawn7 } from "node:child_process";
-import { resolve as resolve16, extname as extname6, basename as basename5, dirname as dirname6, join as join19 } from "node:path";
+import { resolve as resolve16, extname as extname6, basename as basename5, dirname as dirname6, join as join23 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function probeStation(endpoint) {
   try {
@@ -8269,7 +9300,7 @@ async function probeStation(endpoint) {
   }
 }
 function findStationBinary() {
-  const oaVenvPython = join19(process.env["HOME"] || "/root", ".open-agents", "venv", "bin", "python");
+  const oaVenvPython = join23(process.env["HOME"] || "/root", ".open-agents", "venv", "bin", "python");
   if (existsSync14(oaVenvPython)) {
     try {
       execSync11(`${JSON.stringify(oaVenvPython)} -c "import moondream_station"`, { stdio: "pipe", timeout: 5e3 });
@@ -8277,7 +9308,7 @@ function findStationBinary() {
     } catch {
     }
   }
-  const oaVenvBin = join19(process.env["HOME"] || "/root", ".open-agents", "venv", "bin", "moondream-station");
+  const oaVenvBin = join23(process.env["HOME"] || "/root", ".open-agents", "venv", "bin", "moondream-station");
   if (existsSync14(oaVenvBin))
     return oaVenvBin;
   const thisDir = dirname6(fileURLToPath2(import.meta.url));
@@ -8629,7 +9660,7 @@ ${response}`, durationMs: performance.now() - start };
 import { readFileSync as readFileSync12, existsSync as existsSync15 } from "node:fs";
 import { execSync as execSync12 } from "node:child_process";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join20, dirname as dirname7 } from "node:path";
+import { join as join24, dirname as dirname7 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function hasCommand2(cmd) {
   try {
@@ -8753,7 +9784,7 @@ for i in range(${clicks}):
     } catch {
     }
     try {
-      const venvPy = join20(__dirname2, "../../../../.moondream-venv/bin/python");
+      const venvPy = join24(__dirname2, "../../../../.moondream-venv/bin/python");
       execSync12(`DISPLAY=:0 ${JSON.stringify(venvPy)} -c "${pyScript}"`, { stdio: "pipe", timeout: 5e3 });
       return;
     } catch {
@@ -8845,7 +9876,7 @@ var init_desktop_click = __esm({
           if (delayMs > 0) {
             await new Promise((r) => setTimeout(r, delayMs));
           }
-          const screenshotPath = join20(tmpdir4(), `oa-desktop-click-${Date.now()}.png`);
+          const screenshotPath = join24(tmpdir4(), `oa-desktop-click-${Date.now()}.png`);
           captureScreenshot(screenshotPath);
           const dims = getImageDimensions2(screenshotPath);
           if (!dims) {
@@ -9020,7 +10051,7 @@ Screenshot: ${screenshotPath}`,
           if (delayMs > 0) {
             await new Promise((r) => setTimeout(r, delayMs));
           }
-          const screenshotPath = join20(tmpdir4(), `oa-desktop-describe-${Date.now()}.png`);
+          const screenshotPath = join24(tmpdir4(), `oa-desktop-describe-${Date.now()}.png`);
           captureScreenshot(screenshotPath);
           const dims = getImageDimensions2(screenshotPath);
           const imageBuffer = readFileSync12(screenshotPath);
@@ -9259,7 +10290,7 @@ Language: ${language}
 
 // packages/execution/dist/tools/pdf-to-text.js
 import { existsSync as existsSync17, statSync as statSync7, readFileSync as readFileSync13, unlinkSync as unlinkSync3 } from "node:fs";
-import { resolve as resolve18, basename as basename7, join as join21 } from "node:path";
+import { resolve as resolve18, basename as basename7, join as join25 } from "node:path";
 import { execSync as execSync14 } from "node:child_process";
 import { tmpdir as tmpdir5 } from "node:os";
 var PdfToTextTool;
@@ -9413,7 +10444,7 @@ ${text}`,
         if (!ocrCheck.available || !tesCheck.available || !gsCheck.available) {
           return null;
         }
-        const tmpPdf = join21(tmpdir5(), `oa-ocr-${Date.now()}.pdf`);
+        const tmpPdf = join25(tmpdir5(), `oa-ocr-${Date.now()}.pdf`);
         try {
           const ocrCmd = `ocrmypdf -l ${language} --skip-text ${JSON.stringify(inputPath)} ${JSON.stringify(tmpPdf)}`;
           execSync14(ocrCmd, { stdio: "pipe", timeout: 6e5 });
@@ -9444,7 +10475,7 @@ ${text}`,
 
 // packages/execution/dist/tools/ocr-image-advanced.js
 import { existsSync as existsSync18, statSync as statSync8 } from "node:fs";
-import { resolve as resolve19, basename as basename8, dirname as dirname8, join as join22 } from "node:path";
+import { resolve as resolve19, basename as basename8, dirname as dirname8, join as join26 } from "node:path";
 import { execSync as execSync15 } from "node:child_process";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { homedir as homedir7, tmpdir as tmpdir6 } from "node:os";
@@ -9462,7 +10493,7 @@ function findOcrScript() {
   return null;
 }
 function findPython() {
-  const venvPython = join22(homedir7(), ".open-agents", "venv", "bin", "python");
+  const venvPython = join26(homedir7(), ".open-agents", "venv", "bin", "python");
   if (existsSync18(venvPython)) {
     try {
       execSync15(`${JSON.stringify(venvPython)} -c "import cv2, pytesseract, numpy, PIL"`, {
@@ -9608,7 +10639,7 @@ var init_ocr_image_advanced = __esm({
           cmdParts.push("--output-dir", JSON.stringify(resolve19(this.workingDir, outputDir)));
         let debugDir;
         if (debug) {
-          debugDir = join22(tmpdir6(), `oa-ocr-debug-${Date.now()}`);
+          debugDir = join26(tmpdir6(), `oa-ocr-debug-${Date.now()}`);
           cmdParts.push("--debug-dir", debugDir);
         }
         try {
@@ -9707,7 +10738,7 @@ var init_ocr_image_advanced = __esm({
         if (region) {
           try {
             const [x, y, w, h] = region.split(",").map(Number);
-            const croppedPath = join22(tmpdir6(), `oa-ocr-crop-${Date.now()}.png`);
+            const croppedPath = join26(tmpdir6(), `oa-ocr-crop-${Date.now()}.png`);
             execSync15(`convert ${JSON.stringify(imagePath)} -crop ${w}x${h}+${x}+${y} +repage ${JSON.stringify(croppedPath)}`, { stdio: "pipe", timeout: 1e4 });
             inputPath = croppedPath;
           } catch {
@@ -9748,18 +10779,18 @@ Note: Advanced Python pipeline not available \u2014 install pytesseract, opencv-
 // packages/execution/dist/tools/browser-action.js
 import { execSync as execSync16, spawn as spawn8 } from "node:child_process";
 import { existsSync as existsSync19, readFileSync as readFileSync14 } from "node:fs";
-import { join as join23, dirname as dirname9 } from "node:path";
+import { join as join27, dirname as dirname9 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function findScrapeScript() {
   const candidates = [
     // Published npm package: dist/scripts/web_scrape.py
-    join23(__dirname3, "scripts", "web_scrape.py"),
+    join27(__dirname3, "scripts", "web_scrape.py"),
     // Published npm package (from node_modules): node_modules/open-agents-ai/dist/scripts/
-    join23(__dirname3, "..", "node_modules", "open-agents-ai", "dist", "scripts", "web_scrape.py"),
+    join27(__dirname3, "..", "node_modules", "open-agents-ai", "dist", "scripts", "web_scrape.py"),
     // Dev monorepo: packages/execution/src/tools/../../scripts/
-    join23(__dirname3, "..", "..", "scripts", "web_scrape.py"),
+    join27(__dirname3, "..", "..", "scripts", "web_scrape.py"),
     // Dev monorepo alt: packages/execution/scripts/
-    join23(__dirname3, "..", "scripts", "web_scrape.py")
+    join27(__dirname3, "..", "scripts", "web_scrape.py")
   ];
   return candidates.find((p) => existsSync19(p)) || candidates[0];
 }
@@ -10014,7 +11045,7 @@ var init_browser_action = __esm({
 // packages/execution/dist/tools/autoresearch.js
 import { execSync as execSync17, spawn as spawn9 } from "node:child_process";
 import { existsSync as existsSync20, readFileSync as readFileSync15, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, appendFileSync, copyFileSync } from "node:fs";
-import { join as join24, resolve as resolve20, dirname as dirname10 } from "node:path";
+import { join as join28, resolve as resolve20, dirname as dirname10 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function findAutoresearchScript(scriptName) {
   const thisDir = dirname10(fileURLToPath6(import.meta.url));
@@ -10116,7 +11147,7 @@ Requires: NVIDIA GPU, Python 3.10+, uv (astral.sh package manager).`;
       async execute(args) {
         const start = Date.now();
         const action = String(args["action"] ?? "status");
-        const workspacePath = String(args["workspace"] ?? join24(this.repoRoot, ".oa", "autoresearch"));
+        const workspacePath = String(args["workspace"] ?? join28(this.repoRoot, ".oa", "autoresearch"));
         try {
           switch (action) {
             case "setup":
@@ -10157,13 +11188,13 @@ Requires: NVIDIA GPU, Python 3.10+, uv (astral.sh package manager).`;
         const prepareScript = findAutoresearchScript("autoresearch-prepare.py");
         const trainScript = findAutoresearchScript("autoresearch-train.py");
         if (prepareScript) {
-          copyFileSync(prepareScript, join24(workspace, "prepare.py"));
+          copyFileSync(prepareScript, join28(workspace, "prepare.py"));
           output.push("Copied prepare.py template");
         } else {
           return { success: false, output: output.join("\n"), error: "autoresearch-prepare.py template not found in distribution", durationMs: Date.now() - start };
         }
         if (trainScript) {
-          copyFileSync(trainScript, join24(workspace, "train.py"));
+          copyFileSync(trainScript, join28(workspace, "train.py"));
           output.push("Copied train.py template");
         } else {
           return { success: false, output: output.join("\n"), error: "autoresearch-train.py template not found in distribution", durationMs: Date.now() - start };
@@ -10195,7 +11226,7 @@ name = "pytorch-cu128"
 url = "https://download.pytorch.org/whl/cu128"
 explicit = true
 `;
-        writeFileSync6(join24(workspace, "pyproject.toml"), pyprojectContent, "utf-8");
+        writeFileSync6(join28(workspace, "pyproject.toml"), pyprojectContent, "utf-8");
         output.push("Created pyproject.toml");
         try {
           execSync17("git rev-parse --git-dir", { cwd: workspace, encoding: "utf-8", timeout: 5e3 });
@@ -10237,7 +11268,7 @@ explicit = true
           const e = err;
           output.push(`Data prep warning: ${(e.stderr ?? e.stdout ?? "failed").slice(0, 500)}`);
         }
-        const tsvPath = join24(workspace, "results.tsv");
+        const tsvPath = join28(workspace, "results.tsv");
         if (!existsSync20(tsvPath)) {
           writeFileSync6(tsvPath, "commit	val_bpb	memory_gb	status	description\n", "utf-8");
           output.push("Created results.tsv");
@@ -10259,10 +11290,10 @@ Next steps:
       }
       // ── Run experiment ─────────────────────────────────────────────────────
       async run(workspace, args, start) {
-        if (!existsSync20(join24(workspace, "train.py"))) {
+        if (!existsSync20(join28(workspace, "train.py"))) {
           return { success: false, output: "", error: `No train.py found in ${workspace}. Run autoresearch(action="setup") first.`, durationMs: Date.now() - start };
         }
-        if (!existsSync20(join24(workspace, ".venv")) && existsSync20(join24(workspace, "pyproject.toml"))) {
+        if (!existsSync20(join28(workspace, ".venv")) && existsSync20(join28(workspace, "pyproject.toml"))) {
           try {
             execSync17("uv sync 2>&1", { cwd: workspace, encoding: "utf-8", timeout: 3e5 });
           } catch {
@@ -10270,7 +11301,7 @@ Next steps:
         }
         const timeoutMin = Number(args["timeout_minutes"] ?? 10);
         const timeoutMs = timeoutMin * 60 * 1e3;
-        const logPath = join24(workspace, "run.log");
+        const logPath = join28(workspace, "run.log");
         return new Promise((resolveResult) => {
           const proc = spawn9("uv", ["run", "train.py"], {
             cwd: workspace,
@@ -10341,7 +11372,7 @@ ${fullLog.slice(-2e3)}`,
               return;
             }
             try {
-              writeFileSync6(join24(workspace, ".last-result.json"), JSON.stringify(result, null, 2), "utf-8");
+              writeFileSync6(join28(workspace, ".last-result.json"), JSON.stringify(result, null, 2), "utf-8");
             } catch {
             }
             const memGB = (result.peak_vram_mb / 1024).toFixed(1);
@@ -10377,7 +11408,7 @@ ${fullLog.slice(-2e3)}`,
       }
       // ── Results ────────────────────────────────────────────────────────────
       getResults(workspace, start) {
-        const tsvPath = join24(workspace, "results.tsv");
+        const tsvPath = join28(workspace, "results.tsv");
         if (!existsSync20(tsvPath)) {
           return { success: false, output: "", error: `No results.tsv found. Run autoresearch(action="setup") first.`, durationMs: Date.now() - start };
         }
@@ -10404,7 +11435,7 @@ ${fullLog.slice(-2e3)}`,
       // ── Status ─────────────────────────────────────────────────────────────
       getStatus(workspace, start) {
         const output = [];
-        if (!existsSync20(join24(workspace, "train.py"))) {
+        if (!existsSync20(join28(workspace, "train.py"))) {
           return {
             success: true,
             output: `Autoresearch workspace not initialized at ${workspace}.
@@ -10427,7 +11458,7 @@ Run autoresearch(action="setup") to begin.`,
         } catch {
           output.push("GPU: not detected");
         }
-        const lastResultPath = join24(workspace, ".last-result.json");
+        const lastResultPath = join28(workspace, ".last-result.json");
         if (existsSync20(lastResultPath)) {
           try {
             const last = JSON.parse(readFileSync15(lastResultPath, "utf-8"));
@@ -10435,20 +11466,20 @@ Run autoresearch(action="setup") to begin.`,
           } catch {
           }
         }
-        const tsvPath = join24(workspace, "results.tsv");
+        const tsvPath = join28(workspace, "results.tsv");
         if (existsSync20(tsvPath)) {
           const lines = readFileSync15(tsvPath, "utf-8").trim().split("\n");
           output.push(`Experiments recorded: ${lines.length - 1}`);
         }
-        const cacheDir = join24(process.env["HOME"] ?? "~", ".cache", "autoresearch");
+        const cacheDir = join28(process.env["HOME"] ?? "~", ".cache", "autoresearch");
         output.push(`Data cache: ${existsSync20(cacheDir) ? "present" : "not found"} (${cacheDir})`);
         return { success: true, output: output.join("\n"), durationMs: Date.now() - start };
       }
       // ── Keep / Discard ─────────────────────────────────────────────────────
       keepExperiment(workspace, args, start) {
         const desc = String(args["description"] ?? "experiment");
-        const tsvPath = join24(workspace, "results.tsv");
-        const lastResultPath = join24(workspace, ".last-result.json");
+        const tsvPath = join28(workspace, "results.tsv");
+        const lastResultPath = join28(workspace, ".last-result.json");
         let valBpb = args["val_bpb"];
         let memGb = args["memory_gb"];
         if ((valBpb === void 0 || memGb === void 0) && existsSync20(lastResultPath)) {
@@ -10486,8 +11517,8 @@ Branch advanced. Ready for next experiment.`,
       }
       discardExperiment(workspace, args, start) {
         const desc = String(args["description"] ?? "experiment");
-        const tsvPath = join24(workspace, "results.tsv");
-        const lastResultPath = join24(workspace, ".last-result.json");
+        const tsvPath = join28(workspace, "results.tsv");
+        const lastResultPath = join28(workspace, ".last-result.json");
         let valBpb = args["val_bpb"];
         let memGb = args["memory_gb"];
         if ((valBpb === void 0 || memGb === void 0) && existsSync20(lastResultPath)) {
@@ -10533,8 +11564,8 @@ train.py reverted to last kept state. Ready for next experiment.`,
 
 // packages/execution/dist/tools/scheduler.js
 import { execSync as execSync18, exec as execCb } from "node:child_process";
-import { readFile as readFile9, writeFile as writeFile8, mkdir as mkdir4 } from "node:fs/promises";
-import { resolve as resolve21, join as join25 } from "node:path";
+import { readFile as readFile13, writeFile as writeFile12, mkdir as mkdir8 } from "node:fs/promises";
+import { resolve as resolve21, join as join29 } from "node:path";
 import { randomBytes as randomBytes3 } from "node:crypto";
 function isValidCron(expr) {
   const parts = expr.trim().split(/\s+/);
@@ -10618,7 +11649,7 @@ function installCronJob(task, workingDir) {
   const lines = getCurrentCrontab();
   const oaBin = findOaBinary();
   const logDir = resolve21(workingDir, ".oa", "scheduled", "logs");
-  const logFile = join25(logDir, `${task.id}.log`);
+  const logFile = join29(logDir, `${task.id}.log`);
   const storeFile = resolve21(workingDir, ".oa", "scheduled", "tasks.json");
   const taskEscaped = task.task.replace(/'/g, "'\\''");
   const taskId = task.id;
@@ -10651,7 +11682,7 @@ function listCronJobs() {
 async function loadStore(workingDir) {
   const storePath = resolve21(workingDir, ".oa", "scheduled", "tasks.json");
   try {
-    const raw = await readFile9(storePath, "utf-8");
+    const raw = await readFile13(storePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { tasks: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
@@ -10659,10 +11690,10 @@ async function loadStore(workingDir) {
 }
 async function saveStore(workingDir, store) {
   const dir = resolve21(workingDir, ".oa", "scheduled");
-  await mkdir4(dir, { recursive: true });
-  await mkdir4(join25(dir, "logs"), { recursive: true });
+  await mkdir8(dir, { recursive: true });
+  await mkdir8(join29(dir, "logs"), { recursive: true });
   store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeFile8(join25(dir, "tasks.json"), JSON.stringify(store, null, 2), "utf-8");
+  await writeFile12(join29(dir, "tasks.json"), JSON.stringify(store, null, 2), "utf-8");
 }
 var SCHEDULE_PRESETS, CRON_MARKER, SchedulerTool;
 var init_scheduler = __esm({
@@ -10882,7 +11913,7 @@ var init_scheduler = __esm({
           return { success: false, output: "", error: "id is required for logs action", durationMs: performance.now() - start };
         const logFile = resolve21(this.workingDir, ".oa", "scheduled", "logs", `${id}.log`);
         try {
-          const raw = await readFile9(logFile, "utf-8");
+          const raw = await readFile13(logFile, "utf-8");
           const truncated = raw.length > 1e4 ? "...(truncated)\n" + raw.slice(-1e4) : raw;
           return { success: true, output: `Logs for ${id}:
 ${truncated}`, durationMs: performance.now() - start };
@@ -10895,8 +11926,8 @@ ${truncated}`, durationMs: performance.now() - start };
 });
 
 // packages/execution/dist/tools/reminder.js
-import { readFile as readFile10, writeFile as writeFile9, mkdir as mkdir5 } from "node:fs/promises";
-import { resolve as resolve22, join as join26 } from "node:path";
+import { readFile as readFile14, writeFile as writeFile13, mkdir as mkdir9 } from "node:fs/promises";
+import { resolve as resolve22, join as join30 } from "node:path";
 import { randomBytes as randomBytes4 } from "node:crypto";
 function parseDueTime(due) {
   const lower = due.toLowerCase().trim();
@@ -10947,13 +11978,13 @@ function parseDueTime(due) {
 }
 async function getStorePath(workingDir) {
   const dir = resolve22(workingDir, ".oa", "scheduled");
-  await mkdir5(dir, { recursive: true });
-  return join26(dir, STORE_FILE);
+  await mkdir9(dir, { recursive: true });
+  return join30(dir, STORE_FILE);
 }
 async function loadReminderStore(workingDir) {
   const storePath = await getStorePath(workingDir);
   try {
-    const raw = await readFile10(storePath, "utf-8");
+    const raw = await readFile14(storePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { reminders: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
@@ -10962,7 +11993,7 @@ async function loadReminderStore(workingDir) {
 async function saveReminderStore(workingDir, store) {
   const storePath = await getStorePath(workingDir);
   store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeFile9(storePath, JSON.stringify(store, null, 2), "utf-8");
+  await writeFile13(storePath, JSON.stringify(store, null, 2), "utf-8");
 }
 async function getDueReminders(workingDir) {
   const store = await loadReminderStore(workingDir);
@@ -11208,13 +12239,13 @@ var init_reminder = __esm({
 });
 
 // packages/execution/dist/tools/agenda.js
-import { readFile as readFile11, writeFile as writeFile10, mkdir as mkdir6 } from "node:fs/promises";
-import { resolve as resolve23, join as join27 } from "node:path";
+import { readFile as readFile15, writeFile as writeFile14, mkdir as mkdir10 } from "node:fs/promises";
+import { resolve as resolve23, join as join31 } from "node:path";
 import { randomBytes as randomBytes5 } from "node:crypto";
 async function loadAttentionStore(workingDir) {
   const storePath = resolve23(workingDir, ".oa", "scheduled", "attention.json");
   try {
-    const raw = await readFile11(storePath, "utf-8");
+    const raw = await readFile15(storePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { items: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
@@ -11222,9 +12253,9 @@ async function loadAttentionStore(workingDir) {
 }
 async function saveAttentionStore(workingDir, store) {
   const dir = resolve23(workingDir, ".oa", "scheduled");
-  await mkdir6(dir, { recursive: true });
+  await mkdir10(dir, { recursive: true });
   store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeFile10(join27(dir, "attention.json"), JSON.stringify(store, null, 2), "utf-8");
+  await writeFile14(join31(dir, "attention.json"), JSON.stringify(store, null, 2), "utf-8");
 }
 async function getActiveAttentionItems(workingDir) {
   const store = await loadAttentionStore(workingDir);
@@ -11520,7 +12551,7 @@ ${sections.join("\n")}`,
       async loadScheduleStore() {
         try {
           const storePath = resolve23(this.workingDir, ".oa", "scheduled", "tasks.json");
-          const raw = await readFile11(storePath, "utf-8");
+          const raw = await readFile15(storePath, "utf-8");
           const store = JSON.parse(raw);
           return store.tasks ?? [];
         } catch {
@@ -11534,7 +12565,7 @@ ${sections.join("\n")}`,
 // packages/execution/dist/tools/opencode.js
 import { execSync as execSync19, spawn as spawn10 } from "node:child_process";
 import { existsSync as existsSync21 } from "node:fs";
-import { join as join28, resolve as resolve24 } from "node:path";
+import { join as join32, resolve as resolve24 } from "node:path";
 function findOpencode() {
   for (const cmd of ["opencode"]) {
     try {
@@ -11546,8 +12577,8 @@ function findOpencode() {
   }
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
   const candidates = [
-    join28(homeDir, ".opencode", "bin", "opencode"),
-    join28(homeDir, "bin", "opencode"),
+    join32(homeDir, ".opencode", "bin", "opencode"),
+    join32(homeDir, "bin", "opencode"),
     "/usr/local/bin/opencode"
   ];
   for (const p of candidates) {
@@ -11808,7 +12839,7 @@ var init_opencode = __esm({
 // packages/execution/dist/tools/factory.js
 import { execSync as execSync20, spawn as spawn11 } from "node:child_process";
 import { existsSync as existsSync22 } from "node:fs";
-import { join as join29 } from "node:path";
+import { join as join33 } from "node:path";
 function findDroid() {
   for (const cmd of ["droid"]) {
     try {
@@ -11820,8 +12851,8 @@ function findDroid() {
   }
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
   const candidates = [
-    join29(homeDir, ".factory", "bin", "droid"),
-    join29(homeDir, "bin", "droid"),
+    join33(homeDir, ".factory", "bin", "droid"),
+    join33(homeDir, "bin", "droid"),
     "/usr/local/bin/droid"
   ];
   for (const p of candidates) {
@@ -12116,8 +13147,8 @@ var init_factory = __esm({
 
 // packages/execution/dist/tools/cron-agent.js
 import { execSync as execSync21 } from "node:child_process";
-import { readFile as readFile12, writeFile as writeFile11, mkdir as mkdir7 } from "node:fs/promises";
-import { resolve as resolve25, join as join30 } from "node:path";
+import { readFile as readFile16, writeFile as writeFile15, mkdir as mkdir11 } from "node:fs/promises";
+import { resolve as resolve25, join as join34 } from "node:path";
 import { randomBytes as randomBytes6 } from "node:crypto";
 function isValidCron2(expr) {
   const parts = expr.trim().split(/\s+/);
@@ -12203,7 +13234,7 @@ function installCronAgentJob(job, workingDir) {
   const lines = getCurrentCrontab2();
   const oaBin = findOaBinary2();
   const logDir = resolve25(workingDir, ".oa", "cron-agents", "logs");
-  const logFile = join30(logDir, `${job.id}.log`);
+  const logFile = join34(logDir, `${job.id}.log`);
   const storeFile = resolve25(workingDir, ".oa", "cron-agents", "store.json");
   const taskEscaped = job.task.replace(/'/g, "'\\''");
   const jobId = job.id;
@@ -12233,7 +13264,7 @@ function removeCronAgentJob(jobId) {
 async function loadStore2(workingDir) {
   const storePath = resolve25(workingDir, ".oa", "cron-agents", "store.json");
   try {
-    const raw = await readFile12(storePath, "utf-8");
+    const raw = await readFile16(storePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { jobs: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
@@ -12241,10 +13272,10 @@ async function loadStore2(workingDir) {
 }
 async function saveStore2(workingDir, store) {
   const dir = resolve25(workingDir, ".oa", "cron-agents");
-  await mkdir7(dir, { recursive: true });
-  await mkdir7(join30(dir, "logs"), { recursive: true });
+  await mkdir11(dir, { recursive: true });
+  await mkdir11(join34(dir, "logs"), { recursive: true });
   store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeFile11(join30(dir, "store.json"), JSON.stringify(store, null, 2), "utf-8");
+  await writeFile15(join34(dir, "store.json"), JSON.stringify(store, null, 2), "utf-8");
 }
 var LONG_HORIZON_PRESETS, CRON_AGENT_MARKER, CronAgentTool;
 var init_cron_agent = __esm({
@@ -12509,7 +13540,7 @@ var init_cron_agent = __esm({
           return { success: false, output: "", error: "id is required", durationMs: performance.now() - start };
         const logFile = resolve25(this.workingDir, ".oa", "cron-agents", "logs", `${id}.log`);
         try {
-          const raw = await readFile12(logFile, "utf-8");
+          const raw = await readFile16(logFile, "utf-8");
           const truncated = raw.length > 2e4 ? "...(truncated)\n" + raw.slice(-2e4) : raw;
           return { success: true, output: `Logs for ${id}:
 ${truncated}`, durationMs: performance.now() - start };
@@ -12580,9 +13611,9 @@ ${truncated}`, durationMs: performance.now() - start };
 });
 
 // packages/execution/dist/tools/nexus.js
-import { readFile as readFile13, writeFile as writeFile12, mkdir as mkdir8, chmod, unlink, readdir as readdir3, open as fsOpen } from "node:fs/promises";
+import { readFile as readFile17, writeFile as writeFile16, mkdir as mkdir12, chmod, unlink, readdir as readdir3, open as fsOpen } from "node:fs/promises";
 import { existsSync as existsSync23, readFileSync as readFileSync16, watch as fsWatchLocal } from "node:fs";
-import { resolve as resolve26, join as join31 } from "node:path";
+import { resolve as resolve26, join as join35 } from "node:path";
 import { randomBytes as randomBytes7, createCipheriv, createDecipheriv, scryptSync, createHash } from "node:crypto";
 import { execSync as execSync22, spawn as spawn12 } from "node:child_process";
 import { hostname, userInfo } from "node:os";
@@ -14555,7 +15586,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
       }
       async ensureDir() {
         if (!existsSync23(this.nexusDir)) {
-          await mkdir8(this.nexusDir, { recursive: true });
+          await mkdir12(this.nexusDir, { recursive: true });
         }
       }
       async execute(args) {
@@ -14675,7 +15706,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
       // Daemon management
       // =========================================================================
       getDaemonPid() {
-        const pidFile = join31(this.nexusDir, "daemon.pid");
+        const pidFile = join35(this.nexusDir, "daemon.pid");
         if (!existsSync23(pidFile))
           return null;
         try {
@@ -14701,12 +15732,12 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             throw new Error("Nexus daemon not running. Use action 'connect' first.");
         }
         const cmdId = randomBytes7(8).toString("hex");
-        const cmdFile = join31(this.nexusDir, "cmd.json");
-        const respFile = join31(this.nexusDir, "resp.json");
+        const cmdFile = join35(this.nexusDir, "cmd.json");
+        const respFile = join35(this.nexusDir, "resp.json");
         if (existsSync23(respFile))
           await unlink(respFile).catch(() => {
           });
-        await writeFile12(cmdFile, JSON.stringify({ id: cmdId, action, args }, null, 2));
+        await writeFile16(cmdFile, JSON.stringify({ id: cmdId, action, args }, null, 2));
         const pollMs = 50;
         const polls = Math.ceil(timeoutMs / pollMs);
         let resolved = false;
@@ -14738,7 +15769,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             if (!existsSync23(respFile))
               continue;
             try {
-              const resp = JSON.parse(await readFile13(respFile, "utf8"));
+              const resp = JSON.parse(await readFile17(respFile, "utf8"));
               if (resp.id === cmdId) {
                 resolved = true;
                 return resp.output || (resp.ok ? "OK" : "Failed");
@@ -14761,7 +15792,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         }
         if (existsSync23(respFile)) {
           try {
-            const resp = JSON.parse(await readFile13(respFile, "utf8"));
+            const resp = JSON.parse(await readFile17(respFile, "utf8"));
             if (resp.id === cmdId) {
               return resp.output || (resp.ok ? "OK" : "Failed");
             }
@@ -14786,7 +15817,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         const currentScriptHash = createHash("sha256").update(DAEMON_SCRIPT).digest("hex").slice(0, 16);
         const existingPid = this.getDaemonPid();
         if (existingPid) {
-          const daemonPath2 = join31(this.nexusDir, "nexus-daemon.mjs");
+          const daemonPath2 = join35(this.nexusDir, "nexus-daemon.mjs");
           let needsRestart = true;
           if (existsSync23(daemonPath2)) {
             try {
@@ -14810,16 +15841,16 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             } catch {
             }
             for (const f of ["daemon.pid", "status.json", "cmd.json", "resp.json"]) {
-              const p = join31(this.nexusDir, f);
+              const p = join35(this.nexusDir, f);
               if (existsSync23(p))
                 await unlink(p).catch(() => {
                 });
             }
           } else {
-            const statusFile2 = join31(this.nexusDir, "status.json");
+            const statusFile2 = join35(this.nexusDir, "status.json");
             if (existsSync23(statusFile2)) {
               try {
-                const status = JSON.parse(await readFile13(statusFile2, "utf8"));
+                const status = JSON.parse(await readFile17(statusFile2, "utf8"));
                 if (status.connected && status.peerId) {
                   await this.ensureWallet();
                   return `Already connected (pid: ${existingPid}, peerId: ${status.peerId})`;
@@ -14835,7 +15866,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           }
         }
         for (const f of ["daemon.pid", "status.json", "cmd.json", "resp.json"]) {
-          const p = join31(this.nexusDir, f);
+          const p = join35(this.nexusDir, f);
           if (existsSync23(p))
             await unlink(p).catch(() => {
             });
@@ -14853,7 +15884,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           });
         });
         try {
-          const nexusPkg = join31(nodeModulesDir, "open-agents-nexus", "package.json");
+          const nexusPkg = join35(nodeModulesDir, "open-agents-nexus", "package.json");
           if (existsSync23(nexusPkg)) {
             nexusResolved = true;
             try {
@@ -14864,7 +15895,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           } else {
             try {
               const globalDir = await execAsync2("npm root -g", { timeout: 5e3 });
-              const globalPkg = join31(globalDir, "open-agents-nexus", "package.json");
+              const globalPkg = join35(globalDir, "open-agents-nexus", "package.json");
               if (existsSync23(globalPkg)) {
                 nexusResolved = true;
                 try {
@@ -14909,8 +15940,8 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           }
         }
         await this.ensureWallet();
-        const daemonPath = join31(this.nexusDir, "nexus-daemon.mjs");
-        await writeFile12(daemonPath, DAEMON_SCRIPT);
+        const daemonPath = join35(this.nexusDir, "nexus-daemon.mjs");
+        await writeFile16(daemonPath, DAEMON_SCRIPT);
         const agentName = args.agent_name || "open-agents-node";
         const agentType = args.agent_type || "general";
         const nodePaths = [nodeModulesDir];
@@ -14920,8 +15951,8 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         } catch {
         }
         const { openSync: openSync2, closeSync: closeSync2 } = await import("node:fs");
-        const daemonLogPath = join31(this.nexusDir, "daemon.log");
-        const daemonErrPath = join31(this.nexusDir, "daemon.err");
+        const daemonLogPath = join35(this.nexusDir, "daemon.log");
+        const daemonErrPath = join35(this.nexusDir, "daemon.err");
         const outFd = openSync2(daemonLogPath, "w");
         const errFd = openSync2(daemonErrPath, "w");
         const child = spawn12("node", [daemonPath, this.nexusDir, agentName, agentType], {
@@ -14939,16 +15970,16 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           closeSync2(errFd);
         } catch {
         }
-        const statusFile = join31(this.nexusDir, "status.json");
+        const statusFile = join35(this.nexusDir, "status.json");
         for (let i = 0; i < 40; i++) {
           await new Promise((r) => setTimeout(r, 500));
           if (existsSync23(statusFile)) {
             try {
-              const status = JSON.parse(await readFile13(statusFile, "utf8"));
+              const status = JSON.parse(await readFile17(statusFile, "utf8"));
               if (status.error) {
                 let errTail = "";
                 try {
-                  errTail = (await readFile13(daemonErrPath, "utf8")).slice(-300);
+                  errTail = (await readFile17(daemonErrPath, "utf8")).slice(-300);
                 } catch {
                 }
                 return `Nexus daemon failed to connect: ${status.error}${errTail ? "\n" + errTail : ""}`;
@@ -14970,12 +16001,12 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         const pid = this.getDaemonPid();
         let earlyError = "";
         try {
-          earlyError = (await readFile13(daemonErrPath, "utf8")).slice(-500);
+          earlyError = (await readFile17(daemonErrPath, "utf8")).slice(-500);
         } catch {
         }
         let earlyOutput = "";
         try {
-          earlyOutput = (await readFile13(daemonLogPath, "utf8")).slice(-500);
+          earlyOutput = (await readFile17(daemonLogPath, "utf8")).slice(-500);
         } catch {
         }
         if (pid) {
@@ -14998,7 +16029,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         } catch {
         }
         for (const f of ["daemon.pid", "status.json", "cmd.json", "resp.json"]) {
-          const p = join31(this.nexusDir, f);
+          const p = join35(this.nexusDir, f);
           if (existsSync23(p))
             await unlink(p).catch(() => {
             });
@@ -15009,11 +16040,11 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         const pid = this.getDaemonPid();
         if (!pid)
           return "Nexus daemon not running. Use action 'connect' to start.";
-        const statusFile = join31(this.nexusDir, "status.json");
+        const statusFile = join35(this.nexusDir, "status.json");
         if (!existsSync23(statusFile))
           return `Daemon running (pid: ${pid}) but no status yet.`;
         try {
-          const status = JSON.parse(await readFile13(statusFile, "utf8"));
+          const status = JSON.parse(await readFile17(statusFile, "utf8"));
           const lines = [
             `Nexus Status (v1.5.0)`,
             `  Connected: ${status.connected}`,
@@ -15024,10 +16055,10 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             `  Capabilities: ${(status.capabilities || []).length ? (status.capabilities || []).join(", ") : "none"}`,
             `  Blocked peers: ${(status.blockedPeers || []).length || 0}`
           ];
-          const walletPath = join31(this.nexusDir, "wallet.enc");
+          const walletPath = join35(this.nexusDir, "wallet.enc");
           if (existsSync23(walletPath)) {
             try {
-              const w = JSON.parse(await readFile13(walletPath, "utf8"));
+              const w = JSON.parse(await readFile17(walletPath, "utf8"));
               lines.push(`  Wallet: ${w.address}`);
             } catch {
               lines.push(`  Wallet: corrupt`);
@@ -15035,14 +16066,14 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           } else {
             lines.push(`  Wallet: not configured`);
           }
-          const inboxDir = join31(this.nexusDir, "inbox");
+          const inboxDir = join35(this.nexusDir, "inbox");
           if (existsSync23(inboxDir)) {
             try {
               const roomDirs = await readdir3(inboxDir);
               let totalMsgs = 0;
               for (const rd of roomDirs) {
                 try {
-                  totalMsgs += (await readdir3(join31(inboxDir, rd))).length;
+                  totalMsgs += (await readdir3(join35(inboxDir, rd))).length;
                 } catch {
                 }
               }
@@ -15089,9 +16120,9 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
       }
       async doReadMessages(args) {
         const roomId = args.room_id;
-        const inboxDir = join31(this.nexusDir, "inbox");
+        const inboxDir = join35(this.nexusDir, "inbox");
         if (roomId) {
-          const roomInbox = join31(inboxDir, roomId);
+          const roomInbox = join35(inboxDir, roomId);
           if (!existsSync23(roomInbox))
             return `No messages in room: ${roomId}`;
           const files = (await readdir3(roomInbox)).sort().slice(-20);
@@ -15100,7 +16131,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           const messages = [`Messages in ${roomId} (last ${files.length}):`];
           for (const f of files) {
             try {
-              const msg = JSON.parse(await readFile13(join31(roomInbox, f), "utf8"));
+              const msg = JSON.parse(await readFile17(join35(roomInbox, f), "utf8"));
               const sender = (msg.sender || "unknown").slice(0, 12);
               messages.push(`  [${new Date(msg.timestamp).toLocaleTimeString()}] ${sender}...: ${msg.content}`);
             } catch {
@@ -15116,7 +16147,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         const lines = ["Inbox:"];
         for (const rd of roomDirs) {
           try {
-            const count = (await readdir3(join31(inboxDir, rd))).length;
+            const count = (await readdir3(join35(inboxDir, rd))).length;
             lines.push(`  ${rd}: ${count} message(s)`);
           } catch {
           }
@@ -15128,12 +16159,12 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
       // ---------------------------------------------------------------------------
       async doWalletStatus() {
         await this.ensureDir();
-        const walletPath = join31(this.nexusDir, "wallet.enc");
+        const walletPath = join35(this.nexusDir, "wallet.enc");
         if (!existsSync23(walletPath)) {
           return "No wallet configured. Use wallet_create to set one up.";
         }
         try {
-          const w = JSON.parse(await readFile13(walletPath, "utf8"));
+          const w = JSON.parse(await readFile17(walletPath, "utf8"));
           const lines = [
             `Wallet Status:`,
             `  Address: ${w.address}`,
@@ -15167,7 +16198,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
       }
       async doWalletCreate(args) {
         await this.ensureDir();
-        const walletPath = join31(this.nexusDir, "wallet.enc");
+        const walletPath = join35(this.nexusDir, "wallet.enc");
         if (existsSync23(walletPath))
           return "Wallet already exists. Delete wallet.enc to create a new one.";
         const userAddress = args.wallet_address;
@@ -15213,7 +16244,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         const cipher = createCipheriv("aes-256-gcm", key, iv);
         let enc = cipher.update(privKeyHex, "utf8", "hex");
         enc += cipher.final("hex");
-        const x402KeyPath = join31(this.nexusDir, "x402-wallet.key");
+        const x402KeyPath = join35(this.nexusDir, "x402-wallet.key");
         const x402Fh = await fsOpen(x402KeyPath, "w", 384);
         await x402Fh.writeFile("0x" + privKeyHex);
         await x402Fh.close();
@@ -15251,7 +16282,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
        * Silent — no user output, just ensures the files exist.
        */
       async ensureWallet() {
-        const walletPath = join31(this.nexusDir, "wallet.enc");
+        const walletPath = join35(this.nexusDir, "wallet.enc");
         if (existsSync23(walletPath))
           return;
         let address;
@@ -15275,7 +16306,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         const cipher = createCipheriv("aes-256-gcm", key, iv);
         let enc = cipher.update(privKeyHex, "utf8", "hex");
         enc += cipher.final("hex");
-        const x402KeyPath = join31(this.nexusDir, "x402-wallet.key");
+        const x402KeyPath = join35(this.nexusDir, "x402-wallet.key");
         const x402Fh = await fsOpen(x402KeyPath, "w", 384);
         await x402Fh.writeFile("0x" + privKeyHex);
         await x402Fh.close();
@@ -15335,12 +16366,12 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
       // ---------------------------------------------------------------------------
       async doLedgerStatus() {
         await this.ensureDir();
-        const ledgerPath = join31(this.nexusDir, "ledger.jsonl");
+        const ledgerPath = join35(this.nexusDir, "ledger.jsonl");
         if (!existsSync23(ledgerPath)) {
           return "No ledger entries. Earnings and spending will be tracked here after x402 transactions.";
         }
         try {
-          const raw = await readFile13(ledgerPath, "utf8");
+          const raw = await readFile17(ledgerPath, "utf8");
           const entries = raw.trim().split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
           if (entries.length === 0) {
             return "Ledger is empty. No transactions recorded.";
@@ -15377,11 +16408,11 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         }
       }
       async getLedgerSummary() {
-        const ledgerPath = join31(this.nexusDir, "ledger.jsonl");
+        const ledgerPath = join35(this.nexusDir, "ledger.jsonl");
         if (!existsSync23(ledgerPath))
           return null;
         try {
-          const raw = await readFile13(ledgerPath, "utf8");
+          const raw = await readFile17(ledgerPath, "utf8");
           const entries = raw.trim().split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
           let totalEarned = 0n, totalSpent = 0n;
           for (const e of entries) {
@@ -15402,25 +16433,25 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
       }
       async appendLedger(entry) {
         await this.ensureDir();
-        const ledgerPath = join31(this.nexusDir, "ledger.jsonl");
+        const ledgerPath = join35(this.nexusDir, "ledger.jsonl");
         const line = JSON.stringify(entry) + "\n";
-        await writeFile12(ledgerPath, existsSync23(ledgerPath) ? await readFile13(ledgerPath, "utf8") + line : line);
+        await writeFile16(ledgerPath, existsSync23(ledgerPath) ? await readFile17(ledgerPath, "utf8") + line : line);
       }
       // ---------------------------------------------------------------------------
       // Step 4: Budget Policy — Spending limits and auto-approve thresholds
       // ---------------------------------------------------------------------------
       async loadBudget() {
-        const budgetPath = join31(this.nexusDir, "budget.json");
+        const budgetPath = join35(this.nexusDir, "budget.json");
         if (!existsSync23(budgetPath))
           return null;
         try {
-          return JSON.parse(await readFile13(budgetPath, "utf8"));
+          return JSON.parse(await readFile17(budgetPath, "utf8"));
         } catch {
           return null;
         }
       }
       async ensureDefaultBudget() {
-        const budgetPath = join31(this.nexusDir, "budget.json");
+        const budgetPath = join35(this.nexusDir, "budget.json");
         if (existsSync23(budgetPath))
           return;
         const defaultBudget = {
@@ -15441,7 +16472,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           deniedPeers: []
         };
         await this.ensureDir();
-        await writeFile12(budgetPath, JSON.stringify(defaultBudget, null, 2));
+        await writeFile16(budgetPath, JSON.stringify(defaultBudget, null, 2));
       }
       async doBudgetStatus() {
         await this.ensureDir();
@@ -15490,17 +16521,17 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         if (changes.length === 0) {
           return "No budget parameters provided. Use daily_limit, per_invoke_max, or auto_approve_below.";
         }
-        const budgetPath = join31(this.nexusDir, "budget.json");
-        await writeFile12(budgetPath, JSON.stringify(budget, null, 2));
+        const budgetPath = join35(this.nexusDir, "budget.json");
+        await writeFile16(budgetPath, JSON.stringify(budget, null, 2));
         return `Budget updated: ${changes.join(", ")}`;
       }
       async getTodaySpending() {
-        const ledgerPath = join31(this.nexusDir, "ledger.jsonl");
+        const ledgerPath = join35(this.nexusDir, "ledger.jsonl");
         if (!existsSync23(ledgerPath))
           return 0;
         try {
           const todayPrefix = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-          const raw = await readFile13(ledgerPath, "utf8");
+          const raw = await readFile17(ledgerPath, "utf8");
           let total = 0;
           for (const line of raw.trim().split("\n")) {
             if (!line.trim())
@@ -15539,10 +16570,10 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         if (todaySpent + amountUsdc > budget.dailyLimitUsdc) {
           return { allowed: false, reason: `Would exceed daily limit ($${((todaySpent + amountUsdc) / 1e6).toFixed(6)} > $${(budget.dailyLimitUsdc / 1e6).toFixed(6)})` };
         }
-        const walletPath = join31(this.nexusDir, "wallet.enc");
+        const walletPath = join35(this.nexusDir, "wallet.enc");
         if (existsSync23(walletPath)) {
           try {
-            const w = JSON.parse(await readFile13(walletPath, "utf8"));
+            const w = JSON.parse(await readFile17(walletPath, "utf8"));
             if (w.version === 2 && w.address) {
               const balance = await this.queryUsdcBalance(w.address, w.chainId || 8453);
               if (balance !== null && Number(balance) < budget.circuitBreakerUsdc) {
@@ -15570,10 +16601,10 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         const budgetResult = await this.checkBudget(amountSmallest, "transfer:direct", targetAddress);
         if (!budgetResult.allowed)
           return `BLOCKED by budget policy: ${budgetResult.reason}`;
-        const walletPath = join31(this.nexusDir, "wallet.enc");
+        const walletPath = join35(this.nexusDir, "wallet.enc");
         if (!existsSync23(walletPath))
           throw new Error("No wallet. Use wallet_create first.");
-        const w = JSON.parse(await readFile13(walletPath, "utf8"));
+        const w = JSON.parse(await readFile17(walletPath, "utf8"));
         if (!w.encryptedKey)
           throw new Error("User-managed wallet cannot spend (no private key)");
         const salt = Buffer.from(w.salt, "hex");
@@ -15631,7 +16662,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             capability: "transfer:direct",
             note: "signed, awaiting submission"
           });
-          const proofFile = join31(this.nexusDir, "pending-transfer.json");
+          const proofFile = join35(this.nexusDir, "pending-transfer.json");
           const proof = {
             from: account.address,
             to: targetAddress,
@@ -15644,7 +16675,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             usdcContract: USDC_ADDRESS,
             createdAt: (/* @__PURE__ */ new Date()).toISOString()
           };
-          await writeFile12(proofFile, JSON.stringify(proof, null, 2));
+          await writeFile16(proofFile, JSON.stringify(proof, null, 2));
           return [
             `Transfer signed (EIP-3009 TransferWithAuthorization):`,
             `  From: ${account.address}`,
@@ -15673,10 +16704,10 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           throw new Error("prompt is required");
         const estimatedTokens = Math.ceil(prompt.length / 4) + 1e3;
         let estimatedCostSmallest = 0;
-        const pricingPath = join31(this.nexusDir, "pricing.json");
+        const pricingPath = join35(this.nexusDir, "pricing.json");
         if (existsSync23(pricingPath)) {
           try {
-            const pricing = JSON.parse(await readFile13(pricingPath, "utf8"));
+            const pricing = JSON.parse(await readFile17(pricingPath, "utf8"));
             const modelPricing = (pricing.models || []).find((m) => m.model === model || m.model.startsWith(model.split(":")[0]));
             if (modelPricing?.pricing?.input_per_1m_tokens > 0) {
               estimatedCostSmallest = Math.ceil(estimatedTokens / 1e6 * modelPricing.pricing.input_per_1m_tokens * 1e6);
@@ -15793,7 +16824,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           const bar = (s) => "\u2588".repeat(Math.round(s / 5)) + "\u2591".repeat(20 - Math.round(s / 5));
           const mem = vramMb > 24e3 ? 95 : vramMb > 16e3 ? 80 : vramMb > 8e3 ? 60 : vramMb > 0 ? 40 : 20;
           await this.ensureDir();
-          await writeFile12(join31(this.nexusDir, "inference-proof.json"), JSON.stringify({
+          await writeFile16(join35(this.nexusDir, "inference-proof.json"), JSON.stringify({
             modelName,
             gpuName,
             vramMb,
@@ -16434,6 +17465,7 @@ __export(dist_exports, {
   DesktopClickTool: () => DesktopClickTool,
   DesktopDescribeTool: () => DesktopDescribeTool,
   DiagnosticTool: () => DiagnosticTool,
+  ExplorationCultureTool: () => ExplorationCultureTool,
   ExploreToolsTool: () => ExploreToolsTool,
   FactoryTool: () => FactoryTool,
   FileEditTool: () => FileEditTool,
@@ -16443,9 +17475,11 @@ __export(dist_exports, {
   GitInfoTool: () => GitInfoTool,
   GlobFindTool: () => GlobFindTool,
   GrepSearchTool: () => GrepSearchTool,
+  IdentityKernelTool: () => IdentityKernelTool,
   ImageReadTool: () => ImageReadTool,
   ListDirectoryTool: () => ListDirectoryTool,
   ManageToolsTool: () => ManageToolsTool,
+  MemoryMetabolismTool: () => MemoryMetabolismTool,
   MemoryReadTool: () => MemoryReadTool,
   MemorySearchTool: () => MemorySearchTool,
   MemoryWriteTool: () => MemoryWriteTool,
@@ -16455,6 +17489,7 @@ __export(dist_exports, {
   OcrPdfTool: () => OcrPdfTool,
   OpenCodeTool: () => OpenCodeTool,
   PdfToTextTool: () => PdfToTextTool,
+  ReflectionIntegrityTool: () => ReflectionIntegrityTool,
   ReminderTool: () => ReminderTool,
   ReplTool: () => ReplTool,
   SchedulerTool: () => SchedulerTool,
@@ -16542,6 +17577,10 @@ var init_dist2 = __esm({
     init_structured_file();
     init_code_sandbox();
     init_repl();
+    init_memory_metabolism();
+    init_identity_kernel();
+    init_reflection_integrity();
+    init_exploration_culture();
     init_structured_read();
     init_vision();
     init_desktop_click();
@@ -17242,12 +18281,12 @@ var init_dist3 = __esm({
 
 // packages/orchestrator/dist/promptLoader.js
 import { readFileSync as readFileSync18, existsSync as existsSync25 } from "node:fs";
-import { join as join32, dirname as dirname12 } from "node:path";
+import { join as join36, dirname as dirname12 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function loadPrompt(promptPath, vars) {
   let content = cache.get(promptPath);
   if (content === void 0) {
-    const fullPath = join32(PROMPTS_DIR, promptPath);
+    const fullPath = join36(PROMPTS_DIR, promptPath);
     if (!existsSync25(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
@@ -17264,7 +18303,7 @@ var init_promptLoader = __esm({
     "use strict";
     __filename = fileURLToPath7(import.meta.url);
     __dirname4 = dirname12(__filename);
-    PROMPTS_DIR = join32(__dirname4, "..", "prompts");
+    PROMPTS_DIR = join36(__dirname4, "..", "prompts");
     cache = /* @__PURE__ */ new Map();
   }
 });
@@ -17627,8 +18666,8 @@ var init_code_retriever = __esm({
         });
       }
       async getFileContent(filePath, startLine, endLine) {
-        const { readFile: readFile18 } = await import("node:fs/promises");
-        const content = await readFile18(filePath, "utf-8");
+        const { readFile: readFile22 } = await import("node:fs/promises");
+        const content = await readFile22(filePath, "utf-8");
         if (startLine === void 0)
           return content;
         const lines = content.split("\n");
@@ -17643,8 +18682,8 @@ var init_code_retriever = __esm({
 // packages/retrieval/dist/lexicalSearch.js
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import { readFile as readFile14, readdir as readdir4, stat as stat3 } from "node:fs/promises";
-import { join as join33, extname as extname7 } from "node:path";
+import { readFile as readFile18, readdir as readdir4, stat as stat3 } from "node:fs/promises";
+import { join as join37, extname as extname7 } from "node:path";
 async function searchByPath(pathPattern, options) {
   const allFiles = await collectFiles(options.rootDir, options.includeGlobs ?? DEFAULT_INCLUDE_GLOBS, options.excludeGlobs ?? DEFAULT_EXCLUDE_GLOBS);
   const pattern = options.caseInsensitive ? pathPattern.toLowerCase() : pathPattern;
@@ -17749,7 +18788,7 @@ async function searchWithNodeFallback(pattern, kind, options) {
     if (results.length >= maxMatches)
       break;
     try {
-      const content = await readFile14(filePath, "utf-8");
+      const content = await readFile18(filePath, "utf-8");
       const contentLines = content.split("\n");
       for (let i = 0; i < contentLines.length; i++) {
         if (results.length >= maxMatches)
@@ -17786,7 +18825,7 @@ async function walkForFiles(rootDir, dir, excludeGlobs, results) {
       continue;
     if (excludeGlobs.some((g) => entry.name === g || matchesGlob(entry.name, g)))
       continue;
-    const absPath = join33(dir, entry.name);
+    const absPath = join37(dir, entry.name);
     if (entry.isDirectory()) {
       await walkForFiles(rootDir, absPath, excludeGlobs, results);
     } else if (entry.isFile()) {
@@ -18092,8 +19131,8 @@ var init_graphExpand = __esm({
 });
 
 // packages/retrieval/dist/snippetPacker.js
-import { readFile as readFile15 } from "node:fs/promises";
-import { join as join34 } from "node:path";
+import { readFile as readFile19 } from "node:fs/promises";
+import { join as join38 } from "node:path";
 async function packSnippets(requests, opts = {}) {
   const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
   const contextLines = opts.contextLines ?? DEFAULT_CONTEXT_LINES;
@@ -18119,10 +19158,10 @@ async function packSnippets(requests, opts = {}) {
   return { packed, dropped, totalTokens };
 }
 async function extractSnippet(req, repoRoot, contextLines = DEFAULT_CONTEXT_LINES) {
-  const absPath = req.filePath.startsWith("/") ? req.filePath : join34(repoRoot, req.filePath);
+  const absPath = req.filePath.startsWith("/") ? req.filePath : join38(repoRoot, req.filePath);
   let content;
   try {
-    content = await readFile15(absPath, "utf-8");
+    content = await readFile19(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -20713,8 +21752,8 @@ ${marker}` : marker);
           return;
         try {
           const { mkdirSync: mkdirSync21, writeFileSync: writeFileSync20 } = __require("node:fs");
-          const { join: join58 } = __require("node:path");
-          const sessionDir = join58(this._workingDirectory, ".oa", "session", this._sessionId);
+          const { join: join62 } = __require("node:path");
+          const sessionDir = join62(this._workingDirectory, ".oa", "session", this._sessionId);
           mkdirSync21(sessionDir, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -20727,7 +21766,7 @@ ${marker}` : marker);
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync20(join58(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync20(join62(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -21995,7 +23034,7 @@ ${transcript}`
 // packages/orchestrator/dist/nexusBackend.js
 import { existsSync as existsSync26, statSync as statSync9, openSync, readSync, closeSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync8 } from "node:fs";
 import { watch as fsWatch } from "node:fs";
-import { join as join35 } from "node:path";
+import { join as join39 } from "node:path";
 import { tmpdir as tmpdir7 } from "node:os";
 import { randomBytes as randomBytes8 } from "node:crypto";
 var NexusAgenticBackend;
@@ -22145,7 +23184,7 @@ var init_nexusBackend = __esm({
        * Falls back to unary + word-split if streaming setup fails.
        */
       async *chatCompletionStream(request) {
-        const streamFile = join35(tmpdir7(), `nexus-stream-${randomBytes8(6).toString("hex")}.jsonl`);
+        const streamFile = join39(tmpdir7(), `nexus-stream-${randomBytes8(6).toString("hex")}.jsonl`);
         writeFileSync8(streamFile, "", "utf8");
         const daemonArgs = {
           model: this.model,
@@ -23182,7 +24221,7 @@ __export(listen_exports, {
 });
 import { spawn as spawn15, execSync as execSync23 } from "node:child_process";
 import { existsSync as existsSync27, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, readdirSync as readdirSync6 } from "node:fs";
-import { join as join36, dirname as dirname13 } from "node:path";
+import { join as join40, dirname as dirname13 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 import { EventEmitter } from "node:events";
@@ -23268,12 +24307,12 @@ function findMicCaptureCommand() {
 function findLiveWhisperScript() {
   const thisDir = dirname13(fileURLToPath8(import.meta.url));
   const candidates = [
-    join36(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
-    join36(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
-    join36(thisDir, "../../execution/scripts/live-whisper.py"),
+    join40(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
+    join40(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
+    join40(thisDir, "../../execution/scripts/live-whisper.py"),
     // npm install layout — scripts bundled alongside dist
-    join36(thisDir, "../scripts/live-whisper.py"),
-    join36(thisDir, "../../scripts/live-whisper.py")
+    join40(thisDir, "../scripts/live-whisper.py"),
+    join40(thisDir, "../../scripts/live-whisper.py")
   ];
   for (const p of candidates) {
     if (existsSync27(p))
@@ -23286,8 +24325,8 @@ function findLiveWhisperScript() {
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     const candidates2 = [
-      join36(globalRoot, "open-agents-ai", "dist", "scripts", "live-whisper.py"),
-      join36(globalRoot, "open-agents-ai", "scripts", "live-whisper.py")
+      join40(globalRoot, "open-agents-ai", "dist", "scripts", "live-whisper.py"),
+      join40(globalRoot, "open-agents-ai", "scripts", "live-whisper.py")
     ];
     for (const p of candidates2) {
       if (existsSync27(p))
@@ -23295,11 +24334,11 @@ function findLiveWhisperScript() {
     }
   } catch {
   }
-  const nvmBase = join36(homedir8(), ".nvm", "versions", "node");
+  const nvmBase = join40(homedir8(), ".nvm", "versions", "node");
   if (existsSync27(nvmBase)) {
     try {
       for (const ver of readdirSync6(nvmBase)) {
-        const p = join36(nvmBase, ver, "lib", "node_modules", "open-agents-ai", "dist", "scripts", "live-whisper.py");
+        const p = join40(nvmBase, ver, "lib", "node_modules", "open-agents-ai", "dist", "scripts", "live-whisper.py");
         if (existsSync27(p))
           return p;
       }
@@ -23318,7 +24357,7 @@ function ensureTranscribeCliBackground() {
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      if (existsSync27(join36(globalRoot, "transcribe-cli", "dist", "index.js"))) {
+      if (existsSync27(join40(globalRoot, "transcribe-cli", "dist", "index.js"))) {
         return true;
       }
     } catch {
@@ -23541,24 +24580,24 @@ var init_listen = __esm({
             timeout: 5e3,
             stdio: ["pipe", "pipe", "pipe"]
           }).trim();
-          const tcPath = join36(globalRoot, "transcribe-cli");
-          if (existsSync27(join36(tcPath, "dist", "index.js"))) {
+          const tcPath = join40(globalRoot, "transcribe-cli");
+          if (existsSync27(join40(tcPath, "dist", "index.js"))) {
             const { createRequire: createRequire4 } = await import("node:module");
             const req = createRequire4(import.meta.url);
-            return req(join36(tcPath, "dist", "index.js"));
+            return req(join40(tcPath, "dist", "index.js"));
           }
         } catch {
         }
-        const nvmBase = join36(homedir8(), ".nvm", "versions", "node");
+        const nvmBase = join40(homedir8(), ".nvm", "versions", "node");
         if (existsSync27(nvmBase)) {
           try {
             const { readdirSync: readdirSync17 } = await import("node:fs");
             for (const ver of readdirSync17(nvmBase)) {
-              const tcPath = join36(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
-              if (existsSync27(join36(tcPath, "dist", "index.js"))) {
+              const tcPath = join40(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
+              if (existsSync27(join40(tcPath, "dist", "index.js"))) {
                 const { createRequire: createRequire4 } = await import("node:module");
                 const req = createRequire4(import.meta.url);
-                return req(join36(tcPath, "dist", "index.js"));
+                return req(join40(tcPath, "dist", "index.js"));
               }
             }
           } catch {
@@ -23840,9 +24879,9 @@ transcribe-cli error: ${transcribeCliError}` : "";
           });
           if (outputDir) {
             const { basename: basename16 } = await import("node:path");
-            const transcriptDir = join36(outputDir, ".oa", "transcripts");
+            const transcriptDir = join40(outputDir, ".oa", "transcripts");
             mkdirSync8(transcriptDir, { recursive: true });
-            const outFile = join36(transcriptDir, `${basename16(filePath)}.txt`);
+            const outFile = join40(transcriptDir, `${basename16(filePath)}.txt`);
             writeFileSync9(outFile, result.text, "utf-8");
           }
           return {
@@ -29200,7 +30239,7 @@ import { randomBytes as randomBytes9 } from "node:crypto";
 import { URL as URL2 } from "node:url";
 import { loadavg, cpus, totalmem, freemem } from "node:os";
 import { existsSync as existsSync28, readFileSync as readFileSync19, writeFileSync as writeFileSync10, unlinkSync as unlinkSync5, mkdirSync as mkdirSync9, readdirSync as readdirSync7, statSync as statSync10 } from "node:fs";
-import { join as join37 } from "node:path";
+import { join as join41 } from "node:path";
 function cleanForwardHeaders(raw, targetHost) {
   const out = {};
   for (const [key, value] of Object.entries(raw)) {
@@ -29228,7 +30267,7 @@ function fmtTokens(n) {
 }
 function readExposeState(stateDir) {
   try {
-    const path = join37(stateDir, STATE_FILE_NAME);
+    const path = join41(stateDir, STATE_FILE_NAME);
     if (!existsSync28(path))
       return null;
     const raw = readFileSync19(path, "utf8");
@@ -29243,13 +30282,13 @@ function readExposeState(stateDir) {
 function writeExposeState(stateDir, state) {
   try {
     mkdirSync9(stateDir, { recursive: true });
-    writeFileSync10(join37(stateDir, STATE_FILE_NAME), JSON.stringify(state, null, 2));
+    writeFileSync10(join41(stateDir, STATE_FILE_NAME), JSON.stringify(state, null, 2));
   } catch {
   }
 }
 function removeExposeState(stateDir) {
   try {
-    unlinkSync5(join37(stateDir, STATE_FILE_NAME));
+    unlinkSync5(join41(stateDir, STATE_FILE_NAME));
   } catch {
   }
 }
@@ -29338,7 +30377,7 @@ async function collectSystemMetricsAsync() {
 }
 function readP2PExposeState(stateDir) {
   try {
-    const path = join37(stateDir, P2P_STATE_FILE_NAME);
+    const path = join41(stateDir, P2P_STATE_FILE_NAME);
     if (!existsSync28(path))
       return null;
     const raw = readFileSync19(path, "utf8");
@@ -29353,13 +30392,13 @@ function readP2PExposeState(stateDir) {
 function writeP2PExposeState(stateDir, state) {
   try {
     mkdirSync9(stateDir, { recursive: true });
-    writeFileSync10(join37(stateDir, P2P_STATE_FILE_NAME), JSON.stringify(state, null, 2));
+    writeFileSync10(join41(stateDir, P2P_STATE_FILE_NAME), JSON.stringify(state, null, 2));
   } catch {
   }
 }
 function removeP2PExposeState(stateDir) {
   try {
-    unlinkSync5(join37(stateDir, P2P_STATE_FILE_NAME));
+    unlinkSync5(join41(stateDir, P2P_STATE_FILE_NAME));
   } catch {
   }
 }
@@ -30189,7 +31228,7 @@ ${this.formatConnectionInfo()}`);
           throw new Error(`Expose failed: ${exposeResult.error}`);
         }
         const nexusDir = this._nexusTool.getNexusDir();
-        const statusPath = join37(nexusDir, "status.json");
+        const statusPath = join41(nexusDir, "status.json");
         for (let i = 0; i < 80; i++) {
           try {
             const raw = readFileSync19(statusPath, "utf8");
@@ -30223,7 +31262,7 @@ ${this.formatConnectionInfo()}`);
           });
         }
         try {
-          const invocDir = join37(nexusDir, "invocations");
+          const invocDir = join41(nexusDir, "invocations");
           if (existsSync28(invocDir)) {
             this._prevInvocCount = readdirSync7(invocDir).filter((f) => f.endsWith(".json")).length;
             this._stats.totalRequests = this._prevInvocCount;
@@ -30253,7 +31292,7 @@ ${this.formatConnectionInfo()}`);
         if (!state)
           return null;
         const nexusDir = nexusTool.getNexusDir();
-        const statusPath = join37(nexusDir, "status.json");
+        const statusPath = join41(nexusDir, "status.json");
         try {
           if (!existsSync28(statusPath)) {
             removeP2PExposeState(stateDir);
@@ -30312,7 +31351,7 @@ ${this.formatConnectionInfo()}`);
         let lastMeteringLineCount = 0;
         this._activityPollTimer = setInterval(() => {
           try {
-            const invocDir = join37(nexusDir, "invocations");
+            const invocDir = join41(nexusDir, "invocations");
             if (!existsSync28(invocDir))
               return;
             const files = readdirSync7(invocDir).filter((f) => f.endsWith(".json"));
@@ -30328,13 +31367,13 @@ ${this.formatConnectionInfo()}`);
             let recentActive = 0;
             for (const f of files.slice(-10)) {
               try {
-                const st = statSync10(join37(invocDir, f));
+                const st = statSync10(join41(invocDir, f));
                 if (now - st.mtimeMs < 1e4)
                   recentActive++;
               } catch {
               }
             }
-            const meteringFile = join37(nexusDir, "metering.jsonl");
+            const meteringFile = join41(nexusDir, "metering.jsonl");
             let meteringLines = lastMeteringLineCount;
             try {
               if (existsSync28(meteringFile)) {
@@ -30364,7 +31403,7 @@ ${this.formatConnectionInfo()}`);
         this._activityPollTimer.unref();
         this._pollTimer = setInterval(() => {
           try {
-            const statusPath = join37(nexusDir, "status.json");
+            const statusPath = join41(nexusDir, "status.json");
             if (existsSync28(statusPath)) {
               const status = JSON.parse(readFileSync19(statusPath, "utf8"));
               if (status.peerId && !this._peerId) {
@@ -30375,7 +31414,7 @@ ${this.formatConnectionInfo()}`);
           } catch {
           }
           try {
-            const invocDir = join37(nexusDir, "invocations");
+            const invocDir = join41(nexusDir, "invocations");
             if (existsSync28(invocDir)) {
               const files = readdirSync7(invocDir);
               const invocCount = files.filter((f) => f.endsWith(".json")).length;
@@ -30387,7 +31426,7 @@ ${this.formatConnectionInfo()}`);
           } catch {
           }
           try {
-            const meteringFile = join37(nexusDir, "metering.jsonl");
+            const meteringFile = join41(nexusDir, "metering.jsonl");
             if (existsSync28(meteringFile)) {
               const content = readFileSync19(meteringFile, "utf8");
               if (content.length > lastMeteringSize) {
@@ -30599,7 +31638,7 @@ var init_types = __esm({
 // packages/cli/dist/tui/p2p/secret-vault.js
 import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes10, scryptSync as scryptSync2, createHash as createHash2 } from "node:crypto";
 import { readFileSync as readFileSync20, writeFileSync as writeFileSync11, existsSync as existsSync29, mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join38, dirname as dirname14 } from "node:path";
+import { join as join42, dirname as dirname14 } from "node:path";
 var PLACEHOLDER_PREFIX, PLACEHOLDER_SUFFIX, CIPHER_ALGO, SALT_LEN, IV_LEN, KEY_LEN, SecretVault;
 var init_secret_vault = __esm({
   "packages/cli/dist/tui/p2p/secret-vault.js"() {
@@ -31936,13 +32975,13 @@ async function fetchPeerModels(peerId, authKey) {
   try {
     const { NexusTool: NexusTool2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
     const { existsSync: existsSync45, readFileSync: readFileSync33 } = await import("node:fs");
-    const { join: join58 } = await import("node:path");
+    const { join: join62 } = await import("node:path");
     const cwd4 = process.cwd();
     const nexusTool = new NexusTool2(cwd4);
     const nexusDir = nexusTool.getNexusDir();
     let isLocalPeer = false;
     try {
-      const statusPath = join58(nexusDir, "status.json");
+      const statusPath = join62(nexusDir, "status.json");
       if (existsSync45(statusPath)) {
         const status = JSON.parse(readFileSync33(statusPath, "utf8"));
         if (status.peerId === peerId)
@@ -31951,7 +32990,7 @@ async function fetchPeerModels(peerId, authKey) {
     } catch {
     }
     if (isLocalPeer) {
-      const pricingPath = join58(nexusDir, "pricing.json");
+      const pricingPath = join62(nexusDir, "pricing.json");
       if (existsSync45(pricingPath)) {
         try {
           const pricing = JSON.parse(readFileSync33(pricingPath, "utf8"));
@@ -31968,7 +33007,7 @@ async function fetchPeerModels(peerId, authKey) {
         }
       }
     }
-    const cachePath = join58(nexusDir, "peer-models-cache.json");
+    const cachePath = join62(nexusDir, "peer-models-cache.json");
     if (existsSync45(cachePath)) {
       try {
         const cache4 = JSON.parse(readFileSync33(cachePath, "utf8"));
@@ -32086,7 +33125,7 @@ async function fetchPeerModels(peerId, authKey) {
     } catch {
     }
     if (isLocalPeer) {
-      const pricingPath = join58(nexusDir, "pricing.json");
+      const pricingPath = join62(nexusDir, "pricing.json");
       if (existsSync45(pricingPath)) {
         try {
           const pricing = JSON.parse(readFileSync33(pricingPath, "utf8"));
@@ -32359,12 +33398,12 @@ var init_render2 = __esm({
 
 // packages/prompts/dist/promptLoader.js
 import { readFileSync as readFileSync21, existsSync as existsSync30 } from "node:fs";
-import { join as join39, dirname as dirname15 } from "node:path";
+import { join as join43, dirname as dirname15 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 function loadPrompt2(promptPath, vars) {
   let content = cache2.get(promptPath);
   if (content === void 0) {
-    const fullPath = join39(PROMPTS_DIR2, promptPath);
+    const fullPath = join43(PROMPTS_DIR2, promptPath);
     if (!existsSync30(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
@@ -32381,8 +33420,8 @@ var init_promptLoader2 = __esm({
     "use strict";
     __filename2 = fileURLToPath9(import.meta.url);
     __dirname5 = dirname15(__filename2);
-    devPath = join39(__dirname5, "..", "templates");
-    publishedPath = join39(__dirname5, "..", "prompts", "templates");
+    devPath = join43(__dirname5, "..", "templates");
+    publishedPath = join43(__dirname5, "..", "prompts", "templates");
     PROMPTS_DIR2 = existsSync30(devPath) ? devPath : publishedPath;
     cache2 = /* @__PURE__ */ new Map();
   }
@@ -32494,7 +33533,7 @@ var init_task_templates = __esm({
 });
 
 // packages/prompts/dist/index.js
-import { join as join40, dirname as dirname16 } from "node:path";
+import { join as join44, dirname as dirname16 } from "node:path";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
 var _dir, _packageRoot;
 var init_dist6 = __esm({
@@ -32505,21 +33544,21 @@ var init_dist6 = __esm({
     init_task_templates();
     init_render2();
     _dir = dirname16(fileURLToPath10(import.meta.url));
-    _packageRoot = join40(_dir, "..");
+    _packageRoot = join44(_dir, "..");
   }
 });
 
 // packages/cli/dist/tui/oa-directory.js
 import { existsSync as existsSync31, mkdirSync as mkdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync12, readdirSync as readdirSync8, statSync as statSync11, unlinkSync as unlinkSync6 } from "node:fs";
-import { join as join41, relative as relative2, basename as basename9, extname as extname8 } from "node:path";
+import { join as join45, relative as relative2, basename as basename9, extname as extname8 } from "node:path";
 import { homedir as homedir9 } from "node:os";
 function initOaDirectory(repoRoot) {
-  const oaPath = join41(repoRoot, OA_DIR);
+  const oaPath = join45(repoRoot, OA_DIR);
   for (const sub of SUBDIRS) {
-    mkdirSync11(join41(oaPath, sub), { recursive: true });
+    mkdirSync11(join45(oaPath, sub), { recursive: true });
   }
   try {
-    const gitignorePath = join41(repoRoot, ".gitignore");
+    const gitignorePath = join45(repoRoot, ".gitignore");
     const settingsPattern = ".oa/settings.json";
     if (existsSync31(gitignorePath)) {
       const content = readFileSync22(gitignorePath, "utf-8");
@@ -32532,10 +33571,10 @@ function initOaDirectory(repoRoot) {
   return oaPath;
 }
 function hasOaDirectory(repoRoot) {
-  return existsSync31(join41(repoRoot, OA_DIR, "index"));
+  return existsSync31(join45(repoRoot, OA_DIR, "index"));
 }
 function loadProjectSettings(repoRoot) {
-  const settingsPath = join41(repoRoot, OA_DIR, "settings.json");
+  const settingsPath = join45(repoRoot, OA_DIR, "settings.json");
   try {
     if (existsSync31(settingsPath)) {
       return JSON.parse(readFileSync22(settingsPath, "utf-8"));
@@ -32545,14 +33584,14 @@ function loadProjectSettings(repoRoot) {
   return {};
 }
 function saveProjectSettings(repoRoot, settings) {
-  const oaPath = join41(repoRoot, OA_DIR);
+  const oaPath = join45(repoRoot, OA_DIR);
   mkdirSync11(oaPath, { recursive: true });
   const existing = loadProjectSettings(repoRoot);
   const merged = { ...existing, ...settings };
-  writeFileSync12(join41(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync12(join45(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function loadGlobalSettings() {
-  const settingsPath = join41(homedir9(), ".open-agents", "settings.json");
+  const settingsPath = join45(homedir9(), ".open-agents", "settings.json");
   try {
     if (existsSync31(settingsPath)) {
       return JSON.parse(readFileSync22(settingsPath, "utf-8"));
@@ -32562,11 +33601,11 @@ function loadGlobalSettings() {
   return {};
 }
 function saveGlobalSettings(settings) {
-  const dir = join41(homedir9(), ".open-agents");
+  const dir = join45(homedir9(), ".open-agents");
   mkdirSync11(dir, { recursive: true });
   const existing = loadGlobalSettings();
   const merged = { ...existing, ...settings };
-  writeFileSync12(join41(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync12(join45(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function resolveSettings(repoRoot) {
   const global = loadGlobalSettings();
@@ -32581,7 +33620,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   while (dir && !visited.has(dir)) {
     visited.add(dir);
     for (const name of CONTEXT_FILES) {
-      const filePath = join41(dir, name);
+      const filePath = join45(dir, name);
       const normalizedName = name.toLowerCase();
       if (existsSync31(filePath) && !seen.has(filePath)) {
         seen.add(filePath);
@@ -32600,7 +33639,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
         }
       }
     }
-    const projectMap = join41(dir, OA_DIR, "context", "project-map.md");
+    const projectMap = join45(dir, OA_DIR, "context", "project-map.md");
     if (existsSync31(projectMap) && !seen.has(projectMap)) {
       seen.add(projectMap);
       try {
@@ -32616,7 +33655,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
       } catch {
       }
     }
-    const parent = join41(dir, "..");
+    const parent = join45(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
@@ -32634,7 +33673,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   return found;
 }
 function readIndexMeta(repoRoot) {
-  const metaPath = join41(repoRoot, OA_DIR, "index", "meta.json");
+  const metaPath = join45(repoRoot, OA_DIR, "index", "meta.json");
   try {
     return JSON.parse(readFileSync22(metaPath, "utf-8"));
   } catch {
@@ -32687,28 +33726,28 @@ ${tree}\`\`\`
     sections.push("");
   }
   const content = sections.join("\n");
-  const contextDir = join41(repoRoot, OA_DIR, "context");
+  const contextDir = join45(repoRoot, OA_DIR, "context");
   mkdirSync11(contextDir, { recursive: true });
-  writeFileSync12(join41(contextDir, "project-map.md"), content, "utf-8");
+  writeFileSync12(join45(contextDir, "project-map.md"), content, "utf-8");
   return content;
 }
 function saveSession(repoRoot, session) {
-  const historyDir = join41(repoRoot, OA_DIR, "history");
+  const historyDir = join45(repoRoot, OA_DIR, "history");
   mkdirSync11(historyDir, { recursive: true });
-  writeFileSync12(join41(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
+  writeFileSync12(join45(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
 }
 function loadRecentSessions(repoRoot, limit = 5) {
-  const historyDir = join41(repoRoot, OA_DIR, "history");
+  const historyDir = join45(repoRoot, OA_DIR, "history");
   if (!existsSync31(historyDir))
     return [];
   try {
     const files = readdirSync8(historyDir).filter((f) => f.endsWith(".json") && f !== "pending-task.json").map((f) => {
-      const stat5 = statSync11(join41(historyDir, f));
+      const stat5 = statSync11(join45(historyDir, f));
       return { file: f, mtime: stat5.mtimeMs };
     }).sort((a, b) => b.mtime - a.mtime).slice(0, limit);
     return files.map((f) => {
       try {
-        return JSON.parse(readFileSync22(join41(historyDir, f.file), "utf-8"));
+        return JSON.parse(readFileSync22(join45(historyDir, f.file), "utf-8"));
       } catch {
         return null;
       }
@@ -32718,12 +33757,12 @@ function loadRecentSessions(repoRoot, limit = 5) {
   }
 }
 function savePendingTask(repoRoot, task) {
-  const historyDir = join41(repoRoot, OA_DIR, "history");
+  const historyDir = join45(repoRoot, OA_DIR, "history");
   mkdirSync11(historyDir, { recursive: true });
-  writeFileSync12(join41(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
+  writeFileSync12(join45(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
 }
 function loadPendingTask(repoRoot) {
-  const filePath = join41(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
+  const filePath = join45(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
   try {
     if (!existsSync31(filePath))
       return null;
@@ -32738,9 +33777,9 @@ function loadPendingTask(repoRoot) {
   }
 }
 function saveSessionContext(repoRoot, entry) {
-  const contextDir = join41(repoRoot, OA_DIR, "context");
+  const contextDir = join45(repoRoot, OA_DIR, "context");
   mkdirSync11(contextDir, { recursive: true });
-  const filePath = join41(contextDir, CONTEXT_SAVE_FILE);
+  const filePath = join45(contextDir, CONTEXT_SAVE_FILE);
   let ctx;
   try {
     if (existsSync31(filePath)) {
@@ -32759,7 +33798,7 @@ function saveSessionContext(repoRoot, entry) {
   writeFileSync12(filePath, JSON.stringify(ctx, null, 2) + "\n", "utf-8");
 }
 function loadSessionContext(repoRoot) {
-  const filePath = join41(repoRoot, OA_DIR, "context", CONTEXT_SAVE_FILE);
+  const filePath = join45(repoRoot, OA_DIR, "context", CONTEXT_SAVE_FILE);
   try {
     if (!existsSync31(filePath))
       return null;
@@ -32810,7 +33849,7 @@ function detectManifests(repoRoot) {
     { file: "docker-compose.yaml", type: "Docker Compose" }
   ];
   for (const check of checks) {
-    const filePath = join41(repoRoot, check.file);
+    const filePath = join45(repoRoot, check.file);
     if (existsSync31(filePath)) {
       let name;
       if (check.nameField) {
@@ -32844,7 +33883,7 @@ function findKeyFiles(repoRoot) {
     { pattern: "CLAUDE.md", description: "Claude Code context" }
   ];
   for (const check of checks) {
-    if (existsSync31(join41(repoRoot, check.pattern))) {
+    if (existsSync31(join45(repoRoot, check.pattern))) {
       keyFiles.push({ path: check.pattern, description: check.description });
     }
   }
@@ -32870,12 +33909,12 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
       if (entry.isDirectory()) {
         let fileCount = 0;
         try {
-          fileCount = readdirSync8(join41(root, entry.name)).filter((f) => !f.startsWith(".")).length;
+          fileCount = readdirSync8(join45(root, entry.name)).filter((f) => !f.startsWith(".")).length;
         } catch {
         }
         result += `${prefix}${connector}${entry.name}/ (${fileCount})
 `;
-        result += buildDirTree(join41(root, entry.name), maxDepth, childPrefix, depth + 1);
+        result += buildDirTree(join45(root, entry.name), maxDepth, childPrefix, depth + 1);
       } else if (depth < maxDepth) {
         result += `${prefix}${connector}${entry.name}
 `;
@@ -32895,7 +33934,7 @@ function loadUsageFile(filePath) {
   return { records: [] };
 }
 function saveUsageFile(filePath, data) {
-  const dir = join41(filePath, "..");
+  const dir = join45(filePath, "..");
   mkdirSync11(dir, { recursive: true });
   writeFileSync12(filePath, JSON.stringify(data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
@@ -32925,15 +33964,15 @@ function recordUsage(kind, value, opts) {
     }
     saveUsageFile(filePath, data);
   };
-  update(join41(homedir9(), ".open-agents", USAGE_HISTORY_FILE));
+  update(join45(homedir9(), ".open-agents", USAGE_HISTORY_FILE));
   if (opts?.repoRoot) {
-    update(join41(opts.repoRoot, OA_DIR, USAGE_HISTORY_FILE));
+    update(join45(opts.repoRoot, OA_DIR, USAGE_HISTORY_FILE));
   }
 }
 function loadUsageHistory(kind, repoRoot) {
-  const globalPath = join41(homedir9(), ".open-agents", USAGE_HISTORY_FILE);
+  const globalPath = join45(homedir9(), ".open-agents", USAGE_HISTORY_FILE);
   const globalData = loadUsageFile(globalPath);
-  const localData = repoRoot ? loadUsageFile(join41(repoRoot, OA_DIR, USAGE_HISTORY_FILE)) : { records: [] };
+  const localData = repoRoot ? loadUsageFile(join45(repoRoot, OA_DIR, USAGE_HISTORY_FILE)) : { records: [] };
   const map = /* @__PURE__ */ new Map();
   for (const r of globalData.records) {
     if (r.kind !== kind)
@@ -32964,9 +34003,9 @@ function deleteUsageRecord(kind, value, repoRoot) {
       saveUsageFile(filePath, data);
     }
   };
-  remove(join41(homedir9(), ".open-agents", USAGE_HISTORY_FILE));
+  remove(join45(homedir9(), ".open-agents", USAGE_HISTORY_FILE));
   if (repoRoot) {
-    remove(join41(repoRoot, OA_DIR, USAGE_HISTORY_FILE));
+    remove(join45(repoRoot, OA_DIR, USAGE_HISTORY_FILE));
   }
 }
 var OA_DIR, SUBDIRS, CONTEXT_FILES, PENDING_TASK_FILE, CONTEXT_SAVE_FILE, MAX_CONTEXT_ENTRIES, SKIP_DIRS, USAGE_HISTORY_FILE, MAX_HISTORY_RECORDS;
@@ -33017,7 +34056,7 @@ import * as readline from "node:readline";
 import { execSync as execSync25, spawn as spawn18, exec as exec2 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
 import { existsSync as existsSync32, writeFileSync as writeFileSync13, readFileSync as readFileSync23, appendFileSync as appendFileSync2, mkdirSync as mkdirSync12 } from "node:fs";
-import { join as join42 } from "node:path";
+import { join as join46 } from "node:path";
 import { homedir as homedir10, platform } from "node:os";
 function detectSystemSpecs() {
   let totalRamGB = 0;
@@ -34058,9 +35097,9 @@ async function doSetup(config, rl) {
           `PARAMETER num_predict ${numPredict}`,
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
-        const modelDir2 = join42(homedir10(), ".open-agents", "models");
+        const modelDir2 = join46(homedir10(), ".open-agents", "models");
         mkdirSync12(modelDir2, { recursive: true });
-        const modelfilePath = join42(modelDir2, `Modelfile.${customName}`);
+        const modelfilePath = join46(modelDir2, `Modelfile.${customName}`);
         writeFileSync13(modelfilePath, modelfileContent + "\n", "utf8");
         process.stdout.write(`  ${c2.dim("Creating model...")} `);
         execSync25(`ollama create ${customName} -f ${modelfilePath}`, {
@@ -34106,7 +35145,7 @@ async function isModelAvailable(config) {
 }
 function isFirstRun() {
   try {
-    return !existsSync32(join42(homedir10(), ".open-agents", "config.json"));
+    return !existsSync32(join46(homedir10(), ".open-agents", "config.json"));
   } catch {
     return true;
   }
@@ -34143,7 +35182,7 @@ function detectPkgManager() {
   return null;
 }
 function getVenvDir() {
-  return join42(homedir10(), ".open-agents", "venv");
+  return join46(homedir10(), ".open-agents", "venv");
 }
 function hasVenvModule() {
   try {
@@ -34155,7 +35194,7 @@ function hasVenvModule() {
 }
 function ensureVenv(log) {
   const venvDir = getVenvDir();
-  const venvPip = join42(venvDir, "bin", "pip");
+  const venvPip = join46(venvDir, "bin", "pip");
   if (existsSync32(venvPip))
     return venvDir;
   log("Creating Python venv for vision deps...");
@@ -34168,9 +35207,9 @@ function ensureVenv(log) {
     return null;
   }
   try {
-    mkdirSync12(join42(homedir10(), ".open-agents"), { recursive: true });
+    mkdirSync12(join46(homedir10(), ".open-agents"), { recursive: true });
     execSync25(`python3 -m venv "${venvDir}"`, { stdio: "pipe", timeout: 3e4 });
-    execSync25(`"${join42(venvDir, "bin", "pip")}" install --upgrade pip`, {
+    execSync25(`"${join46(venvDir, "bin", "pip")}" install --upgrade pip`, {
       stdio: "pipe",
       timeout: 6e4
     });
@@ -34361,11 +35400,11 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     }
   }
   const venvDir = getVenvDir();
-  const venvBin = join42(venvDir, "bin");
-  const venvMoondream = join42(venvBin, "moondream-station");
+  const venvBin = join46(venvDir, "bin");
+  const venvMoondream = join46(venvBin, "moondream-station");
   const venv = ensureVenv(log);
   if (venv && !hasCmd("moondream-station") && !existsSync32(venvMoondream)) {
-    const venvPip = join42(venvBin, "pip");
+    const venvPip = join46(venvBin, "pip");
     log("Installing moondream-station in ~/.open-agents/venv...");
     try {
       execSync25(`"${venvPip}" install moondream-station`, { stdio: "pipe", timeout: 3e5 });
@@ -34386,8 +35425,8 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     }
   }
   if (venv) {
-    const venvPython = join42(venvBin, "python");
-    const venvPip2 = join42(venvBin, "pip");
+    const venvPython = join46(venvBin, "python");
+    const venvPip2 = join46(venvBin, "pip");
     let ocrStackInstalled = false;
     try {
       execSync25(`"${venvPython}" -c "import cv2, pytesseract, numpy, PIL"`, { stdio: "pipe", timeout: 1e4 });
@@ -34531,9 +35570,9 @@ async function createExpandedVariantAsync(baseModel, specs, sizeGB, kvBytesPerTo
       `PARAMETER num_predict ${numPredict}`,
       `PARAMETER stop "<|endoftext|>"`
     ].join("\n");
-    const modelDir2 = join42(homedir10(), ".open-agents", "models");
+    const modelDir2 = join46(homedir10(), ".open-agents", "models");
     mkdirSync12(modelDir2, { recursive: true });
-    const modelfilePath = join42(modelDir2, `Modelfile.${customName}`);
+    const modelfilePath = join46(modelDir2, `Modelfile.${customName}`);
     writeFileSync13(modelfilePath, modelfileContent + "\n", "utf8");
     await execAsync(`ollama create ${customName} -f ${modelfilePath}`, {
       timeout: 12e4
@@ -34608,8 +35647,8 @@ async function ensureNeovim() {
   const platform5 = process.platform;
   const arch = process.arch;
   if (platform5 === "linux") {
-    const binDir = join42(homedir10(), ".local", "bin");
-    const nvimDest = join42(binDir, "nvim");
+    const binDir = join46(homedir10(), ".local", "bin");
+    const nvimDest = join46(binDir, "nvim");
     try {
       mkdirSync12(binDir, { recursive: true });
     } catch {
@@ -34680,7 +35719,7 @@ async function ensureNeovim() {
 }
 function ensurePathInShellRc(binDir) {
   const shell = process.env.SHELL ?? "";
-  const rcFile = shell.includes("zsh") ? join42(homedir10(), ".zshrc") : join42(homedir10(), ".bashrc");
+  const rcFile = shell.includes("zsh") ? join46(homedir10(), ".zshrc") : join46(homedir10(), ".bashrc");
   try {
     const rcContent = existsSync32(rcFile) ? readFileSync23(rcFile, "utf8") : "";
     if (rcContent.includes(binDir))
@@ -35452,7 +36491,7 @@ var init_drop_panel = __esm({
 // packages/cli/dist/tui/neovim-mode.js
 import { existsSync as existsSync34, unlinkSync as unlinkSync7 } from "node:fs";
 import { tmpdir as tmpdir8 } from "node:os";
-import { join as join43 } from "node:path";
+import { join as join47 } from "node:path";
 import { execSync as execSync26 } from "node:child_process";
 function isNeovimActive() {
   return _state !== null && !_state.cleanedUp;
@@ -35500,7 +36539,7 @@ async function startNeovimMode(opts) {
     );
   } catch {
   }
-  const socketPath = join43(tmpdir8(), `oa-nvim-${process.pid}-${Date.now()}.sock`);
+  const socketPath = join47(tmpdir8(), `oa-nvim-${process.pid}-${Date.now()}.sock`);
   try {
     if (existsSync34(socketPath))
       unlinkSync7(socketPath);
@@ -35852,7 +36891,7 @@ __export(voice_exports, {
   resetNarrationContext: () => resetNarrationContext
 });
 import { existsSync as existsSync35, mkdirSync as mkdirSync13, writeFileSync as writeFileSync14, readFileSync as readFileSync24, unlinkSync as unlinkSync8, readdirSync as readdirSync9, renameSync, statSync as statSync12 } from "node:fs";
-import { join as join44 } from "node:path";
+import { join as join48 } from "node:path";
 import { homedir as homedir11, tmpdir as tmpdir9, platform as platform2 } from "node:os";
 import { execSync as execSync27, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
@@ -35874,34 +36913,34 @@ function listVoiceModels() {
   }));
 }
 function voiceDir() {
-  return join44(homedir11(), ".open-agents", "voice");
+  return join48(homedir11(), ".open-agents", "voice");
 }
 function modelsDir() {
-  return join44(voiceDir(), "models");
+  return join48(voiceDir(), "models");
 }
 function modelDir(id) {
-  return join44(modelsDir(), id);
+  return join48(modelsDir(), id);
 }
 function modelOnnxPath(id) {
-  return join44(modelDir(id), "model.onnx");
+  return join48(modelDir(id), "model.onnx");
 }
 function modelConfigPath(id) {
-  return join44(modelDir(id), "config.json");
+  return join48(modelDir(id), "config.json");
 }
 function luxttsVenvDir() {
-  return join44(voiceDir(), "luxtts-venv");
+  return join48(voiceDir(), "luxtts-venv");
 }
 function luxttsVenvPy() {
-  return platform2() === "win32" ? join44(luxttsVenvDir(), "Scripts", "python.exe") : join44(luxttsVenvDir(), "bin", "python3");
+  return platform2() === "win32" ? join48(luxttsVenvDir(), "Scripts", "python.exe") : join48(luxttsVenvDir(), "bin", "python3");
 }
 function luxttsRepoDir() {
-  return join44(voiceDir(), "LuxTTS");
+  return join48(voiceDir(), "LuxTTS");
 }
 function luxttsCloneRefsDir() {
-  return join44(voiceDir(), "clone-refs");
+  return join48(voiceDir(), "clone-refs");
 }
 function luxttsInferScript() {
-  return join44(voiceDir(), "luxtts-infer.py");
+  return join48(voiceDir(), "luxtts-infer.py");
 }
 function emotionToPitchBias(emotion, stark = false, autist = false) {
   if (autist)
@@ -36709,7 +37748,7 @@ var init_voice = __esm({
         const refsDir = luxttsCloneRefsDir();
         const targets = ["glados", "overwatch"];
         for (const modelId of targets) {
-          const refFile = join44(refsDir, `${modelId}-ref.wav`);
+          const refFile = join48(refsDir, `${modelId}-ref.wav`);
           if (existsSync35(refFile))
             continue;
           try {
@@ -36789,7 +37828,7 @@ var init_voice = __esm({
         }
         p = p.replace(/\\ /g, " ");
         if (p.startsWith("~/") || p === "~") {
-          p = join44(homedir11(), p.slice(1));
+          p = join48(homedir11(), p.slice(1));
         }
         if (!existsSync35(p)) {
           return `File not found: ${p}
@@ -36803,7 +37842,7 @@ var init_voice = __esm({
         const srcName = (audioPath.split("/").pop() ?? "clone").replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]/g, "-");
         const ts = Date.now().toString(36);
         const destFilename = `clone-${srcName}-${ts}.${ext}`;
-        const destPath = join44(refsDir, destFilename);
+        const destPath = join48(refsDir, destFilename);
         try {
           const data = readFileSync24(audioPath);
           writeFileSync14(destPath, data);
@@ -36848,7 +37887,7 @@ var init_voice = __esm({
           const refsDir = luxttsCloneRefsDir();
           if (!existsSync35(refsDir))
             mkdirSync13(refsDir, { recursive: true });
-          const destPath = join44(refsDir, `${sourceModelId}-ref.wav`);
+          const destPath = join48(refsDir, `${sourceModelId}-ref.wav`);
           const sampleRate = this.config?.audio?.sample_rate ?? 22050;
           this.writeWav(audioData, sampleRate, destPath);
           this.luxttsCloneRef = destPath;
@@ -36864,7 +37903,7 @@ var init_voice = __esm({
       // -------------------------------------------------------------------------
       /** Metadata file for friendly names of clone refs */
       static cloneMetaFile() {
-        return join44(luxttsCloneRefsDir(), "meta.json");
+        return join48(luxttsCloneRefsDir(), "meta.json");
       }
       loadCloneMeta() {
         const p = _VoiceEngine.cloneMetaFile();
@@ -36898,7 +37937,7 @@ var init_voice = __esm({
           return _VoiceEngine.AUDIO_EXTS.has(ext);
         });
         return files.map((f) => {
-          const p = join44(dir, f);
+          const p = join48(dir, f);
           let size = 0;
           try {
             size = statSync12(p).size;
@@ -36915,7 +37954,7 @@ var init_voice = __esm({
       }
       /** Delete a clone reference file by filename. Returns true if deleted. */
       deleteCloneRef(filename) {
-        const p = join44(luxttsCloneRefsDir(), filename);
+        const p = join48(luxttsCloneRefsDir(), filename);
         if (!existsSync35(p))
           return false;
         try {
@@ -36940,7 +37979,7 @@ var init_voice = __esm({
       }
       /** Set the active clone reference by filename. */
       setActiveCloneRef(filename) {
-        const p = join44(luxttsCloneRefsDir(), filename);
+        const p = join48(luxttsCloneRefsDir(), filename);
         if (!existsSync35(p))
           return `File not found: ${filename}`;
         this.luxttsCloneRef = p;
@@ -37226,7 +38265,7 @@ var init_voice = __esm({
           }
           this.onPCMOutput(Buffer.from(int16.buffer), sampleRate);
         }
-        const wavPath = join44(tmpdir9(), `oa-voice-${Date.now()}.wav`);
+        const wavPath = join48(tmpdir9(), `oa-voice-${Date.now()}.wav`);
         this.writeWav(audioData, sampleRate, wavPath);
         await this.playWav(wavPath);
         try {
@@ -37569,7 +38608,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         const mlxModelId = model.mlxModelId ?? "mlx-community/Kokoro-82M-bf16";
         const mlxVoice = model.mlxVoice ?? "af_heart";
         const mlxLangCode = model.mlxLangCode ?? "a";
-        const wavPath = join44(tmpdir9(), `oa-mlx-${Date.now()}.wav`);
+        const wavPath = join48(tmpdir9(), `oa-mlx-${Date.now()}.wav`);
         const pyScript = [
           "import sys, json",
           "from mlx_audio.tts import generate as tts_gen",
@@ -37637,7 +38676,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         const mlxModelId = model.mlxModelId ?? "mlx-community/Kokoro-82M-bf16";
         const mlxVoice = model.mlxVoice ?? "af_heart";
         const mlxLangCode = model.mlxLangCode ?? "a";
-        const wavPath = join44(tmpdir9(), `oa-mlx-buf-${Date.now()}.wav`);
+        const wavPath = join48(tmpdir9(), `oa-mlx-buf-${Date.now()}.wav`);
         const pyScript = [
           "import sys, json",
           "from mlx_audio.tts import generate as tts_gen",
@@ -37748,7 +38787,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           }
         }
         const repoDir = luxttsRepoDir();
-        if (!existsSync35(join44(repoDir, "zipvoice", "luxvoice.py"))) {
+        if (!existsSync35(join48(repoDir, "zipvoice", "luxvoice.py"))) {
           renderInfo("  Cloning LuxTTS repository...");
           try {
             if (existsSync35(repoDir)) {
@@ -37797,7 +38836,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         if (!existsSync35(refsDir))
           return;
         for (const name of ["custom-clone.wav", "custom-clone.mp3", "glados-ref.wav", "overwatch-ref.wav"]) {
-          const p = join44(refsDir, name);
+          const p = join48(refsDir, name);
           if (existsSync35(p)) {
             this.luxttsCloneRef = p;
             return;
@@ -37994,7 +39033,7 @@ if __name__ == '__main__':
         const ready = await this.ensureLuxttsDaemon();
         if (!ready)
           return;
-        const wavPath = join44(tmpdir9(), `oa-luxtts-${Date.now()}.wav`);
+        const wavPath = join48(tmpdir9(), `oa-luxtts-${Date.now()}.wav`);
         try {
           await this.luxttsRequest({
             action: "synthesize",
@@ -38068,7 +39107,7 @@ if __name__ == '__main__':
         const ready = await this.ensureLuxttsDaemon();
         if (!ready)
           return null;
-        const wavPath = join44(tmpdir9(), `oa-luxtts-buf-${Date.now()}.wav`);
+        const wavPath = join48(tmpdir9(), `oa-luxtts-buf-${Date.now()}.wav`);
         try {
           await this.luxttsRequest({
             action: "synthesize",
@@ -38098,7 +39137,7 @@ if __name__ == '__main__':
           return;
         const arch = process.arch;
         mkdirSync13(voiceDir(), { recursive: true });
-        const pkgPath = join44(voiceDir(), "package.json");
+        const pkgPath = join48(voiceDir(), "package.json");
         const expectedDeps = {
           "onnxruntime-node": "^1.21.0",
           "phonemizer": "^1.2.1"
@@ -38120,17 +39159,17 @@ if __name__ == '__main__':
             dependencies: expectedDeps
           }, null, 2));
         }
-        const voiceRequire = createRequire(join44(voiceDir(), "index.js"));
+        const voiceRequire = createRequire(join48(voiceDir(), "index.js"));
         const probeOnnx = () => {
           try {
-            const result = execSync27(`node -e "try { require('onnxruntime-node'); console.log('OK'); } catch(e) { console.log('FAIL:' + e.message); }"`, { cwd: voiceDir(), stdio: "pipe", timeout: 15e3, env: { ...process.env, NODE_PATH: join44(voiceDir(), "node_modules") } });
+            const result = execSync27(`node -e "try { require('onnxruntime-node'); console.log('OK'); } catch(e) { console.log('FAIL:' + e.message); }"`, { cwd: voiceDir(), stdio: "pipe", timeout: 15e3, env: { ...process.env, NODE_PATH: join48(voiceDir(), "node_modules") } });
             const output = result.toString().trim();
             return output === "OK";
           } catch {
             return false;
           }
         };
-        const onnxNodeModules = join44(voiceDir(), "node_modules", "onnxruntime-node");
+        const onnxNodeModules = join48(voiceDir(), "node_modules", "onnxruntime-node");
         const onnxInstalled = existsSync35(onnxNodeModules);
         if (onnxInstalled && !probeOnnx()) {
           throw new Error(`Voice synthesis unavailable: ONNX runtime crashes on this CPU (${process.platform}-${arch}). This is a known issue with some ARM SoCs where the CPU vendor is not recognized. Voice feedback will be disabled but all other features work normally.`);
@@ -40474,8 +41513,8 @@ async function handlePeerEndpoint(peerId, authKey, ctx, local) {
     if (models.length > 0) {
       try {
         const { writeFileSync: writeFileSync20, mkdirSync: mkdirSync21 } = await import("node:fs");
-        const { join: join58, dirname: dirname20 } = await import("node:path");
-        const cachePath = join58(ctx.repoRoot || process.cwd(), ".oa", "nexus", "peer-models-cache.json");
+        const { join: join62, dirname: dirname20 } = await import("node:path");
+        const cachePath = join62(ctx.repoRoot || process.cwd(), ".oa", "nexus", "peer-models-cache.json");
         mkdirSync21(dirname20(cachePath), { recursive: true });
         writeFileSync20(cachePath, JSON.stringify({
           peerId,
@@ -40676,14 +41715,14 @@ async function handleUpdate(subcommand, ctx) {
   try {
     const { createRequire: createRequire4 } = await import("node:module");
     const { fileURLToPath: fileURLToPath14 } = await import("node:url");
-    const { dirname: dirname20, join: join58 } = await import("node:path");
+    const { dirname: dirname20, join: join62 } = await import("node:path");
     const { existsSync: existsSync45 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
     const thisDir = dirname20(fileURLToPath14(import.meta.url));
     const candidates = [
-      join58(thisDir, "..", "package.json"),
-      join58(thisDir, "..", "..", "package.json"),
-      join58(thisDir, "..", "..", "..", "package.json")
+      join62(thisDir, "..", "package.json"),
+      join62(thisDir, "..", "..", "package.json"),
+      join62(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
       if (existsSync45(pkgPath)) {
@@ -41401,7 +42440,7 @@ var init_commands = __esm({
 
 // packages/cli/dist/tui/project-context.js
 import { existsSync as existsSync36, readFileSync as readFileSync25, readdirSync as readdirSync10 } from "node:fs";
-import { join as join45, basename as basename10 } from "node:path";
+import { join as join49, basename as basename10 } from "node:path";
 import { execSync as execSync28 } from "node:child_process";
 import { homedir as homedir12, platform as platform3, release } from "node:os";
 function getModelTier(modelName) {
@@ -41436,7 +42475,7 @@ function loadProjectMap(repoRoot) {
   if (!hasOaDirectory(repoRoot)) {
     initOaDirectory(repoRoot);
   }
-  const mapPath = join45(repoRoot, OA_DIR, "context", "project-map.md");
+  const mapPath = join49(repoRoot, OA_DIR, "context", "project-map.md");
   if (existsSync36(mapPath)) {
     try {
       const content = readFileSync25(mapPath, "utf-8");
@@ -41480,17 +42519,17 @@ ${log}`);
 }
 function loadMemoryContext(repoRoot) {
   const sections = [];
-  const oaMemDir = join45(repoRoot, OA_DIR, "memory");
+  const oaMemDir = join49(repoRoot, OA_DIR, "memory");
   const oaEntries = loadMemoryDir(oaMemDir, "project");
   if (oaEntries)
     sections.push(oaEntries);
-  const legacyMemDir = join45(repoRoot, ".open-agents", "memory");
+  const legacyMemDir = join49(repoRoot, ".open-agents", "memory");
   if (legacyMemDir !== oaMemDir && existsSync36(legacyMemDir)) {
     const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
     if (legacyEntries)
       sections.push(legacyEntries);
   }
-  const globalMemDir = join45(homedir12(), ".open-agents", "memory");
+  const globalMemDir = join49(homedir12(), ".open-agents", "memory");
   const globalEntries = loadMemoryDir(globalMemDir, "global");
   if (globalEntries)
     sections.push(globalEntries);
@@ -41504,7 +42543,7 @@ function loadMemoryDir(memDir, scope) {
     const files = readdirSync10(memDir).filter((f) => f.endsWith(".json"));
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync25(join45(memDir, file), "utf-8");
+        const raw = readFileSync25(join49(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
         const topic = basename10(file, ".json");
         const keys = Object.keys(entries);
@@ -42528,9 +43567,9 @@ var init_carousel = __esm({
 
 // packages/cli/dist/tui/carousel-descriptors.js
 import { existsSync as existsSync37, readFileSync as readFileSync26, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, readdirSync as readdirSync11 } from "node:fs";
-import { join as join46, basename as basename11 } from "node:path";
+import { join as join50, basename as basename11 } from "node:path";
 function loadToolProfile(repoRoot) {
-  const filePath = join46(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
+  const filePath = join50(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
   try {
     if (!existsSync37(filePath))
       return null;
@@ -42540,9 +43579,9 @@ function loadToolProfile(repoRoot) {
   }
 }
 function saveToolProfile(repoRoot, profile) {
-  const contextDir = join46(repoRoot, OA_DIR, "context");
+  const contextDir = join50(repoRoot, OA_DIR, "context");
   mkdirSync14(contextDir, { recursive: true });
-  writeFileSync15(join46(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
+  writeFileSync15(join50(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
 }
 function categorizeToolCall(toolName) {
   for (const cat of TOOL_CATEGORIES) {
@@ -42600,7 +43639,7 @@ function weightedColor(profile) {
   return selectedCat.colors[Math.floor(Math.random() * selectedCat.colors.length)];
 }
 function loadCachedDescriptors(repoRoot) {
-  const filePath = join46(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
+  const filePath = join50(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
   try {
     if (!existsSync37(filePath))
       return null;
@@ -42611,14 +43650,14 @@ function loadCachedDescriptors(repoRoot) {
   }
 }
 function saveCachedDescriptors(repoRoot, phrases, sourceHash) {
-  const contextDir = join46(repoRoot, OA_DIR, "context");
+  const contextDir = join50(repoRoot, OA_DIR, "context");
   mkdirSync14(contextDir, { recursive: true });
   const cached = {
     phrases,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     sourceHash
   };
-  writeFileSync15(join46(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
+  writeFileSync15(join50(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
 }
 function generateDescriptors(repoRoot) {
   const profile = loadToolProfile(repoRoot);
@@ -42666,7 +43705,7 @@ function generateDescriptors(repoRoot) {
   return phrases;
 }
 function extractFromPackageJson(repoRoot, tags) {
-  const pkgPath = join46(repoRoot, "package.json");
+  const pkgPath = join50(repoRoot, "package.json");
   try {
     if (!existsSync37(pkgPath))
       return;
@@ -42714,7 +43753,7 @@ function extractFromManifests(repoRoot, tags) {
     { file: ".github/workflows", tag: "ci/cd" }
   ];
   for (const check of manifestChecks) {
-    if (existsSync37(join46(repoRoot, check.file))) {
+    if (existsSync37(join50(repoRoot, check.file))) {
       tags.push(check.tag);
     }
   }
@@ -42736,7 +43775,7 @@ function extractFromSessions(repoRoot, tags) {
   }
 }
 function extractFromMemory(repoRoot, tags) {
-  const memoryDir = join46(repoRoot, OA_DIR, "memory");
+  const memoryDir = join50(repoRoot, OA_DIR, "memory");
   try {
     if (!existsSync37(memoryDir))
       return;
@@ -42745,7 +43784,7 @@ function extractFromMemory(repoRoot, tags) {
       const topic = file.replace(/\.json$/, "").replace(/[-_]/g, " ");
       tags.push(topic);
       try {
-        const data = JSON.parse(readFileSync26(join46(memoryDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync26(join50(memoryDir, file), "utf-8"));
         if (data && typeof data === "object") {
           const keys = Object.keys(data).slice(0, 3);
           for (const key of keys) {
@@ -43368,10 +44407,10 @@ var init_stream_renderer = __esm({
 
 // packages/cli/dist/tui/edit-history.js
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync15 } from "node:fs";
-import { join as join47 } from "node:path";
+import { join as join51 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
-  const historyDir = join47(repoRoot, ".oa", "history");
-  const logPath = join47(historyDir, "edits.jsonl");
+  const historyDir = join51(repoRoot, ".oa", "history");
+  const logPath = join51(historyDir, "edits.jsonl");
   try {
     mkdirSync15(historyDir, { recursive: true });
   } catch {
@@ -43483,12 +44522,12 @@ var init_edit_history = __esm({
 
 // packages/cli/dist/tui/promptLoader.js
 import { readFileSync as readFileSync27, existsSync as existsSync38 } from "node:fs";
-import { join as join48, dirname as dirname17 } from "node:path";
+import { join as join52, dirname as dirname17 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 function loadPrompt3(promptPath, vars) {
   let content = cache3.get(promptPath);
   if (content === void 0) {
-    const fullPath = join48(PROMPTS_DIR3, promptPath);
+    const fullPath = join52(PROMPTS_DIR3, promptPath);
     if (!existsSync38(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
@@ -43505,8 +44544,8 @@ var init_promptLoader3 = __esm({
     "use strict";
     __filename3 = fileURLToPath11(import.meta.url);
     __dirname6 = dirname17(__filename3);
-    devPath2 = join48(__dirname6, "..", "..", "prompts");
-    publishedPath2 = join48(__dirname6, "..", "prompts");
+    devPath2 = join52(__dirname6, "..", "..", "prompts");
+    publishedPath2 = join52(__dirname6, "..", "prompts");
     PROMPTS_DIR3 = existsSync38(devPath2) ? devPath2 : publishedPath2;
     cache3 = /* @__PURE__ */ new Map();
   }
@@ -43514,10 +44553,10 @@ var init_promptLoader3 = __esm({
 
 // packages/cli/dist/tui/dream-engine.js
 import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync16, readFileSync as readFileSync28, existsSync as existsSync39, cpSync, rmSync, readdirSync as readdirSync12 } from "node:fs";
-import { join as join49, basename as basename12 } from "node:path";
+import { join as join53, basename as basename12 } from "node:path";
 import { execSync as execSync29 } from "node:child_process";
 function loadAutoresearchMemory(repoRoot) {
-  const memoryPath = join49(repoRoot, ".oa", "memory", "autoresearch.json");
+  const memoryPath = join53(repoRoot, ".oa", "memory", "autoresearch.json");
   if (!existsSync39(memoryPath))
     return "";
   try {
@@ -43711,12 +44750,12 @@ var init_dream_engine = __esm({
         const content = String(args["content"] ?? "");
         if (!rawPath)
           return { success: false, output: "", error: "path is required", durationMs: Date.now() - start };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join49(this.autoresearchDir, basename12(rawPath)) : join49(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join53(this.autoresearchDir, basename12(rawPath)) : join53(this.autoresearchDir, rawPath);
         if (!targetPath.startsWith(this.autoresearchDir)) {
           return { success: false, output: "", error: "Autoresearch mode: writes are confined to .oa/autoresearch/", durationMs: Date.now() - start };
         }
         try {
-          const dir = join49(targetPath, "..");
+          const dir = join53(targetPath, "..");
           mkdirSync16(dir, { recursive: true });
           writeFileSync16(targetPath, content, "utf-8");
           return { success: true, output: `Wrote ${content.length} bytes to ${rawPath}`, durationMs: Date.now() - start };
@@ -43746,7 +44785,7 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join49(this.autoresearchDir, basename12(rawPath)) : join49(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join53(this.autoresearchDir, basename12(rawPath)) : join53(this.autoresearchDir, rawPath);
         if (!targetPath.startsWith(this.autoresearchDir)) {
           return { success: false, output: "", error: "Autoresearch mode: edits are confined to .oa/autoresearch/", durationMs: Date.now() - start };
         }
@@ -43800,12 +44839,12 @@ var init_dream_engine = __esm({
         const content = String(args["content"] ?? "");
         if (!rawPath)
           return { success: false, output: "", error: "path is required", durationMs: Date.now() - start };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join49(this.dreamsDir, basename12(rawPath)) : join49(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join53(this.dreamsDir, basename12(rawPath)) : join53(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: writes are confined to .oa/dreams/", durationMs: Date.now() - start };
         }
         try {
-          const dir = join49(targetPath, "..");
+          const dir = join53(targetPath, "..");
           mkdirSync16(dir, { recursive: true });
           writeFileSync16(targetPath, content, "utf-8");
           return { success: true, output: `Wrote ${content.length} bytes to ${rawPath}`, durationMs: Date.now() - start };
@@ -43835,7 +44874,7 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join49(this.dreamsDir, basename12(rawPath)) : join49(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join53(this.dreamsDir, basename12(rawPath)) : join53(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: edits are confined to .oa/dreams/", durationMs: Date.now() - start };
         }
@@ -43902,7 +44941,7 @@ var init_dream_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.dreamsDir = join49(repoRoot, ".oa", "dreams");
+        this.dreamsDir = join53(repoRoot, ".oa", "dreams");
         this.state = {
           mode: "default",
           active: false,
@@ -43986,7 +45025,7 @@ ${result.summary}`;
             if (mode !== "default" || cycle === totalCycles) {
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
-              const summaryPath = join49(this.dreamsDir, `cycle-${cycle}-summary.md`);
+              const summaryPath = join53(this.dreamsDir, `cycle-${cycle}-summary.md`);
               writeFileSync16(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
@@ -44199,7 +45238,7 @@ After synthesis, call task_complete with the final prioritized summary.`, toolMo
       }
       /** Build role-specific tool sets for swarm agents */
       buildSwarmTools(role, _workspace) {
-        const autoresearchDir = join49(this.repoRoot, ".oa", "autoresearch");
+        const autoresearchDir = join53(this.repoRoot, ".oa", "autoresearch");
         const taskComplete = this.createSwarmTaskCompleteTool(role);
         switch (role) {
           case "researcher": {
@@ -44563,7 +45602,7 @@ INSTRUCTIONS:
 2. Summarize the key learnings and next steps
 
 Call task_complete with a human-readable summary of the autoresearch session.`, workspace, onEvent);
-        const reportPath = join49(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
+        const reportPath = join53(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
         const report = `# Autoresearch Swarm Report \u2014 Cycle ${cycleNum}
 
 **Date**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
@@ -44652,7 +45691,7 @@ ${summaryResult}
       }
       /** Save workspace backup for lucid mode */
       saveVersionCheckpoint(cycle) {
-        const checkpointDir = join49(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
+        const checkpointDir = join53(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
           mkdirSync16(checkpointDir, { recursive: true });
           try {
@@ -44671,10 +45710,10 @@ ${summaryResult}
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync16(join49(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync16(join49(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync16(join49(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync16(join49(checkpointDir, "checkpoint.json"), JSON.stringify({
+            writeFileSync16(join53(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync16(join53(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync16(join53(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync16(join53(checkpointDir, "checkpoint.json"), JSON.stringify({
               cycle,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               gitHash,
@@ -44682,7 +45721,7 @@ ${summaryResult}
             }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync16(join49(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
+            writeFileSync16(join53(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (no git)`);
           }
         } catch (err) {
@@ -44740,14 +45779,14 @@ ${files.map((f) => `- [\`${f}\`](./${f})`).join("\n")}
 ---
 *Auto-generated by open-agents dream engine*
 `;
-          writeFileSync16(join49(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync16(join53(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync16(join49(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync16(join53(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
@@ -45122,7 +46161,7 @@ var init_bless_engine = __esm({
 
 // packages/cli/dist/tui/dmn-engine.js
 import { existsSync as existsSync40, readFileSync as readFileSync29, writeFileSync as writeFileSync17, mkdirSync as mkdirSync17, readdirSync as readdirSync13, unlinkSync as unlinkSync9 } from "node:fs";
-import { join as join50, basename as basename13 } from "node:path";
+import { join as join54, basename as basename13 } from "node:path";
 function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer) {
   const competenceReport = competence.length > 0 ? competence.map((c3) => {
     const rate = c3.attempts > 0 ? Math.round(c3.successes / c3.attempts * 100) : 0;
@@ -45235,8 +46274,8 @@ var init_dmn_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.stateDir = join50(repoRoot, ".oa", "dmn");
-        this.historyDir = join50(repoRoot, ".oa", "dmn", "cycles");
+        this.stateDir = join54(repoRoot, ".oa", "dmn");
+        this.historyDir = join54(repoRoot, ".oa", "dmn", "cycles");
         mkdirSync17(this.historyDir, { recursive: true });
         this.loadState();
       }
@@ -45826,8 +46865,8 @@ OUTPUT: Call task_complete with JSON:
       async gatherMemoryTopics() {
         const topics = [];
         const dirs = [
-          join50(this.repoRoot, ".oa", "memory"),
-          join50(this.repoRoot, ".open-agents", "memory")
+          join54(this.repoRoot, ".oa", "memory"),
+          join54(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
           if (!existsSync40(dir))
@@ -45846,7 +46885,7 @@ OUTPUT: Call task_complete with JSON:
       }
       // ── State persistence ─────────────────────────────────────────────────
       loadState() {
-        const path = join50(this.stateDir, "state.json");
+        const path = join54(this.stateDir, "state.json");
         if (existsSync40(path)) {
           try {
             this.state = JSON.parse(readFileSync29(path, "utf-8"));
@@ -45856,19 +46895,19 @@ OUTPUT: Call task_complete with JSON:
       }
       saveState() {
         try {
-          writeFileSync17(join50(this.stateDir, "state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync17(join54(this.stateDir, "state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
       saveCycleResult(result) {
         try {
           const filename = `cycle-${result.cycleNumber}-${Date.now()}.json`;
-          writeFileSync17(join50(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
+          writeFileSync17(join54(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
           const files = readdirSync13(this.historyDir).filter((f) => f.startsWith("cycle-") && f.endsWith(".json")).sort();
           if (files.length > 50) {
             for (const old of files.slice(0, files.length - 50)) {
               try {
-                unlinkSync9(join50(this.historyDir, old));
+                unlinkSync9(join54(this.historyDir, old));
               } catch {
               }
             }
@@ -45882,7 +46921,7 @@ OUTPUT: Call task_complete with JSON:
 
 // packages/cli/dist/tui/snr-engine.js
 import { existsSync as existsSync41, readdirSync as readdirSync14, readFileSync as readFileSync30 } from "node:fs";
-import { join as join51, basename as basename14 } from "node:path";
+import { join as join55, basename as basename14 } from "node:path";
 function computeDPrime(signalScores, noiseScores) {
   if (signalScores.length === 0 || noiseScores.length === 0)
     return 0;
@@ -46122,8 +47161,8 @@ Call task_complete with the JSON array when done.`, onEvent)
       loadMemoryEntries(topics) {
         const entries = [];
         const dirs = [
-          join51(this.repoRoot, ".oa", "memory"),
-          join51(this.repoRoot, ".open-agents", "memory")
+          join55(this.repoRoot, ".oa", "memory"),
+          join55(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
           if (!existsSync41(dir))
@@ -46135,7 +47174,7 @@ Call task_complete with the JSON array when done.`, onEvent)
               if (topics.length > 0 && !topics.includes(topic))
                 continue;
               try {
-                const data = JSON.parse(readFileSync30(join51(dir, f), "utf-8"));
+                const data = JSON.parse(readFileSync30(join55(dir, f), "utf-8"));
                 for (const [key, val] of Object.entries(data)) {
                   const value = typeof val === "object" && val !== null && "value" in val ? String(val.value) : String(val);
                   entries.push({ topic, key, value });
@@ -46703,7 +47742,7 @@ var init_tool_policy = __esm({
 
 // packages/cli/dist/tui/telegram-bridge.js
 import { mkdirSync as mkdirSync18, existsSync as existsSync42, unlinkSync as unlinkSync10, readdirSync as readdirSync15, statSync as statSync13 } from "node:fs";
-import { join as join52, resolve as resolve28 } from "node:path";
+import { join as join56, resolve as resolve28 } from "node:path";
 import { writeFile as writeFileAsync } from "node:fs/promises";
 function convertMarkdownToTelegramHTML(md) {
   let html = md;
@@ -47468,7 +48507,7 @@ Telegram admin: @${msg.username}` : `Telegram ${isGroup ? "group" : "public"} ch
             return null;
           const buffer = Buffer.from(await res.arrayBuffer());
           const fileName = `${Date.now()}-${fileId.slice(0, 8)}${extension}`;
-          const localPath = join52(this.mediaCacheDir, fileName);
+          const localPath = join56(this.mediaCacheDir, fileName);
           await writeFileAsync(localPath, buffer);
           return localPath;
         } catch {
@@ -48119,7 +49158,7 @@ var init_braille_spinner = __esm({
 // packages/cli/dist/tui/system-metrics.js
 import { loadavg as loadavg3, cpus as cpus3, totalmem as totalmem4, freemem as freemem3, platform as platform4 } from "node:os";
 import { exec as exec3 } from "node:child_process";
-import { readFile as readFile16 } from "node:fs/promises";
+import { readFile as readFile20 } from "node:fs/promises";
 function formatRate(bytesPerSec) {
   if (bytesPerSec < 1024)
     return `${Math.round(bytesPerSec)}B`;
@@ -48131,7 +49170,7 @@ function formatRate(bytesPerSec) {
 }
 async function readProcNetDev() {
   try {
-    const data = await readFile16("/proc/net/dev", "utf8");
+    const data = await readFile20("/proc/net/dev", "utf8");
     let rxTotal = 0;
     let txTotal = 0;
     for (const line of data.split("\n")) {
@@ -49906,7 +50945,7 @@ var init_status_bar = __esm({
 import * as readline2 from "node:readline";
 import { Writable } from "node:stream";
 import { cwd } from "node:process";
-import { resolve as resolve29, join as join53, dirname as dirname18, extname as extname10 } from "node:path";
+import { resolve as resolve29, join as join57, dirname as dirname18, extname as extname10 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
 import { readFileSync as readFileSync32, writeFileSync as writeFileSync18, appendFileSync as appendFileSync4, rmSync as rmSync2, readdirSync as readdirSync16, mkdirSync as mkdirSync19 } from "node:fs";
@@ -49930,9 +50969,9 @@ function getVersion3() {
     const require2 = createRequire2(import.meta.url);
     const thisDir = dirname18(fileURLToPath12(import.meta.url));
     const candidates = [
-      join53(thisDir, "..", "package.json"),
-      join53(thisDir, "..", "..", "package.json"),
-      join53(thisDir, "..", "..", "..", "package.json")
+      join57(thisDir, "..", "package.json"),
+      join57(thisDir, "..", "..", "package.json"),
+      join57(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
       if (existsSync43(pkgPath)) {
@@ -50025,6 +51064,14 @@ function buildTools(repoRoot, config, contextWindowSize) {
     new CodeSandboxTool(repoRoot),
     // Persistent Python REPL — RLM (arxiv:2512.24601)
     new ReplTool(repoRoot),
+    // Memory Metabolism — COHERE Layer 5 (arxiv:2512.13564)
+    new MemoryMetabolismTool(repoRoot),
+    // Identity Kernel — COHERE Layer 6
+    new IdentityKernelTool(repoRoot),
+    // Reflection & Integrity — COHERE Layer 7
+    new ReflectionIntegrityTool(repoRoot),
+    // Exploration & Culture — COHERE Layer 8 (ARCHE)
+    new ExplorationCultureTool(repoRoot),
     // Structured file reading (CSV, JSON, Markdown, binary detection)
     new StructuredReadTool(repoRoot),
     // Vision tools (Moondream — desktop awareness + point-and-click)
@@ -50144,15 +51191,15 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
 function gatherMemorySnippets(root) {
   const snippets = [];
   const dirs = [
-    join53(root, ".oa", "memory"),
-    join53(root, ".open-agents", "memory")
+    join57(root, ".oa", "memory"),
+    join57(root, ".open-agents", "memory")
   ];
   for (const dir of dirs) {
     if (!existsSync43(dir))
       continue;
     try {
       for (const f of readdirSync16(dir).filter((f2) => f2.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync32(join53(dir, f), "utf-8"));
+        const data = JSON.parse(readFileSync32(join57(dir, f), "utf-8"));
         for (const val of Object.values(data)) {
           const v = typeof val === "object" && val !== null && "value" in val ? String(val.value) : String(val);
           if (v.length > 10)
@@ -51174,7 +52221,7 @@ async function startInteractive(config, repoPath) {
   let p2pGateway = null;
   let peerMesh = null;
   let inferenceRouter = null;
-  const secretVault = new SecretVault(join53(repoRoot, ".oa", "vault.enc"));
+  const secretVault = new SecretVault(join57(repoRoot, ".oa", "vault.enc"));
   let adminSessionKey = null;
   const callSubAgents = /* @__PURE__ */ new Map();
   const streamRenderer = new StreamRenderer();
@@ -51383,8 +52430,8 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     const hits = allCompletions.filter((c3) => c3.toLowerCase().startsWith(lower));
     return [hits, line];
   }
-  const HISTORY_DIR = join53(homedir13(), ".open-agents");
-  const HISTORY_FILE = join53(HISTORY_DIR, "repl-history");
+  const HISTORY_DIR = join57(homedir13(), ".open-agents");
+  const HISTORY_FILE = join57(HISTORY_DIR, "repl-history");
   const MAX_HISTORY_LINES = 500;
   let savedHistory = [];
   try {
@@ -51594,7 +52641,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     } catch {
     }
     try {
-      const oaDir = join53(repoRoot, ".oa");
+      const oaDir = join57(repoRoot, ".oa");
       const reconnected = await ExposeGateway.checkAndReconnect(oaDir, {
         onInfo: (msg) => writeContent(() => renderInfo(msg)),
         onError: (msg) => writeContent(() => renderWarning(msg))
@@ -51617,7 +52664,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     } catch {
     }
     try {
-      const oaDir = join53(repoRoot, ".oa");
+      const oaDir = join57(repoRoot, ".oa");
       const reconnectedP2P = await ExposeP2PGateway.checkAndReconnect(oaDir, new NexusTool(repoRoot), {
         onInfo: (msg) => writeContent(() => renderInfo(msg)),
         onError: (msg) => writeContent(() => renderWarning(msg))
@@ -52436,7 +53483,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           kind,
           targetUrl,
           authKey,
-          stateDir: join53(repoRoot, ".oa"),
+          stateDir: join57(repoRoot, ".oa"),
           passthrough: passthrough ?? false,
           loadbalance: loadbalance ?? false,
           endpointAuth: passthrough ? currentConfig.apiKey : void 0,
@@ -52484,7 +53531,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         await tunnelGateway.stop();
         tunnelGateway = null;
       }
-      const newTunnel = new ExposeGateway({ kind, targetUrl, authKey, fullAccess, stateDir: join53(repoRoot, ".oa") });
+      const newTunnel = new ExposeGateway({ kind, targetUrl, authKey, fullAccess, stateDir: join57(repoRoot, ".oa") });
       newTunnel.on("stats", (stats) => {
         statusBar.setExposeStatus({
           status: stats.status,
@@ -52746,7 +53793,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       }
     },
     destroyProject() {
-      const oaPath = join53(repoRoot, OA_DIR);
+      const oaPath = join57(repoRoot, OA_DIR);
       if (existsSync43(oaPath)) {
         try {
           rmSync2(oaPath, { recursive: true, force: true });
@@ -53679,9 +54726,9 @@ var init_run = __esm({
 // packages/indexer/dist/codebase-indexer.js
 import { glob } from "glob";
 import ignore from "ignore";
-import { readFile as readFile17, stat as stat4 } from "node:fs/promises";
+import { readFile as readFile21, stat as stat4 } from "node:fs/promises";
 import { createHash as createHash4 } from "node:crypto";
-import { join as join54, relative as relative3, extname as extname11, basename as basename15 } from "node:path";
+import { join as join58, relative as relative3, extname as extname11, basename as basename15 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -53725,7 +54772,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile17(join54(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile21(join58(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -53740,12 +54787,12 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join54(this.config.rootDir, relativePath);
+          const fullPath = join58(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
               continue;
-            const content = await readFile17(fullPath);
+            const content = await readFile21(fullPath);
             const hash = createHash4("sha256").update(content).digest("hex");
             const ext = extname11(relativePath);
             indexed.push({
@@ -53786,7 +54833,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join54(current.path, part),
+                  path: join58(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -54127,7 +55174,7 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join55, resolve as resolve31 } from "node:path";
+import { join as join59, resolve as resolve31 } from "node:path";
 import { homedir as homedir14 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function redactIfSensitive(key, value) {
@@ -54210,7 +55257,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join55(homedir14(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join59(homedir14(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -54249,7 +55296,7 @@ function handleSet(opts, _config) {
       const coerced = coerceForSettings(key, value);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${redactIfSensitive(key, value)}`);
-      printInfo(`Saved to ${join55(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join59(repoRoot, ".oa", "settings.json")}`);
       printInfo("This override applies only when running in this workspace.");
     } catch (err) {
       printError(`Failed to save: ${err instanceof Error ? err.message : String(err)}`);
@@ -54508,7 +55555,7 @@ __export(eval_exports, {
 });
 import { tmpdir as tmpdir10 } from "node:os";
 import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync19 } from "node:fs";
-import { join as join56 } from "node:path";
+import { join as join60 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -54633,9 +55680,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join56(tmpdir10(), `open-agents-eval-${Date.now()}`);
+  const dir = join60(tmpdir10(), `open-agents-eval-${Date.now()}`);
   mkdirSync20(dir, { recursive: true });
-  writeFileSync19(join56(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  writeFileSync19(join60(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -54695,7 +55742,7 @@ init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
-import { dirname as dirname19, join as join57 } from "node:path";
+import { dirname as dirname19, join as join61 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -54802,7 +55849,7 @@ init_output();
 function getVersion4() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join57(dirname19(fileURLToPath13(import.meta.url)), "..", "package.json");
+    const pkgPath = join61(dirname19(fileURLToPath13(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {