open-agents-ai 0.138.80 → 0.138.82

package/dist/index.js

@@ -5667,6 +5667,21 @@ async function handleCmd(cmd) {
               }
             }
           } catch {}
+          // WO-DL4: IPFS pin the insight content for persistence + cross-node retrieval
+          var _cpiCid = null;
+          try {
+            var _cpiHeliaReady = await _ensureHelia();
+            if (_cpiHeliaReady && _heliaFs) {
+              var _cpiBytes = new TextEncoder().encode(JSON.stringify({ insight: _cpiInsight, category: _cpiCategory, confidence: _cpiConfidence, tier: _cpiTier, agent: agentName, ts: Date.now() }));
+              var _cpiCidObj = await _heliaFs.addBytes(_cpiBytes);
+              for await (var _cpiPin of _heliaNode.pins.add(_cpiCidObj)) {}
+              _cpiCid = _cpiCidObj.toString();
+              dlog('IPFS pinned insight: ' + _cpiCid);
+            }
+          } catch (_cpiIpfsErr) {
+            dlog('IPFS pin failed (graceful): ' + (_cpiIpfsErr.message || _cpiIpfsErr));
+          }
+
           var _cpiDelta = {
             type: 'cohere.learning',
             delta_id: 'insight-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6),
@@ -5676,6 +5691,7 @@ async function handleCmd(cmd) {
             category: _cpiCategory,
             confidence: _cpiConfidence,
             model_tier: _cpiTier,
+            cid: _cpiCid,  // null if IPFS unavailable, CID string if pinned
             timestamp: Date.now(),
           };
           _natsConn.publish('nexus.cohere.learning', _natsCodec.encode(JSON.stringify(_cpiDelta)));
@@ -6971,6 +6987,31 @@ process.on('unhandledRejection', (reason) => {
             mkdirSync(_lStoreDir, { recursive: true });
             writeFileSync(_lStoreFile, JSON.stringify(_lStore, null, 2));
             dlog('COHERE learning ingested from ' + (_lData.source_agent || 'unknown') + ': ' + String(_lData.insight).slice(0, 60));
+
+            // WO-DL4: Cross-pin the CID locally if provided (content persistence)
+            if (_lData.cid && _lData.cid.startsWith('bafy')) {
+              try {
+                var _lCidDir = join(nexusDir, 'ipfs', 'cid-registry');
+                mkdirSync(_lCidDir, { recursive: true });
+                var _lCidFile = join(_lCidDir, 'learning-cids.json');
+                var _lCids = {};
+                try { if (existsSync(_lCidFile)) _lCids = JSON.parse(readFileSync(_lCidFile, 'utf8')); } catch {}
+                _lCids[_lData.delta_id] = { cid: _lData.cid, source: _lData.source_agent, pinned: false, timestamp: Date.now() };
+                writeFileSync(_lCidFile, JSON.stringify(_lCids, null, 2));
+                dlog('CID registered: ' + _lData.cid.slice(0, 20) + '... from ' + _lData.source_agent);
+                // Attempt cross-pin if Helia is ready
+                try {
+                  if (_heliaReady && _heliaNode) {
+                    var { CID: CIDClass } = await import('multiformats/cid');
+                    var _lCidObj = CIDClass.parse(_lData.cid);
+                    for await (var _lPin of _heliaNode.pins.add(_lCidObj)) {}
+                    _lCids[_lData.delta_id].pinned = true;
+                    writeFileSync(_lCidFile, JSON.stringify(_lCids, null, 2));
+                    dlog('Cross-pinned CID: ' + _lData.cid.slice(0, 20));
+                  }
+                } catch {}
+              } catch {}
+            }
           } catch {}
         }
       })().catch(function(e) { dlog('COHERE learning listener error: ' + (e.message || e)); });
@@ -7032,6 +7073,69 @@ process.on('unhandledRejection', (reason) => {
         if (cohereActive) _publishCapacityAnnouncement();
       }, 60000);
 
+      // \u2500\u2500 WO-DL3: Epoch sync \u2014 hash-based state comparison every 5 min \u2500\u2500
+      // Each node publishes a lightweight fingerprint of its memory state.
+      // If hashes differ between same-tier nodes, the lagging node can
+      // request missing insights via nexus.cohere.learning.request.
+      var _epochCounter = 0;
+      function _publishEpochSync() {
+        if (!cohereActive || !_natsConn || !_natsCodec) return;
+        try {
+          // Read local memory store for fingerprinting
+          var _esStoreFile = join(nexusDir, '..', 'memory', 'metabolism', 'store.json');
+          var _esStore = [];
+          try { if (existsSync(_esStoreFile)) _esStore = JSON.parse(readFileSync(_esStoreFile, 'utf8')); } catch {}
+
+          // Compute top-10 memory IDs sorted by utility*confidence (deterministic)
+          var _esFiltered = _esStore
+            .filter(function(m) { return m.type !== 'quarantine' && m.scores && m.scores.confidence > 0.15; })
+            .sort(function(a, b) { return (b.scores.utility * b.scores.confidence) - (a.scores.utility * a.scores.confidence); })
+            .slice(0, 10);
+          var _esTopIds = _esFiltered.map(function(m) { return m.id; }).sort().join(',');
+
+          // SHA-256 hash of top-10 IDs for compact comparison
+          var _esHash = require('crypto').createHash('sha256').update(_esTopIds).digest('hex').slice(0, 16);
+
+          _epochCounter++;
+          var _esAnnouncement = {
+            type: 'cohere.epoch',
+            peer: nexus.peerId,
+            agentName: agentName,
+            epoch: _epochCounter,
+            memoryCount: _esStore.length,
+            topHash: _esHash,
+            insightsAvailable: _esFiltered.length,
+            timestamp: Date.now(),
+          };
+          _natsConn.publish('nexus.cohere.learning.epoch', _natsCodec.encode(JSON.stringify(_esAnnouncement)));
+          dlog('Epoch sync published: epoch=' + _epochCounter + ' memories=' + _esStore.length + ' hash=' + _esHash);
+        } catch (e) {
+          dlog('Epoch sync error: ' + (e.message || e));
+        }
+      }
+
+      // Epoch sync every 5 minutes
+      setInterval(function() {
+        if (cohereActive) _publishEpochSync();
+      }, 300000);
+      // Also publish on startup after a brief delay
+      setTimeout(function() { if (cohereActive) _publishEpochSync(); }, 10000);
+
+      // Listen for epoch announcements from other nodes
+      var _epochSub = _natsConn.subscribe('nexus.cohere.learning.epoch');
+      (async function() {
+        for await (var _eMsg of _epochSub) {
+          try {
+            var _eData = JSON.parse(_natsCodec.decode(_eMsg.data));
+            if (!_eData.peer || _eData.peer === nexus.peerId) continue;
+            // Log peer epoch state for dashboard visibility
+            dlog('Epoch from ' + (_eData.agentName || 'peer') + ': epoch=' + _eData.epoch + ' memories=' + _eData.memoryCount + ' hash=' + _eData.topHash);
+            // Future: if our hash differs and they have more insights, request sync
+          } catch {}
+        }
+      })().catch(function(e) { dlog('Epoch listener error: ' + (e.message || e)); });
+      dlog('Epoch sync listener active on nexus.cohere.learning.epoch');
+
       // Lazy-init IPFS in background (non-blocking)
       _ensureHelia().catch(function() {});
     }
@@ -22200,6 +22304,10 @@ var init_agenticRunner = __esm({
       get taskState() {
         return this._taskState;
       }
+      /** Get the backend (for post-task LLM extraction calls) */
+      getBackend() {
+        return this.backend;
+      }
       /** Get the file state registry (for external inspection) */
       get fileRegistry() {
         return this._fileRegistry;
@@ -43781,7 +43889,7 @@ async function handlePeerEndpoint(peerId, authKey, ctx, local) {
   }
 }
 async function handleParallel(arg, ctx) {
-  const { execSync: execSync30 } = await import("node:child_process");
+  const { execSync: execSync31 } = await import("node:child_process");
   const baseUrl = ctx.config.backendUrl || "http://localhost:11434";
   const isRemote = ctx.config.backendType === "nexus";
   if (isRemote) {
@@ -43805,7 +43913,7 @@ async function handleParallel(arg, ctx) {
     }
     let systemdVal = "";
     try {
-      const out = execSync30("systemctl show ollama.service -p Environment 2>/dev/null || true", { encoding: "utf8" });
+      const out = execSync31("systemctl show ollama.service -p Environment 2>/dev/null || true", { encoding: "utf8" });
       const match = out.match(/OLLAMA_NUM_PARALLEL=(\d+)/);
       if (match)
         systemdVal = match[1];
@@ -43834,7 +43942,7 @@ async function handleParallel(arg, ctx) {
   }
   const isSystemd = (() => {
     try {
-      const out = execSync30("systemctl is-active ollama.service 2>/dev/null", { encoding: "utf8" }).trim();
+      const out = execSync31("systemctl is-active ollama.service 2>/dev/null", { encoding: "utf8" }).trim();
       return out === "active" || out === "inactive";
     } catch {
       return false;
@@ -43848,10 +43956,10 @@ async function handleParallel(arg, ctx) {
       const overrideContent = `[Service]
 Environment="OLLAMA_NUM_PARALLEL=${n}"
 `;
-      execSync30(`sudo mkdir -p ${overrideDir}`, { stdio: "pipe" });
-      execSync30(`echo '${overrideContent}' | sudo tee ${overrideFile} > /dev/null`, { stdio: "pipe" });
-      execSync30("sudo systemctl daemon-reload", { stdio: "pipe" });
-      execSync30("sudo systemctl restart ollama.service", { stdio: "pipe" });
+      execSync31(`sudo mkdir -p ${overrideDir}`, { stdio: "pipe" });
+      execSync31(`echo '${overrideContent}' | sudo tee ${overrideFile} > /dev/null`, { stdio: "pipe" });
+      execSync31("sudo systemctl daemon-reload", { stdio: "pipe" });
+      execSync31("sudo systemctl restart ollama.service", { stdio: "pipe" });
       let ready = false;
       for (let i = 0; i < 30 && !ready; i++) {
         await new Promise((r) => setTimeout(r, 500));
@@ -43878,7 +43986,7 @@ Environment="OLLAMA_NUM_PARALLEL=${n}"
     renderInfo(`Setting OLLAMA_NUM_PARALLEL=${n}...`);
     try {
       try {
-        execSync30("pkill -f 'ollama serve' 2>/dev/null || true", { stdio: "pipe" });
+        execSync31("pkill -f 'ollama serve' 2>/dev/null || true", { stdio: "pipe" });
       } catch {
       }
       await new Promise((r) => setTimeout(r, 1e3));
@@ -44630,18 +44738,18 @@ async function showExposeDashboard(gateway, rl, ctx) {
           const cmd = `/endpoint ${id} --auth ${gateway.authKey ?? ""}`;
           let copied = false;
           try {
-            const { execSync: execSync30 } = __require("node:child_process");
+            const { execSync: execSync31 } = __require("node:child_process");
             const platform5 = process.platform;
             if (platform5 === "darwin") {
-              execSync30("pbcopy", { input: cmd, timeout: 3e3 });
+              execSync31("pbcopy", { input: cmd, timeout: 3e3 });
               copied = true;
             } else if (platform5 === "win32") {
-              execSync30("clip", { input: cmd, timeout: 3e3 });
+              execSync31("clip", { input: cmd, timeout: 3e3 });
               copied = true;
             } else {
               for (const tool of ["xclip -selection clipboard", "xsel --clipboard --input", "wl-copy"]) {
                 try {
-                  execSync30(tool, { input: cmd, timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] });
+                  execSync31(tool, { input: cmd, timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] });
                   copied = true;
                   break;
                 } catch {
@@ -52079,15 +52187,301 @@ var init_system_metrics = __esm({
   }
 });
 
+// packages/cli/dist/tui/text-selection.js
+import { execSync as execSync29 } from "node:child_process";
+function stripAnsi3(s) {
+  return s.replace(/\x1B\[[0-9;]*[A-Za-z]|\x1B\].*?(?:\x07|\x1B\\)/g, "");
+}
+function visibleLength(s) {
+  return stripAnsi3(s).length;
+}
+function copyText(text) {
+  try {
+    const platform5 = process.platform;
+    if (platform5 === "darwin") {
+      execSync29("pbcopy", { input: text, timeout: 3e3 });
+      return true;
+    }
+    if (platform5 === "win32") {
+      execSync29("clip", { input: text, timeout: 3e3 });
+      return true;
+    }
+    for (const tool of ["xclip -selection clipboard", "xsel --clipboard --input", "wl-copy"]) {
+      try {
+        execSync29(tool, { input: text, timeout: 3e3 });
+        return true;
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  try {
+    const b64 = Buffer.from(text).toString("base64");
+    process.stdout.write(`\x1B]52;c;${b64}\x07`);
+    return true;
+  } catch {
+  }
+  return false;
+}
+function computeHeaderButtons(termWidth) {
+  const buttons = ["/help", "/voice", "/cohere", "/model"];
+  const GAP = 2;
+  const result = [];
+  let col = termWidth - 1;
+  for (let i = buttons.length - 1; i >= 0; i--) {
+    const label = ` ${buttons[i]} `;
+    const endCol = col;
+    const startCol = col - label.length + 1;
+    if (startCol < 1)
+      break;
+    result.unshift({
+      label,
+      command: buttons[i],
+      startCol,
+      endCol,
+      row: 3
+    });
+    col = startCol - GAP - 1;
+  }
+  return result;
+}
+function renderHeaderButtons(termWidth) {
+  const buttons = computeHeaderButtons(termWidth);
+  if (buttons.length === 0)
+    return "";
+  let out = "";
+  for (const btn of buttons) {
+    out += `\x1B[${btn.row};${btn.startCol}H`;
+    out += `\x1B[1;${SEL_FG}m\x1B[48;5;${SEL_BG}m${btn.label}\x1B[0m`;
+  }
+  return out;
+}
+function hitTestHeaderButton(row, col, termWidth) {
+  const buttons = computeHeaderButtons(termWidth);
+  for (const btn of buttons) {
+    if (row === btn.row && col >= btn.startCol && col <= btn.endCol) {
+      return btn.command;
+    }
+  }
+  return null;
+}
+var SEL_BG, SEL_FG, SEL_START, SEL_END, TextSelection;
+var init_text_selection = __esm({
+  "packages/cli/dist/tui/text-selection.js"() {
+    "use strict";
+    SEL_BG = 178;
+    SEL_FG = 30;
+    SEL_START = `\x1B[${SEL_FG}m\x1B[48;5;${SEL_BG}m`;
+    SEL_END = `\x1B[0m`;
+    TextSelection = class {
+      _selection = null;
+      _active = false;
+      // true while mouse button is held
+      _blockModeArmed = false;
+      // Ctrl+Shift+B pressed, next click starts block select
+      _provider;
+      constructor(provider) {
+        this._provider = provider;
+      }
+      /** Whether a selection currently exists */
+      get hasSelection() {
+        return this._selection !== null;
+      }
+      /** Whether we're actively dragging */
+      get isDragging() {
+        return this._active;
+      }
+      /** Get the current selection range (or null) */
+      get selection() {
+        return this._selection;
+      }
+      /** Arm block selection mode — next click starts rectangular select */
+      armBlockMode() {
+        this._blockModeArmed = true;
+      }
+      /** Clear the current selection */
+      clear() {
+        this._selection = null;
+        this._active = false;
+        this._blockModeArmed = false;
+      }
+      /**
+       * Handle mouse press (button 0, M suffix in SGR).
+       * Starts a new selection from the click position.
+       */
+      onMousePress(row, col) {
+        const mode = this._blockModeArmed ? "block" : "line";
+        this._blockModeArmed = false;
+        this._selection = {
+          anchor: { row, col },
+          current: { row, col },
+          mode
+        };
+        this._active = true;
+      }
+      /**
+       * Handle mouse drag (button 32, M suffix in SGR).
+       * Extends the selection to the current cursor position.
+       */
+      onMouseDrag(row, col) {
+        if (!this._active || !this._selection)
+          return;
+        this._selection.current = { row, col };
+      }
+      /**
+       * Handle mouse release (button 0, m suffix in SGR).
+       * Finalizes the selection.
+       */
+      onMouseRelease(row, col) {
+        if (!this._active || !this._selection)
+          return;
+        this._selection.current = { row, col };
+        this._active = false;
+        if (this._selection.anchor.row === this._selection.current.row && this._selection.anchor.col === this._selection.current.col) {
+          this._selection = null;
+        }
+      }
+      /**
+       * Compute which content buffer indices and column ranges are selected.
+       * Returns an array of { bufferIdx, startCol, endCol } for each selected line.
+       * Columns are 0-based visible character positions.
+       */
+      getSelectedRanges() {
+        if (!this._selection)
+          return [];
+        const { anchor, current, mode } = this._selection;
+        const top = this._provider.getScrollRegionTop();
+        const height = this._provider.getContentHeight();
+        const offset = this._provider.getScrollOffset();
+        const totalLines = this._provider.getContentLines().length;
+        const startIdx = Math.max(0, totalLines - height - offset);
+        const anchorBufIdx = startIdx + (anchor.row - top);
+        const currentBufIdx = startIdx + (current.row - top);
+        const minRow = Math.min(anchorBufIdx, currentBufIdx);
+        const maxRow = Math.max(anchorBufIdx, currentBufIdx);
+        const minCol = Math.min(anchor.col, current.col);
+        const maxCol = Math.max(anchor.col, current.col);
+        const ranges = [];
+        if (mode === "block") {
+          for (let idx = minRow; idx <= maxRow; idx++) {
+            if (idx >= 0 && idx < totalLines) {
+              ranges.push({ bufferIdx: idx, startCol: minCol - 1, endCol: maxCol - 1 });
+            }
+          }
+        } else {
+          const isForward = anchorBufIdx < currentBufIdx || anchorBufIdx === currentBufIdx && anchor.col <= current.col;
+          const startR = isForward ? anchorBufIdx : currentBufIdx;
+          const endR = isForward ? currentBufIdx : anchorBufIdx;
+          const startC = isForward ? anchor.col - 1 : current.col - 1;
+          const endC = isForward ? current.col - 1 : anchor.col - 1;
+          for (let idx = startR; idx <= endR; idx++) {
+            if (idx < 0 || idx >= totalLines)
+              continue;
+            const lineLen = visibleLength(this._provider.getContentLines()[idx] ?? "");
+            if (idx === startR && idx === endR) {
+              ranges.push({ bufferIdx: idx, startCol: startC, endCol: endC });
+            } else if (idx === startR) {
+              ranges.push({ bufferIdx: idx, startCol: startC, endCol: Math.max(lineLen, startC) });
+            } else if (idx === endR) {
+              ranges.push({ bufferIdx: idx, startCol: 0, endCol: endC });
+            } else {
+              ranges.push({ bufferIdx: idx, startCol: 0, endCol: lineLen });
+            }
+          }
+        }
+        return ranges;
+      }
+      /**
+       * Apply selection highlighting to a content line for rendering.
+       * Takes the original ANSI line and returns it with selection highlight applied.
+       *
+       * @param line  Original content line (with ANSI codes)
+       * @param startCol  0-based visible start column to highlight
+       * @param endCol    0-based visible end column to highlight (inclusive)
+       * @returns  Line with selection highlight overlay
+       */
+      static applyHighlight(line, startCol, endCol) {
+        const plain = stripAnsi3(line);
+        if (startCol > plain.length || endCol < 0 || startCol > endCol)
+          return line;
+        const sc = Math.max(0, startCol);
+        const ec = Math.min(plain.length - 1, endCol);
+        let result = "";
+        let visPos = 0;
+        let i = 0;
+        let inHighlight = false;
+        while (i < line.length) {
+          const escMatch = line.slice(i).match(/^(\x1B\[[0-9;]*[A-Za-z]|\x1B\].*?(?:\x07|\x1B\\))/);
+          if (escMatch) {
+            if (inHighlight) {
+              result += SEL_END + escMatch[0] + SEL_START;
+            } else {
+              result += escMatch[0];
+            }
+            i += escMatch[0].length;
+            continue;
+          }
+          if (visPos === sc && !inHighlight) {
+            result += SEL_START;
+            inHighlight = true;
+          }
+          result += line[i];
+          if (visPos === ec && inHighlight) {
+            result += SEL_END;
+            inHighlight = false;
+          }
+          visPos++;
+          i++;
+        }
+        if (inHighlight)
+          result += SEL_END;
+        return result;
+      }
+      /**
+       * Get the selected text content (plain text, no ANSI codes).
+       * For block mode, each line is joined with newline.
+       * For line mode, text flows continuously with newlines between lines.
+       */
+      getSelectedText() {
+        const ranges = this.getSelectedRanges();
+        if (ranges.length === 0)
+          return "";
+        const lines = this._provider.getContentLines();
+        const parts = [];
+        for (const { bufferIdx, startCol, endCol } of ranges) {
+          const raw = lines[bufferIdx] ?? "";
+          const plain = stripAnsi3(raw);
+          const selected = plain.slice(Math.max(0, startCol), Math.min(plain.length, endCol + 1));
+          parts.push(selected);
+        }
+        return parts.join("\n");
+      }
+      /**
+       * Copy current selection to system clipboard.
+       * Tries platform commands first, falls back to OSC 52.
+       * Returns true if copy succeeded.
+       */
+      copyToClipboard() {
+        const text = this.getSelectedText();
+        if (!text)
+          return false;
+        return copyText(text);
+      }
+    };
+  }
+});
+
 // packages/cli/dist/tui/status-bar.js
 import { readFileSync as readFileSync31 } from "node:fs";
-var EXPERT_TOOL_BASELINES, CONTEXT_SWITCH_OVERHEAD, TURN_PLANNING_OVERHEAD, DEFAULT_TOOL_BASELINE, CODE_READ_CHARS_PER_SEC, PROSE_READ_CHARS_PER_SEC, MIN_CONTENT_FOR_READING, CODE_CONTENT_TOOLS, PROSE_CONTENT_TOOLS, HumanSpeedTracker, PANEL_BG, CONTENT_BG, PANEL_BG_SEQ, CONTENT_BG_SEQ, RESET, StatusBar;
+var EXPERT_TOOL_BASELINES, CONTEXT_SWITCH_OVERHEAD, TURN_PLANNING_OVERHEAD, DEFAULT_TOOL_BASELINE, CODE_READ_CHARS_PER_SEC, PROSE_READ_CHARS_PER_SEC, MIN_CONTENT_FOR_READING, CODE_CONTENT_TOOLS, PROSE_CONTENT_TOOLS, HumanSpeedTracker, PANEL_BG, CONTENT_BG, TEXT_PRIMARY, PANEL_BG_SEQ, CONTENT_BG_SEQ, RESET, StatusBar;
 var init_status_bar = __esm({
   "packages/cli/dist/tui/status-bar.js"() {
     "use strict";
     init_render();
     init_braille_spinner();
     init_system_metrics();
+    init_text_selection();
     EXPERT_TOOL_BASELINES = {
       file_read: 12,
       structured_read: 15,
@@ -52247,6 +52641,7 @@ var init_status_bar = __esm({
     };
     PANEL_BG = 234;
     CONTENT_BG = 233;
+    TEXT_PRIMARY = 178;
     PANEL_BG_SEQ = `\x1B[48;5;${PANEL_BG}m`;
     CONTENT_BG_SEQ = `\x1B[48;5;${CONTENT_BG}m`;
     RESET = "\x1B[0m";
@@ -52274,6 +52669,15 @@ var init_status_bar = __esm({
       _mouseIdleTimer = null;
       static MOUSE_IDLE_MS = 1500;
       // disable after 1.5s idle
+      /** Text selection state — tracks click-drag selection for copy */
+      _textSelection = new TextSelection({
+        getContentLines: () => this._contentLines,
+        getScrollOffset: () => this._contentScrollOffset,
+        getContentHeight: () => this.contentHeight,
+        getScrollRegionTop: () => this.scrollRegionTop
+      });
+      /** Callback for header button clicks — fires slash commands */
+      _headerButtonHandler = null;
       /** Banner refresh callback — called after resize to re-render top rows */
       _bannerRefresh = null;
       /** Track previous terminal dimensions to clear ghost separators on resize */
@@ -52917,6 +53321,91 @@ var init_status_bar = __esm({
           this._mouseIdleTimer = null;
         }
       }
+      // ── Text Selection + Header Buttons ─────────────────────────────────
+      /** Set the handler for header button clicks (dispatches slash commands) */
+      setHeaderButtonHandler(handler) {
+        this._headerButtonHandler = handler;
+      }
+      /** Get the text selection instance (for external keyboard shortcut wiring) */
+      get textSelection() {
+        return this._textSelection;
+      }
+      /**
+       * Handle a mouse pointer event (press/drag/release).
+       * Called by MouseFilterStream's pointer handler.
+       * Routes to: header button clicks, text selection, or ignored.
+       */
+      handlePointerEvent(type, col, row) {
+        if (!this.active)
+          return;
+        if (type === "press" && row < this.scrollRegionTop) {
+          const w = process.stdout.columns ?? 80;
+          const cmd = hitTestHeaderButton(row, col, w);
+          if (cmd && this._headerButtonHandler) {
+            this._headerButtonHandler(cmd);
+            return;
+          }
+        }
+        if (row < this.scrollRegionTop)
+          return;
+        const rows = process.stdout.rows ?? 24;
+        const fh = this._currentFooterHeight;
+        const footerStart = rows - fh + 1;
+        if (row >= footerStart)
+          return;
+        if (type === "press") {
+          this._textSelection.clear();
+          this._textSelection.onMousePress(row, col);
+          this.repaintContent();
+        } else if (type === "drag") {
+          this._textSelection.onMouseDrag(row, col);
+          if (this._textSelection.isDragging)
+            this.repaintContent();
+        } else if (type === "release") {
+          this._textSelection.onMouseRelease(row, col);
+          this.repaintContent();
+        }
+      }
+      /** Copy current selection to clipboard. Returns true if copied. */
+      copySelection() {
+        if (!this._textSelection.hasSelection)
+          return false;
+        const ok = this._textSelection.copyToClipboard();
+        if (ok) {
+          const rows = process.stdout.rows ?? 24;
+          const pos = this.rowPositions(rows);
+          const writer = this._origWrite ?? process.stdout.write.bind(process.stdout);
+          writer(`\x1B[${pos.metricsRow};1H\x1B[2K\x1B[38;5;${TEXT_PRIMARY}m  \u2713 Copied to clipboard\x1B[0m`);
+          setTimeout(() => {
+            if (this.active)
+              this.renderFooterAndPositionInput();
+          }, 1200);
+        }
+        return ok;
+      }
+      /** Arm block (rectangular) selection mode — next click starts block select */
+      armBlockSelection() {
+        this._textSelection.armBlockMode();
+        const rows = process.stdout.rows ?? 24;
+        const pos = this.rowPositions(rows);
+        const writer = this._origWrite ?? process.stdout.write.bind(process.stdout);
+        writer(`\x1B[${pos.metricsRow};1H\x1B[2K\x1B[38;5;${TEXT_PRIMARY}m  \u25A0 Block selection mode \u2014 click and drag\x1B[0m`);
+        setTimeout(() => {
+          if (this.active)
+            this.renderFooterAndPositionInput();
+        }, 1500);
+      }
+      /** Render header buttons overlay on banner row 3 */
+      renderHeaderButtons() {
+        if (!this.active)
+          return;
+        const w = process.stdout.columns ?? 80;
+        const overlay = renderHeaderButtons(w);
+        if (overlay) {
+          const writer = this._origWrite ?? process.stdout.write.bind(process.stdout);
+          writer(overlay);
+        }
+      }
       /** Set a callback to re-render the banner after resize/redraw */
       setBannerRefresh(refresh) {
         this._bannerRefresh = refresh;
@@ -53111,6 +53600,7 @@ ${CONTENT_BG_SEQ}`);
       scrollContentUp(lines = 1) {
         if (!this.active)
           return;
+        this._textSelection.clear();
         this.cancelMouseIdle();
         this.enableMouseTracking();
         const maxOffset = Math.max(0, this._contentLines.length - this.contentHeight);
@@ -53122,6 +53612,7 @@ ${CONTENT_BG_SEQ}`);
       scrollContentDown(lines = 1) {
         if (!this.active)
           return;
+        this._textSelection.clear();
         this.cancelMouseIdle();
         this.enableMouseTracking();
         this._contentScrollOffset = Math.max(0, this._contentScrollOffset - lines);
@@ -53158,10 +53649,18 @@ ${CONTENT_BG_SEQ}`);
         let buf = "\x1B[?2026h";
         buf += "\x1B7";
         buf += "\x1B[?25l";
+        const selRanges = this._textSelection.hasSelection ? this._textSelection.getSelectedRanges() : [];
+        const selByBuf = /* @__PURE__ */ new Map();
+        for (const r of selRanges)
+          selByBuf.set(r.bufferIdx, r);
         for (let row = 0; row < h; row++) {
           const lineIdx = startIdx + row;
-          const line = lineIdx < totalLines ? this._contentLines[lineIdx] : "";
+          let line = lineIdx < totalLines ? this._contentLines[lineIdx] : "";
           const screenRow = this.scrollRegionTop + row;
+          const sel = selByBuf.get(lineIdx);
+          if (sel) {
+            line = TextSelection.applyHighlight(line, sel.startCol, sel.endCol);
+          }
           buf += `\x1B[${screenRow};1H${CONTENT_BG_SEQ}\x1B[2K${line}`;
         }
         if (this._contentScrollOffset > 0) {
@@ -53813,6 +54312,22 @@ ${CONTENT_BG_SEQ}`);
             onCtrlO();
             return;
           }
+          if (key?.ctrl && key?.shift && key?.name === "c") {
+            self.copySelection();
+            return;
+          }
+          if (s === "\x1B[67;6u") {
+            self.copySelection();
+            return;
+          }
+          if (key?.ctrl && key?.shift && key?.name === "b") {
+            self.armBlockSelection();
+            return;
+          }
+          if (s === "\x1B[66;6u") {
+            self.armBlockSelection();
+            return;
+          }
           if (s && (/\x1B\[</.test(s) || /^\d+;\d+;\d*[Mm]/.test(s) || /^;\d+[Mm]/.test(s) || /\[<\d/.test(s))) {
             return;
           }
@@ -53936,11 +54451,13 @@ var init_mouse_filter = __esm({
       buffer = "";
       onScroll = null;
       onActivity = null;
+      onPointer = null;
       flushTimer = null;
-      constructor(scrollHandler, activityHandler) {
+      constructor(scrollHandler, activityHandler, pointerHandler) {
         super();
         this.onScroll = scrollHandler;
         this.onActivity = activityHandler ?? null;
+        this.onPointer = pointerHandler ?? null;
       }
       _transform(chunk, _encoding, callback) {
         this.buffer += chunk.toString();
@@ -53956,10 +54473,20 @@ var init_mouse_filter = __esm({
             if (mouseMatch) {
               const btn = parseInt(mouseMatch[1]);
               const row = parseInt(mouseMatch[3]);
+              const col = parseInt(mouseMatch[2]);
+              const suffix = mouseMatch[4];
               if ((btn === 64 || btn === 96) && this.onScroll)
                 this.onScroll("up", 3, row);
               else if ((btn === 65 || btn === 97) && this.onScroll)
                 this.onScroll("down", 3, row);
+              else if (this.onPointer) {
+                if (btn === 0 && suffix === "M")
+                  this.onPointer("press", col, row);
+                else if (btn === 32 && suffix === "M")
+                  this.onPointer("drag", col, row);
+                else if (btn === 0 && suffix === "m")
+                  this.onPointer("release", col, row);
+              }
               if (this.onActivity)
                 this.onActivity();
               i += mouseMatch[0].length;
@@ -54018,7 +54545,7 @@ 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";
 import { existsSync as existsSync43 } from "node:fs";
-import { execSync as execSync29 } from "node:child_process";
+import { execSync as execSync30 } from "node:child_process";
 import { homedir as homedir13 } from "node:os";
 function formatTimeAgo(date) {
   const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
@@ -55414,7 +55941,10 @@ async function startInteractive(config, repoPath) {
   if (process.stdout.isTTY) {
     const scrollTop = carouselLines > 0 ? carouselLines : 1;
     statusBar.activate(scrollTop);
-    statusBar.setBannerRefresh(() => banner.renderCurrentFrame());
+    statusBar.setBannerRefresh(() => {
+      banner.renderCurrentFrame();
+      statusBar.renderHeaderButtons();
+    });
     const { onOverlayLeave: onOverlayLeave2 } = await Promise.resolve().then(() => (init_overlay_lock(), overlay_lock_exports));
     onOverlayLeave2(() => {
       banner.renderCurrentFrame();
@@ -55424,6 +55954,7 @@ async function startInteractive(config, repoPath) {
     if (cohereEnabled) {
       statusBar.setCohereActive(true);
     }
+    statusBar.renderHeaderButtons();
     if (isResumed) {
       statusBar.beginContentWrite();
       const resumeMsg = hasTaskToResume ? `Updated to v${version} \u2014 picking up where you left off.` : `Updated to v${version}.`;
@@ -55803,6 +56334,8 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     statusBar.cancelMouseIdle();
     statusBar.enableMouseTracking();
     statusBar.scheduleMouseIdle();
+  }, (type, col, row) => {
+    statusBar.handlePointerEvent(type, col, row);
   });
   process.stdin.pipe(mouseFilter);
   const rl = readline2.createInterface({
@@ -55825,6 +56358,21 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
         statusBar.handleResize();
     }
   });
+  let commandCtxRef = null;
+  statusBar.setHeaderButtonHandler((command) => {
+    if (!commandCtxRef)
+      return;
+    (async () => {
+      try {
+        if (statusBar.isActive)
+          statusBar.beginContentWrite();
+        await handleSlashCommand(command, commandCtxRef);
+        if (statusBar.isActive)
+          statusBar.endContentWrite();
+      } catch {
+      }
+    })();
+  });
   rl.output = null;
   if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
     process.stdin.setRawMode(true);
@@ -57214,7 +57762,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
             try {
               if (process.platform === "win32") {
                 try {
-                  execSync29(`taskkill /F /PID ${pid}`, { timeout: 5e3, stdio: "ignore" });
+                  execSync30(`taskkill /F /PID ${pid}`, { timeout: 5e3, stdio: "ignore" });
                 } catch {
                 }
               } else {
@@ -57241,7 +57789,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
               if (pid > 0) {
                 if (process.platform === "win32") {
                   try {
-                    execSync29(`taskkill /F /PID ${pid}`, { timeout: 5e3, stdio: "ignore" });
+                    execSync30(`taskkill /F /PID ${pid}`, { timeout: 5e3, stdio: "ignore" });
                   } catch {
                   }
                 } else {
@@ -57258,7 +57806,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       } catch {
       }
       try {
-        execSync29(process.platform === "win32" ? "timeout /t 1 /nobreak >nul" : "sleep 0.5", { timeout: 3e3, stdio: "ignore" });
+        execSync30(process.platform === "win32" ? "timeout /t 1 /nobreak >nul" : "sleep 0.5", { timeout: 3e3, stdio: "ignore" });
       } catch {
       }
       const oaPath = join59(repoRoot, OA_DIR);
@@ -57272,14 +57820,14 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           } catch (err) {
             if (attempt < 2) {
               try {
-                execSync29(process.platform === "win32" ? "timeout /t 1 /nobreak >nul" : "sleep 0.3", { timeout: 3e3, stdio: "ignore" });
+                execSync30(process.platform === "win32" ? "timeout /t 1 /nobreak >nul" : "sleep 0.3", { timeout: 3e3, stdio: "ignore" });
               } catch {
               }
             } else {
               writeContent(() => renderWarning(`Could not fully remove ${OA_DIR}/: ${err instanceof Error ? err.message : String(err)}`));
               if (process.platform === "win32") {
                 try {
-                  execSync29(`rd /s /q "${oaPath}"`, { timeout: 1e4, stdio: "ignore" });
+                  execSync30(`rd /s /q "${oaPath}"`, { timeout: 1e4, stdio: "ignore" });
                   deleted = true;
                 } catch {
                 }
@@ -57328,6 +57876,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       return { entries: ctx.entries.length, lastSaved: ctx.updatedAt };
     }
   };
+  commandCtxRef = commandCtx;
   showPrompt();
   if (!isResumed) {
     const savedCtx = loadSessionContext(repoRoot);
@@ -58219,19 +58768,48 @@ async function runWithTUI(task, config, repoPath) {
     try {
       const ts = handle.runner?.taskState;
       if (ts && ts.toolCallCount > 2) {
-        let category = "strategy";
-        let lesson = "";
-        if (ts.failedApproaches && ts.failedApproaches.length > 0) {
-          category = "recovery";
-          const failed = ts.failedApproaches.slice(0, 2).join("; ");
-          const worked = ts.completedSteps?.slice(-2).join(" \u2192 ") || "completed task";
-          lesson = `[recovery] Avoid: ${failed}. Instead: ${worked}`;
-        } else if (ts.completedSteps && ts.completedSteps.length > 1) {
-          lesson = `[strategy] ${ts.completedSteps.slice(-3).join(" \u2192 ")}`;
-        } else {
-          lesson = `[strategy] Solved: ${task.slice(0, 150)}`;
-        }
-        if (lesson) {
+        const extractionBackend = handle.runner.getBackend();
+        const modFiles = Array.from(ts.modifiedFiles.entries()).map(([p, a]) => `${p} (${a})`).join(", ");
+        const trajectoryPrompt = `You are a memory extraction system. Given this completed task trajectory, extract ONE concise reusable lesson.
+
+TASK: ${task.slice(0, 300)}
+COMPLETED STEPS: ${(ts.completedSteps || []).slice(-5).join("; ")}
+FAILED APPROACHES: ${(ts.failedApproaches || []).join("; ") || "none"}
+FILES MODIFIED: ${modFiles || "none"}
+TOOL CALLS: ${ts.toolCallCount}
+
+Extract the lesson in EXACTLY this format (no other text):
+CATEGORY: strategy|recovery|optimization
+TRIGGER: <what problem signature activates this \u2014 one line>
+LESSON: <one-sentence generalizable rule \u2014 the actual fix pattern, NOT error messages>
+STEPS: <ordered concrete steps, semicolon-separated>
+
+Rules:
+- LESSON must describe the FIX PATTERN (e.g. "use ?? null after Map.get()"), never the error text
+- Keep total response under 200 characters for LESSON field
+- Use descriptive variable names for non-fixed elements (e.g. "the target file" not "/src/foo.ts")
+- If FAILED APPROACHES exist, category MUST be "recovery"`;
+        const extractionResp = await extractionBackend.chatCompletion({
+          messages: [
+            { role: "system", content: "You extract structured procedural memories from task trajectories. Respond ONLY in the requested format." },
+            { role: "user", content: trajectoryPrompt }
+          ],
+          tools: [],
+          temperature: 0,
+          maxTokens: 300,
+          timeoutMs: 3e4
+        });
+        const raw = extractionResp.choices?.[0]?.message?.content || "";
+        const categoryMatch = raw.match(/CATEGORY:\s*(strategy|recovery|optimization)/i);
+        const triggerMatch = raw.match(/TRIGGER:\s*(.+)/i);
+        const lessonMatch = raw.match(/LESSON:\s*(.+)/i);
+        const stepsMatch = raw.match(/STEPS:\s*(.+)/i);
+        const category = categoryMatch?.[1]?.toLowerCase() || "strategy";
+        const trigger = triggerMatch?.[1]?.trim().slice(0, 150) || "";
+        const lesson = lessonMatch?.[1]?.trim().slice(0, 200) || "";
+        const steps = stepsMatch?.[1]?.trim().slice(0, 300) || "";
+        if (lesson && lesson.length > 5) {
+          const content = `[${category}] TRIGGER: ${trigger} | LESSON: ${lesson}` + (steps ? ` | STEPS: ${steps}` : "");
           const metaDir = join59(repoRoot, ".oa", "memory", "metabolism");
           const storeFile = join59(metaDir, "store.json");
           let store = [];
@@ -58243,15 +58821,15 @@ async function runWithTUI(task, config, repoPath) {
           store.push({
             id: `mem-traj-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
             type: "procedural",
-            content: lesson.slice(0, 500),
-            sourceTrace: "trajectory-extraction",
+            content: content.slice(0, 600),
+            sourceTrace: "llm-trajectory-extraction",
             scores: {
-              novelty: 0.6,
-              utility: category === "recovery" ? 0.8 : 0.6,
-              confidence: 0.7,
+              novelty: 0.7,
+              utility: category === "recovery" ? 0.85 : 0.7,
+              confidence: 0.8,
               identityRelevance: 0.3
             },
-            decision: { action: "admit", reason: `Auto-extracted ${category} from task (${ts.toolCallCount} tool calls)` },
+            decision: { action: "admit", reason: `LLM-extracted ${category} from task (${ts.toolCallCount} tool calls)` },
             createdAt: (/* @__PURE__ */ new Date()).toISOString(),
             lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString(),
             accessCount: 0
@@ -58278,7 +58856,7 @@ async function runWithTUI(task, config, repoPath) {
         const metaFile = join59(repoRoot, ".oa", "memory", "metabolism", "store.json");
         if (existsSync43(metaFile)) {
           const store = JSON.parse(readFileSync32(metaFile, "utf8"));
-          const latest = store.filter((m) => m.sourceTrace === "trajectory-extraction").slice(-1)[0];
+          const latest = store.filter((m) => m.sourceTrace === "trajectory-extraction" || m.sourceTrace === "llm-trajectory-extraction").slice(-1)[0];
           if (latest && latest.scores?.confidence >= 0.6) {
             try {
               const { NexusTool: NexusTool2 } = __require("@open-agents/execution");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.138.80",
+  "version": "0.138.82",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",