rterm-backend 3.0.4 → 3.0.5

package/bin/gybackend.cjs

@@ -284093,6 +284093,37 @@ var WinRMTransport = class {
       await this.deleteShell(shellId);
     }
   }
+  /**
+   * Run a command on an EXISTING (persistent) shell, streaming output chunks to
+   * `onChunk` as they arrive instead of buffering everything. The shell is left
+   * open for the next command (persistent runspace). The caller owns the shell's
+   * lifecycle (createShell/deleteShell) and must serialize commands per shell.
+   */
+  async runCommandOnShell(shellId, command, opts) {
+    const deadline = Date.now() + (opts?.timeoutMs ?? 12e4);
+    const commandId = await this.sendCommand(shellId, command);
+    let stdout = "";
+    let stderr = "";
+    let exitCode = 0;
+    for (; ; ) {
+      if (opts?.signal?.aborted) throw new Error("AbortError");
+      if (Date.now() > deadline) {
+        throw new Error(`WinRM command timed out after ${opts?.timeoutMs ?? 12e4}ms`);
+      }
+      const r = await this.receive(shellId, commandId);
+      stdout += r.stdout;
+      stderr += r.stderr;
+      if (opts?.onChunk) {
+        if (r.stdout) opts.onChunk("stdout", r.stdout);
+        if (r.stderr) opts.onChunk("stderr", r.stderr);
+      }
+      if (r.done) {
+        exitCode = r.exitCode ?? 0;
+        break;
+      }
+    }
+    return { stdout, stderr, exitCode };
+  }
   /** Lightweight connectivity probe: create then immediately delete a shell. */
   async ping() {
     const shellId = await this.createShell();
@@ -284123,7 +284154,7 @@ var WinRMBackend = class {
     const cfg = config2;
     const ptyId = `winrm-${(0, import_node_crypto2.randomUUID)()}`;
     const transport = this.buildTransport(cfg);
-    const instance = { config: cfg, transport, ready: false, failed: false };
+    const instance = { config: cfg, transport, ready: false, failed: false, commandQueue: Promise.resolve() };
     this.instances.set(ptyId, instance);
     void this.probe(instance).then((ok) => {
       if (ok) {
@@ -284166,7 +284197,9 @@ Run commands with exec_command / run_fleet_command. Interactive TUI apps are not
       timeoutMs: 3e4
     });
   }
-  /** Direct command execution — the path TerminalService uses for winrm tabs. */
+  /** Direct command execution — the path TerminalService uses for winrm tabs.
+   * Uses a persistent runspace (reused across commands) + streams output live,
+   * and tracks the working directory so `cd` persists between commands. */
   async executeCommand(ptyId, command, options) {
     const instance = this.instances.get(ptyId);
     if (!instance) {
@@ -284179,16 +284212,60 @@ Run commands with exec_command / run_fleet_command. Interactive TUI apps are not
     if (!waited) {
       throw new Error("WinRM session is still initializing; try again shortly.");
     }
+    const run = instance.commandQueue.then(
+      () => this.executeOnPersistentShell(instance, command, options)
+    );
+    instance.commandQueue = run.catch(() => {
+    });
+    return run;
+  }
+  /** Lazily create (or recreate) the persistent runspace. */
+  async ensurePersistentShell(instance) {
+    if (instance.persistentShellId) return instance.persistentShellId;
+    const shellId = await instance.transport.createShell();
+    instance.persistentShellId = shellId;
+    try {
+      const r = await instance.transport.runCommandOnShell(shellId, "cd", { timeoutMs: 1e4 });
+      const cwd = r.stdout.trim();
+      if (cwd) instance.cwd = cwd;
+    } catch {
+    }
+    return shellId;
+  }
+  async executeOnPersistentShell(instance, command, options) {
     instance.dataCallback?.(`\r
 \x1B[36m\u276F ${command}\x1B[0m\r
 `);
-    const result = await instance.transport.runCommand(command, {
-      timeoutMs: options?.timeoutMs ?? DEFAULT_WINRM_TIMEOUT_MS,
-      signal: options?.signal
-    });
-    if (result.stdout) instance.dataCallback?.(result.stdout);
-    if (result.stderr) {
-      instance.dataCallback?.(`\x1B[33m${result.stderr}\x1B[0m`);
+    let result;
+    const cwdPrefix = instance.cwd ? `cd /d ${instance.cwd} & ` : "";
+    const isCd = /^\s*(cd|chdir)\s+/i.test(command);
+    try {
+      const shellId = await this.ensurePersistentShell(instance);
+      result = await instance.transport.runCommandOnShell(shellId, cwdPrefix + command, {
+        timeoutMs: options?.timeoutMs ?? DEFAULT_WINRM_TIMEOUT_MS,
+        signal: options?.signal,
+        onChunk: (stream, text) => {
+          if (text) instance.dataCallback?.(stream === "stderr" ? `\x1B[33m${text}\x1B[0m` : text);
+        }
+      });
+      if (isCd && result.exitCode === 0) {
+        const target = command.replace(/^\s*(cd|chdir)\s+\/?d?\s*/i, "").replace(/"/g, "").trim();
+        instance.cwd = this.resolveWinCwd(instance.cwd, target);
+      } else if (result.exitCode === 0) {
+        const probe = await instance.transport.runCommandOnShell(shellId, `${cwdPrefix}cd`, { timeoutMs: 1e4 }).catch(() => null);
+        const probeCwd = probe?.stdout.trim().split(/\r?\n/).map((l) => l.trim()).filter((l) => /^[A-Za-z]:\\/.test(l)).pop();
+        if (probeCwd) instance.cwd = probeCwd;
+      }
+    } catch (error40) {
+      instance.persistentShellId = void 0;
+      const shellId = await this.ensurePersistentShell(instance);
+      result = await instance.transport.runCommandOnShell(shellId, cwdPrefix + command, {
+        timeoutMs: options?.timeoutMs ?? DEFAULT_WINRM_TIMEOUT_MS,
+        signal: options?.signal,
+        onChunk: (stream, text) => {
+          if (text) instance.dataCallback?.(stream === "stderr" ? `\x1B[33m${text}\x1B[0m` : text);
+        }
+      });
     }
     instance.dataCallback?.(
       `\r
@@ -284197,6 +284274,22 @@ Run commands with exec_command / run_fleet_command. Interactive TUI apps are not
     );
     return result;
   }
+  /** Resolve a `cd` target (absolute or relative) against the tracked cwd. */
+  resolveWinCwd(currentCwd, target) {
+    if (!target) return currentCwd ?? "";
+    if (/^[A-Za-z]:[\\/]/.test(target)) {
+      return target.replace(/\//g, "\\").replace(/\\+$/, "");
+    }
+    if (/^[A-Za-z]:$/.test(target)) return `${target}\\`;
+    const base = (currentCwd ?? "C:\\").replace(/\\+$/, "");
+    const parts = base.split("\\").filter(Boolean);
+    for (const seg of target.replace(/\//g, "\\").split("\\")) {
+      if (seg === "" || seg === ".") continue;
+      if (seg === "..") parts.pop();
+      else parts.push(seg);
+    }
+    return parts.join("\\");
+  }
   async waitForReady(instance, timeoutMs) {
     if (instance.ready) return true;
     if (instance.failed) return false;
@@ -284217,6 +284310,10 @@ Run commands with exec_command / run_fleet_command. Interactive TUI apps are not
     const instance = this.instances.get(ptyId);
     if (!instance) return;
     this.instances.delete(ptyId);
+    if (instance.persistentShellId) {
+      void instance.transport.deleteShell(instance.persistentShellId);
+      instance.persistentShellId = void 0;
+    }
     instance.exitCallback?.(0);
   }
   onData(ptyId, callback) {
@@ -284227,8 +284324,8 @@ Run commands with exec_command / run_fleet_command. Interactive TUI apps are not
     const instance = this.instances.get(ptyId);
     if (instance) instance.exitCallback = callback;
   }
-  getCwd(_ptyId) {
-    return void 0;
+  getCwd(ptyId) {
+    return this.instances.get(ptyId)?.cwd;
   }
   getHomeDir(_ptyId) {
     return Promise.resolve(void 0);
@@ -284368,6 +284465,35 @@ var SerialBackend = class {
     if (!inst) return void 0;
     return inst.ready ? "ready" : void 0;
   }
+  // --- Serial-specific controls (v3.0.5) ---
+  /** Send a BREAK signal (Cisco password recovery / ROMMON). Default 500ms. */
+  sendBreak(ptyId, durationMs = 500) {
+    const inst = this.instances.get(ptyId);
+    if (!inst || typeof inst.port.break !== "function") return false;
+    try {
+      inst.port.break({ duration: durationMs }, (err) => {
+        if (err) inst.dataCallback?.(`\x1B[31m\u2718 Break failed: ${err.message}\x1B[0m\r
+`);
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Set modem control lines (DTR/RTS/CTS). */
+  setControlLines(ptyId, lines) {
+    const inst = this.instances.get(ptyId);
+    if (!inst || typeof inst.port.set !== "function") return false;
+    try {
+      inst.port.set(lines, (err) => {
+        if (err) inst.dataCallback?.(`\x1B[31m\u2718 set() failed: ${err.message}\x1B[0m\r
+`);
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
 };
 
 // ../../packages/backend/src/services/ShellUtility.ts
@@ -284376,6 +284502,190 @@ function escapeShellPathList(paths) {
   return escaped.join(" ") + (escaped.length ? " " : "");
 }
 
+// ../../packages/backend/src/services/terminal/autoReconnect.ts
+var DEFAULT_BASE = 1e3;
+var DEFAULT_MAX = 6e4;
+var DEFAULT_JITTER = 0.2;
+var AutoReconnect = class {
+  baseDelayMs;
+  maxDelayMs;
+  maxAttempts;
+  jitterRatio;
+  random;
+  setTimeoutFn;
+  clearTimeoutFn;
+  /** terminalId → pending timer handle. */
+  timers = /* @__PURE__ */ new Map();
+  /** terminalId → attempts fired so far. */
+  attempts = /* @__PURE__ */ new Map();
+  /** terminalId → delay used for the pending attempt. */
+  pendingDelay = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.baseDelayMs = Math.max(1, opts.baseDelayMs ?? DEFAULT_BASE);
+    this.maxDelayMs = Math.max(this.baseDelayMs, opts.maxDelayMs ?? DEFAULT_MAX);
+    this.maxAttempts = Math.max(1, opts.maxAttempts ?? Number.POSITIVE_INFINITY);
+    this.jitterRatio = Math.min(1, Math.max(0, opts.jitterRatio ?? DEFAULT_JITTER));
+    this.random = opts.random ?? (() => Math.random());
+    this.setTimeoutFn = opts.setTimeoutFn ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimeoutFn = opts.clearTimeoutFn ?? ((h) => clearTimeout(h));
+  }
+  /** Compute the delay for attempt N (1-based): base * 2^(n-1), capped, ±jitter. */
+  delayForAttempt(attempt) {
+    const expo = this.baseDelayMs * Math.pow(2, Math.max(0, attempt - 1));
+    const capped = Math.min(this.maxDelayMs, expo);
+    const jitter = capped * this.jitterRatio * (this.random() * 2 - 1);
+    return Math.max(1, Math.round(capped + jitter));
+  }
+  /** Whether a schedule is pending for this terminal. */
+  isScheduled(terminalId) {
+    return this.timers.has(terminalId);
+  }
+  /** Attempts fired so far for this terminal. */
+  attemptsFor(terminalId) {
+    return this.attempts.get(terminalId) ?? 0;
+  }
+  /** Snapshot the schedule state for a terminal (undefined if not scheduled). */
+  state(terminalId) {
+    if (!this.timers.has(terminalId)) return void 0;
+    const fired = this.attempts.get(terminalId) ?? 0;
+    return {
+      terminalId,
+      nextAttempt: fired + 1,
+      nextDelayMs: this.pendingDelay.get(terminalId) ?? 0,
+      attemptsFired: fired,
+      active: true
+    };
+  }
+  /**
+   * Schedule the next reconnect attempt for a terminal. `onAttempt` is called
+   * when the timer fires (it should perform the reconnect); `onGiveUp` is
+   * called when maxAttempts is reached. Returns the schedule state, or
+   * undefined if attempts are already exhausted.
+   */
+  schedule(terminalId, onAttempt, onGiveUp) {
+    this.cancel(terminalId);
+    const fired = this.attempts.get(terminalId) ?? 0;
+    const nextAttempt = fired + 1;
+    if (nextAttempt > this.maxAttempts) {
+      onGiveUp?.(fired);
+      return void 0;
+    }
+    const delay = this.delayForAttempt(nextAttempt);
+    this.pendingDelay.set(terminalId, delay);
+    const handle = this.setTimeoutFn(() => {
+      this.timers.delete(terminalId);
+      this.pendingDelay.delete(terminalId);
+      const now = (this.attempts.get(terminalId) ?? 0) + 1;
+      this.attempts.set(terminalId, now);
+      onAttempt(now);
+    }, delay);
+    this.timers.set(terminalId, handle);
+    return {
+      terminalId,
+      nextAttempt,
+      nextDelayMs: delay,
+      attemptsFired: fired,
+      active: true
+    };
+  }
+  /** Cancel a pending schedule (does NOT reset the attempt counter). */
+  cancel(terminalId) {
+    const handle = this.timers.get(terminalId);
+    if (handle !== void 0) {
+      this.clearTimeoutFn(handle);
+      this.timers.delete(terminalId);
+    }
+    this.pendingDelay.delete(terminalId);
+    return handle !== void 0;
+  }
+  /** Reset a terminal's attempt counter (call after a successful reconnect). */
+  reset(terminalId) {
+    this.attempts.delete(terminalId);
+    this.pendingDelay.delete(terminalId);
+  }
+  /** Cancel + reset (call on manual kill / user reconnect / tab close). */
+  clear(terminalId) {
+    this.cancel(terminalId);
+    this.reset(terminalId);
+  }
+  /** Cancel every pending schedule (shutdown). */
+  clearAll() {
+    for (const id of Array.from(this.timers.keys())) this.cancel(id);
+    this.attempts.clear();
+    this.pendingDelay.clear();
+  }
+};
+
+// ../../packages/backend/src/services/terminal/chunkedRingBuffer.ts
+var DEFAULT_MAX2 = 2e5;
+var DEFAULT_CHUNK = 16384;
+var ChunkedRingBuffer = class {
+  chunks = [];
+  maxSize;
+  chunkSize;
+  /** total chars currently retained. */
+  retained = 0;
+  /** total chars ever appended (monotonic; matches the old `offset`). */
+  offset = 0;
+  constructor(opts = {}) {
+    this.maxSize = Math.max(1, opts.maxSize ?? DEFAULT_MAX2);
+    this.chunkSize = Math.max(256, opts.chunkSize ?? DEFAULT_CHUNK);
+  }
+  /** Append data; drops whole old chunks if over maxSize. */
+  append(data) {
+    if (!data) return;
+    this.offset += data.length;
+    let rest = data;
+    while (rest.length > 0) {
+      const last = this.chunks[this.chunks.length - 1];
+      if (last !== void 0 && last.length < this.chunkSize) {
+        const take = Math.min(this.chunkSize - last.length, rest.length);
+        this.chunks[this.chunks.length - 1] = last + rest.slice(0, take);
+        this.retained += take;
+        rest = rest.slice(take);
+      } else {
+        const take = Math.min(this.chunkSize, rest.length);
+        this.chunks.push(rest.slice(0, take));
+        this.retained += take;
+        rest = rest.slice(take);
+      }
+    }
+    this.evict();
+  }
+  /** Drop oldest whole chunks until retained <= maxSize. */
+  evict() {
+    while (this.retained > this.maxSize && this.chunks.length > 0) {
+      const head = this.chunks[0];
+      if (this.retained - head.length >= this.maxSize) {
+        this.chunks.shift();
+        this.retained -= head.length;
+      } else {
+        const trim = this.retained - this.maxSize;
+        this.chunks[0] = head.slice(trim);
+        this.retained -= trim;
+        break;
+      }
+    }
+  }
+  /** The retained content as a single string (for reads/search). */
+  content() {
+    return this.chunks.join("");
+  }
+  /** Retained size in chars. */
+  size() {
+    return this.retained;
+  }
+  /** Number of chunks (for tests/diagnostics). */
+  chunkCount() {
+    return this.chunks.length;
+  }
+  clear() {
+    this.chunks = [];
+    this.retained = 0;
+    this.offset = 0;
+  }
+};
+
 // ../../node_modules/uuid/dist/esm-node/rng.js
 var import_crypto = __toESM(require("crypto"));
 var rnds8Pool = new Uint8Array(256);
@@ -289265,6 +289575,20 @@ function stripInternalControlMarkers(s) {
 function stripTerminalControlSequences(s) {
   return s.replace(ANSI_OSC_SEQUENCE_PATTERN, "").replace(ANSI_CSI_SEQUENCE_PATTERN, "").replace(OTHER_CONTROL_CHAR_PATTERN, "");
 }
+function makeRingBuffer(maxSize) {
+  const buf = new ChunkedRingBuffer({ maxSize });
+  return {
+    get content() {
+      return buf.content();
+    },
+    get offset() {
+      return buf.offset;
+    },
+    set offset(_v) {
+    },
+    append: (data) => buf.append(data)
+  };
+}
 var cloneTerminalConfig = (config2) => JSON.parse(JSON.stringify(config2));
 var normalizeTerminalConfigForRuntime = (config2) => {
   const normalized = cloneTerminalConfig(config2);
@@ -289327,6 +289651,7 @@ var TerminalService = class {
   commandTrackingPromptSyncPollIntervalMs = 50;
   syntheticCommandQuietWindowMs = 1e3;
   terminalIdsBeingKilled = /* @__PURE__ */ new Set();
+  autoReconnect = new AutoReconnect({ maxAttempts: 10 });
   terminalClosedListeners = /* @__PURE__ */ new Set();
   /** Optional session logger (records terminal output to disk per session). */
   sessionLogger = null;
@@ -289683,7 +290008,7 @@ var TerminalService = class {
     this.terminals.set(config2.id, tab);
     this.terminalConfigs.set(config2.id, config2);
     this.releaseReservedTitleForTerminal(config2.id, reservedTitle);
-    this.buffers.set(config2.id, { content: "", offset: 0 });
+    this.buffers.set(config2.id, makeRingBuffer(MAX_BUFFER_SIZE));
     this.headlessPtys.set(config2.id, headless);
     if (config2.type === "local" && !this.primaryLocalTerminalId) {
       this.primaryLocalTerminalId = config2.id;
@@ -289766,6 +290091,8 @@ var TerminalService = class {
         runtime.ptyId
       );
       this.hydrateTerminalRuntimeMetadata(terminalId);
+      this.autoReconnect.clear(terminalId);
+      tab.reconnectState = void 0;
       this.publishTerminalTabsChanged();
       this.schedulePersistTerminalState();
       return tab;
@@ -289778,6 +290105,43 @@ var TerminalService = class {
       throw error40;
     }
   }
+  /** Schedule an auto-reconnect for a dropped SSH tab with backoff. Updates
+   * tab.reconnectState so the UI can show "reconnecting (attempt N)…". */
+  scheduleSshAutoReconnect(terminalId) {
+    const tab = this.terminals.get(terminalId);
+    if (!tab || tab.type !== "ssh") return;
+    const state = this.autoReconnect.schedule(
+      terminalId,
+      () => {
+        const t = this.terminals.get(terminalId);
+        if (!t || t.type !== "ssh") return;
+        void this.reconnectTerminal(terminalId).catch(() => {
+        });
+      },
+      (attempts) => {
+        const t = this.terminals.get(terminalId);
+        if (t) {
+          t.reconnectState = {
+            scheduled: false,
+            attempt: attempts,
+            attempts,
+            nextDelayMs: 0,
+            gaveUp: true
+          };
+          this.publishTerminalTabsChanged();
+        }
+      }
+    );
+    if (state && tab) {
+      tab.reconnectState = {
+        scheduled: true,
+        attempt: state.nextAttempt,
+        attempts: state.attemptsFired,
+        nextDelayMs: state.nextDelayMs
+      };
+      this.publishTerminalTabsChanged();
+    }
+  }
   async restartLocalTerminalAfterExit(terminalId, code) {
     const tab = this.terminals.get(terminalId);
     const existingConfig = this.terminalConfigs.get(terminalId);
@@ -289889,13 +290253,8 @@ var TerminalService = class {
       const buffer = this.buffers.get(terminalId);
       let currentOffset = 0;
       if (buffer) {
-        buffer.content += cleanedData;
-        buffer.offset += cleanedData.length;
+        buffer.append(cleanedData);
         currentOffset = buffer.offset;
-        if (buffer.content.length > MAX_BUFFER_SIZE) {
-          const trimAmount = buffer.content.length - MAX_BUFFER_SIZE;
-          buffer.content = buffer.content.slice(trimAmount);
-        }
       }
       this.sendToRenderer("terminal:data", { terminalId, data: cleanedData, offset: currentOffset });
     }
@@ -289926,13 +290285,8 @@ var TerminalService = class {
     const buffer = this.buffers.get(terminalId);
     let currentOffset = 0;
     if (buffer) {
-      buffer.content += data;
-      buffer.offset += data.length;
+      buffer.append(data);
       currentOffset = buffer.offset;
-      if (buffer.content.length > MAX_BUFFER_SIZE) {
-        const trimAmount = buffer.content.length - MAX_BUFFER_SIZE;
-        buffer.content = buffer.content.slice(trimAmount);
-      }
     }
     this.sendToRenderer("terminal:data", { terminalId, data, offset: currentOffset });
   }
@@ -290144,6 +290498,9 @@ ${promptPrefix}`;
           rows: tab.rows
         });
       }
+      if (tab.type === "ssh" && !this.terminalIdsBeingKilled.has(terminalId)) {
+        this.scheduleSshAutoReconnect(terminalId);
+      }
     }
     this.sendToRenderer("terminal:exit", { terminalId, code });
     this.publishTerminalTabsChanged();
@@ -290223,6 +290580,7 @@ ${promptPrefix}`;
   }
   kill(terminalId) {
     this.pendingResizeByTerminal.delete(terminalId);
+    this.autoReconnect.clear(terminalId);
     const terminal = this.terminals.get(terminalId);
     if (terminal) {
       const backend = this.getBackend(terminal.type);
@@ -342422,6 +342780,109 @@ async function runReadFile(args, context2, readFileSupport) {
   }
 }
 
+// ../../packages/backend/src/memory/memoryManager.ts
+function parseMemoryEntries(content) {
+  const out = [];
+  const lines = String(content || "").replace(/\r\n/g, "\n").split("\n");
+  for (const line of lines) {
+    const t = line.trim();
+    if (!t || t === "# Memory" || t.startsWith("- Add durable cross-session notes")) continue;
+    if (/^#{1,6}\s/.test(t) || /^[-*]\s/.test(t) || t.length > 24) {
+      out.push({ text: t, tokens: tokenize2(t) });
+    }
+  }
+  return out;
+}
+function tokenize2(s) {
+  return (s.toLowerCase().match(/[a-z0-9_.\-/]{3,}/g) ?? []).filter(
+    (w) => !STOP.has(w)
+  );
+}
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "this",
+  "that",
+  "from",
+  "are",
+  "was",
+  "were",
+  "has",
+  "have",
+  "not",
+  "now",
+  "via",
+  "into",
+  "all",
+  "out",
+  "use",
+  "using"
+]);
+function searchMemory(content, query, limit2 = 10) {
+  const q = tokenize2(query);
+  if (q.length === 0) return [];
+  const qSet = new Set(q);
+  const scored = [];
+  for (const e of parseMemoryEntries(content)) {
+    let score = 0;
+    for (const tok of e.tokens) if (qSet.has(tok)) score += 1;
+    if (score > 0) scored.push({ text: e.text, score });
+  }
+  return scored.sort((a, b) => b.score - a.score).slice(0, limit2);
+}
+function normKey(s) {
+  return s.toLowerCase().replace(/^\s*[-*+]\s+/, "").replace(/\s+/g, " ").trim();
+}
+function appendMemoryNote(content, note, opts = {}) {
+  const maxChars = Math.max(1e3, opts.maxChars ?? 4e4);
+  const body = String(content || "").replace(/\r\n/g, "\n").replace(/\s+$/, "");
+  const noteLine = note.trim().replace(/\n+/g, " ").trim();
+  const key = normKey(noteLine);
+  const lines = body.split("\n");
+  const kept = lines.filter((l) => normKey(l) !== key);
+  const next = [...kept, "", noteLine].join("\n").replace(/\n{3,}/g, "\n\n").trim() + "\n";
+  if (next.length <= maxChars) return next;
+  const head = [];
+  const tail4 = [];
+  const all = next.split("\n");
+  let i = 0;
+  for (; i < all.length; i += 1) {
+    if (/^#\s/.test(all[i]) || all[i].trim() === "") head.push(all[i]);
+    else break;
+  }
+  for (let j = all.length - 1; j >= i; j -= 1) {
+    tail4.unshift(all[j]);
+    if (tail4.join("\n").length > maxChars * 0.9) break;
+  }
+  return [...head, ...tail4].join("\n").replace(/\n{3,}/g, "\n\n").trim() + "\n";
+}
+function recallForPrompt(content, opts = {}) {
+  const maxChars = Math.max(2e3, opts.maxChars ?? 12e3);
+  const body = String(content || "");
+  if (body.length <= maxChars) return body;
+  const hits = opts.query ? searchMemory(body, opts.query, 30) : [];
+  const picked = [];
+  let total = 0;
+  const push2 = (t) => {
+    if (total + t.length + 1 > maxChars) return false;
+    picked.push(t);
+    total += t.length + 1;
+    return true;
+  };
+  if (hits.length > 0) {
+    for (const h of hits) if (!push2(h.text)) break;
+  } else {
+    const entries = parseMemoryEntries(body);
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+      if (!push2(entries[i].text)) break;
+    }
+    picked.reverse();
+  }
+  return picked.join("\n");
+}
+
 // ../../packages/backend/src/services/AgentHelper/prompts.ts
 var SYS_INFO_MARKER = "CURRENT_SYSTEM_INFO_MSG:\n";
 var GYSHELL_BASE_SYSTEM_MARKER = "# Role: GyShell Assistant";
@@ -343021,14 +343482,20 @@ function buildMemoryPromptBlock(opts) {
     /\r\n/g,
     "\n"
   );
+  const recalled = recallForPrompt(normalizedContent, {
+    query: opts.userInput,
+    maxChars: 12e3
+  });
+  const truncated = recalled.length < normalizedContent.length;
   return [
     GLOBAL_MEMORY_TAG.trim(),
     `Memory file absolute path: ${opts.memoryFilePath}`,
     "If you need to add or modify memory, use edit_file to edit this exact file path directly. Use write_file only when intentionally replacing the full memory file.",
     "If you need to re-read memory later, use the read_file tool to read this exact file path directly.",
+    truncated ? "(Memory file is large \u2014 only the most relevant entries are shown below; read the full file with read_file if needed.)" : "",
     "",
-    "# Full MEMORY.md Content",
-    normalizedContent
+    truncated ? "# Relevant MEMORY.md entries" : "# Full MEMORY.md Content",
+    recalled
   ].join("\n");
 }
 function createBaseSystemPromptText(memoryPrompt) {
@@ -345650,7 +346117,7 @@ function evalCond(expr, scope) {
 function cleanTag(inner) {
   return inner.replace(/^-|\s-$/g, "").trim();
 }
-function tokenize2(tpl) {
+function tokenize3(tpl) {
   const tokenRe = /(\{%[\s\S]*?%\}|\{\{[\s\S]*?\}\})/g;
   let lastIndex = 0;
   const tokens = [];
@@ -345720,7 +346187,7 @@ function splitIfElse(body) {
   return { ifBody, elseBody, elifs };
 }
 function renderTemplate2(tpl, vars = {}) {
-  const tokens = tokenize2(tpl);
+  const tokens = tokenize3(tpl);
   function renderTokens2(toks, scope) {
     let s = "";
     let idx = 0;
@@ -368073,6 +368540,33 @@ var WebSocketGatewayAdapter = class {
         }
         return await this.options.memoryBridge.setContent(content);
       }
+      case "memory:search": {
+        if (!this.options.memoryBridge?.search) {
+          throw new WebSocketRpcError(
+            "METHOD_NOT_FOUND",
+            "memory:search is not available on this websocket gateway."
+          );
+        }
+        const query = params.query;
+        if (typeof query !== "string") {
+          throw new WebSocketRpcError("BAD_REQUEST", "query must be string.");
+        }
+        const limit2 = typeof params.limit === "number" ? params.limit : void 0;
+        return { results: await this.options.memoryBridge.search(query, limit2) };
+      }
+      case "memory:append": {
+        if (!this.options.memoryBridge?.append) {
+          throw new WebSocketRpcError(
+            "METHOD_NOT_FOUND",
+            "memory:append is not available on this websocket gateway."
+          );
+        }
+        const note = params.note;
+        if (typeof note !== "string" || note.trim() === "") {
+          throw new WebSocketRpcError("BAD_REQUEST", "note must be a non-empty string.");
+        }
+        return await this.options.memoryBridge.append(note);
+      }
       case "agentSettings:get": {
         if (!this.options.agentSettingsBridge?.get) {
           throw new WebSocketRpcError(
@@ -389081,6 +389575,20 @@ async function startGyBackend() {
           );
           gatewayService.broadcastRaw("memory:updated", snapshot);
           return snapshot;
+        },
+        search: async (query, limit2) => {
+          const { content } = await memoryService.getMemorySnapshot(
+            settingsService.getSettings().agentSettings?.activeProfileId || null
+          );
+          return searchMemory(content, query, limit2 ?? 10);
+        },
+        append: async (note) => {
+          const profileId = settingsService.getSettings().agentSettings?.activeProfileId || null;
+          const { content } = await memoryService.getMemorySnapshot(profileId);
+          const next = appendMemoryNote(content, note);
+          const snapshot = await memoryService.writeMemory(next, profileId);
+          gatewayService.broadcastRaw("memory:updated", snapshot);
+          return snapshot;
         }
       },
       agentSettingsBridge: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rterm-backend",
-  "version": "3.0.4",
-  "description": "rterm-backend — the headless AI-native backend for RTerm (dual-published as neuralOS). run RTerm-as-a-service (AI agent, SSH/WinRM/Serial/local terminals, fleet orchestration, advanced automation, SRE observability, Netdata, AWS APerf, plugin system, governance/audit, Prometheus/OTel metrics export, secrets vault, on-call paging, AI cost budgets, GitOps, cloud inventory, APM/DEM/Infra/ETW ingestion, AgentSpan durable-agent bridge). The RTerm desktop app stays RTerm; neuralOS is the standalone backend daemon. Dual-published as rterm-backend. v3.0.4: monitor-status diagnostic over RPC + agent tool.",
+  "version": "3.0.5",
+  "description": "rterm-backend — the headless AI-native backend for RTerm (dual-published as neuralOS). run RTerm-as-a-service (AI agent, SSH/WinRM/Serial/local terminals, fleet orchestration, advanced automation, SRE observability, Netdata, AWS APerf, plugin system, governance/audit, Prometheus/OTel metrics export, secrets vault, on-call paging, AI cost budgets, GitOps, cloud inventory, APM/DEM/Infra/ETW ingestion, AgentSpan durable-agent bridge). The RTerm desktop app stays RTerm; neuralOS is the standalone backend daemon. Dual-published as rterm-backend. v3.0.5: terminal core (SSH auto-reconnect, WinRM persistent+streaming, serial break), chat user-message nav, reconnecting indicator, memory search/cap.",
   "main": "bin/gybackend.cjs",
   "bin": {
     "gybackend": "bin/gybackend.cjs",