@aion0/forge 0.9.18 → 0.9.19

package/RELEASE_NOTES.md

@@ -1,22 +1,18 @@
-# Forge v0.9.18
+# Forge v0.9.19
 
-Released: 2026-05-28
+Released: 2026-05-29
 
-## Changes since v0.9.16
+## Changes since v0.9.18
 
 ### Other
-- feat(chat): trigger_pipeline accepts skills array
-- feat(connectors): body_form_inject_from + nested instances UI
-- fix(http-protocol): JSON.parse args[X] when LLM stringified it + template inject keys
-- feat(connectors): http body_form_inject for server-side credential injection
-- Revert "feat(connectors): {secret:...} refs for cross-connector + global secrets"
-- Revert "fix(chat): make secret-refs system prompt push the tool-call path"
-- fix(chat): make secret-refs system prompt push the tool-call path
-- revert: drop migrateConnectorInstanceSecrets startup hook
-- fix(connectors): encrypt nested secrets inside type:instances rows
-- feat(connectors): {secret:...} refs for cross-connector + global secrets
-- feat(connectors): generic 'type: instances' field renderer + v0.9.17
-- feat(connectors): generic auth + url_encoding + body_form + multi-instance
+- feat(memory): writeEpisode dual-write + Memory drawer in /chat web
+- feat(monitor): D3 — Memory Worker row in Settings Monitor
+- feat(chat): Phase C — agent-loop reads summarized memory + token-budget history
+- feat(memory): B11 — spawn memory-standalone from forge-server + dev supervisor
+- fix(memory): bypass ai-sdk for summarizer LLM call — raw fetch instead
+- feat(memory): Phase B — memory-standalone process + Temper Summary sub-task
+- feat(memory): Phase A — key conventions + buildMemoryContext + OR-match search
+- fix(chat): cap LLM history at last 40 messages and drop orphan tool_results
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.9.16...v0.9.18
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.9.18...v0.9.19

package/app/api/memory/blocks/route.ts

@@ -0,0 +1,56 @@
+/**
+ * GET /api/memory/blocks?q=&limit=&scope=
+ *
+ * Lists memory blocks from the active backend (Temper or Local).
+ * Powers the Memory drawer in /chat — no editing, just inspection.
+ *
+ * Query params:
+ *   q       — optional search query; routed to store.search() so the
+ *             active backend's relevance ranking applies (Temper KG,
+ *             LocalMemoryStore LIKE). Omit to list everything.
+ *   limit   — cap on rows returned (default 200, max 500)
+ *   scope   — 'own' | 'global' | 'both' (default 'both'), forwarded
+ *             to listBlocks. Ignored when q is set.
+ */
+
+import { NextResponse } from 'next/server';
+import { getMemoryStore } from '@/lib/chat/memory-store';
+
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const q = (url.searchParams.get('q') || '').trim();
+  const limit = Math.min(500, Math.max(1, Number(url.searchParams.get('limit') || 200)));
+  const scopeParam = url.searchParams.get('scope');
+  const scope: 'own' | 'global' | 'both' =
+    scopeParam === 'own' || scopeParam === 'global' || scopeParam === 'both' ? scopeParam : 'both';
+
+  const store = getMemoryStore();
+  if (!store.enabled) {
+    return NextResponse.json({ backend: store.kind, enabled: false, blocks: [], hits: [] });
+  }
+
+  if (q) {
+    // Search path — backend chooses ranking (Temper KG vs Local LIKE).
+    // listBlocks is also fetched so the UI can show "all blocks" once
+    // the user clears the query without a second roundtrip; capped.
+    const [hits, all] = await Promise.allSettled([
+      store.search(q, limit),
+      store.listBlocks({ scope }),
+    ]);
+    return NextResponse.json({
+      backend: store.kind,
+      enabled: true,
+      query: q,
+      hits: hits.status === 'fulfilled' ? hits.value : [],
+      blocks: all.status === 'fulfilled' ? all.value.slice(0, limit) : [],
+    });
+  }
+
+  const blocks = await store.listBlocks({ scope });
+  return NextResponse.json({
+    backend: store.kind,
+    enabled: true,
+    blocks: blocks.slice(0, limit),
+    hits: [],
+  });
+}

package/app/api/monitor/route.ts

@@ -24,6 +24,7 @@ export async function GET() {
   const workspace = countProcess('workspace-standalone');
   const chat = countProcess('chat-standalone');
   const browserBridge = countProcess('browser-bridge-standalone');
+  const memoryWorker = countProcess('memory-standalone');
   const tunnel = countProcess('cloudflared tunnel');
 
   // Chat backend health (port 8408 — process can be alive but crashed)
@@ -83,6 +84,7 @@ export async function GET() {
       telegram: { running: telegram.count > 0, pid: telegram.pid, startedAt: telegram.startedAt },
       workspace: { running: workspace.count > 0, pid: workspace.pid, startedAt: workspace.startedAt },
       browserBridge: { running: browserBridge.count > 0, pid: browserBridge.pid, startedAt: browserBridge.startedAt },
+      memory: { running: memoryWorker.count > 0, pid: memoryWorker.pid, startedAt: memoryWorker.startedAt },
       chat: {
         running: chatStatus.running,
         pid: chat.pid,

package/app/chat/page.tsx

@@ -50,6 +50,7 @@ export default function ChatPage() {
   const [streaming, setStreaming] = useState(false);
   const [partial, setPartial] = useState('');
   const [memory, setMemory] = useState<MemoryStatus | null>(null);
+  const [memoryOpen, setMemoryOpen] = useState(false);
   const [error, setError] = useState('');
 
   const eventSrcRef = useRef<EventSource | null>(null);
@@ -282,7 +283,11 @@ export default function ChatPage() {
         </div>
 
         <div className="px-4 py-3 border-t border-[var(--border)] text-xs text-[var(--text-secondary)] space-y-1">
-          <div className="flex items-center gap-2">
+          <button
+            type="button"
+            onClick={() => setMemoryOpen(true)}
+            className="flex items-center gap-2 w-full text-left hover:text-[var(--text-primary)] transition-colors"
+          >
             <span>Memory</span>
             <span
               className={`px-1.5 py-[1px] rounded text-[10px] uppercase tracking-wide border ${
@@ -295,7 +300,8 @@ export default function ChatPage() {
             >
               {memory?.backend ?? '…'}
             </span>
-          </div>
+            <span className="ml-auto text-[10px] opacity-60">view →</span>
+          </button>
           {memory && (
             <div className="text-[11px]">
               {memory.pinnedCount ?? 0} pinned · {memory.blocksCount ?? 0} blocks
@@ -307,6 +313,8 @@ export default function ChatPage() {
         </div>
       </aside>
 
+      {memoryOpen && <MemoryDrawer onClose={() => setMemoryOpen(false)} />}
+
       {/* ─── Main pane ───────────────────────────────────── */}
       <main className="flex-1 flex flex-col min-w-0">
         <header className="border-b border-[var(--border)] px-6 py-3 flex items-center justify-between">
@@ -529,3 +537,182 @@ function tryPrettyJson(s: string): string {
     return s;
   }
 }
+
+// ─── Memory drawer ───────────────────────────────────────────
+//
+// Inspector for whatever the active memory backend (Temper / Local)
+// has. Read-only: search + list + click-to-expand JSON. The internal
+// summarizer bookkeeping (cursor / health) is hidden by default to
+// reduce noise; toggle reveals it.
+
+const INTERNAL_PREFIXES = ['forge.summarizer.cursor:', 'forge.summarizer.health:'];
+
+interface MemoryBlockRow {
+  key: string;
+  value: unknown;
+  pinned?: boolean;
+  description?: string;
+  scope?: string;
+}
+
+interface MemoryHitRow {
+  id: string;
+  kind: string;
+  fact?: string;
+  score?: number;
+  valid_at?: string | null;
+}
+
+interface MemoryBlocksResponse {
+  backend: 'temper' | 'local';
+  enabled: boolean;
+  blocks: MemoryBlockRow[];
+  hits: MemoryHitRow[];
+  query?: string;
+}
+
+function MemoryDrawer({ onClose }: { onClose: () => void }) {
+  const [data, setData] = useState<MemoryBlocksResponse | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [err, setErr] = useState('');
+  const [q, setQ] = useState('');
+  const [showInternal, setShowInternal] = useState(false);
+  const [expanded, setExpanded] = useState<Record<string, boolean>>({});
+
+  const fetchBlocks = useCallback(async (query: string) => {
+    setLoading(true);
+    setErr('');
+    try {
+      const url = query
+        ? `/api/memory/blocks?q=${encodeURIComponent(query)}&limit=300`
+        : `/api/memory/blocks?limit=300`;
+      const r = await fetch(url);
+      if (!r.ok) throw new Error(`${r.status}`);
+      const j = (await r.json()) as MemoryBlocksResponse;
+      setData(j);
+    } catch (e) {
+      setErr(e instanceof Error ? e.message : String(e));
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => { fetchBlocks(''); }, [fetchBlocks]);
+
+  // Debounce search input → API
+  useEffect(() => {
+    const t = setTimeout(() => fetchBlocks(q.trim()), 250);
+    return () => clearTimeout(t);
+  }, [q, fetchBlocks]);
+
+  const visibleBlocks = useMemo(() => {
+    const all = data?.blocks ?? [];
+    if (showInternal) return all;
+    return all.filter((b) => !INTERNAL_PREFIXES.some((p) => b.key.startsWith(p)));
+  }, [data, showInternal]);
+
+  const visibleHits = data?.hits ?? [];
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/50" onClick={onClose}>
+      <div
+        className="bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg w-[720px] max-w-[95vw] max-h-[85vh] flex flex-col shadow-xl"
+        onClick={(e) => e.stopPropagation()}
+        style={{ fontFamily: SANS_FONT }}
+      >
+        <div className="px-4 py-3 border-b border-[var(--border)] flex items-center gap-3">
+          <h2 className="text-sm font-bold text-[var(--text-primary)]">Memory</h2>
+          {data && (
+            <span
+              className={`px-1.5 py-[1px] rounded text-[10px] uppercase tracking-wide border ${
+                data.backend === 'temper'
+                  ? 'border-green-500/60 text-green-400'
+                  : 'border-[var(--accent)] text-[var(--accent)]'
+              }`}
+            >
+              {data.backend}
+            </span>
+          )}
+          <input
+            value={q}
+            onChange={(e) => setQ(e.target.value)}
+            placeholder="search…"
+            className="flex-1 bg-[var(--bg-primary)] border border-[var(--border)] rounded px-2 py-1 text-xs text-[var(--text-primary)] focus:outline-none focus:border-[var(--accent)]"
+          />
+          <label className="flex items-center gap-1 text-[10px] text-[var(--text-secondary)]">
+            <input
+              type="checkbox"
+              checked={showInternal}
+              onChange={(e) => setShowInternal(e.target.checked)}
+              className="accent-[var(--accent)]"
+            />
+            show internal
+          </label>
+          <button onClick={onClose} className="text-xs text-[var(--text-secondary)] hover:text-[var(--text-primary)]">Close</button>
+        </div>
+
+        <div className="flex-1 overflow-y-auto">
+          {loading && <div className="px-4 py-6 text-xs text-[var(--text-secondary)]">Loading…</div>}
+          {err && <div className="px-4 py-6 text-xs text-red-400">Error: {err}</div>}
+
+          {visibleHits.length > 0 && (
+            <div className="px-4 py-2 border-b border-[var(--border)]">
+              <div className="text-[10px] uppercase tracking-wide text-[var(--text-secondary)] mb-1">
+                Search hits ({visibleHits.length})
+              </div>
+              <div className="space-y-1">
+                {visibleHits.slice(0, 20).map((h) => (
+                  <div key={h.id} className="text-[11px] text-[var(--text-primary)]">
+                    <span className="text-[var(--text-secondary)] font-mono mr-2">{h.id}</span>
+                    {h.fact || '(no fact)'}
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          <div className="px-2 py-1 text-[10px] uppercase tracking-wide text-[var(--text-secondary)] sticky top-0 bg-[var(--bg-secondary)]">
+            Blocks ({visibleBlocks.length}{data && data.blocks.length !== visibleBlocks.length ? ` of ${data.blocks.length}` : ''})
+          </div>
+          {visibleBlocks.length === 0 && !loading && (
+            <div className="px-4 py-6 text-xs text-[var(--text-secondary)] italic">No blocks{q ? ' match' : ''}.</div>
+          )}
+          {visibleBlocks.map((b) => {
+            const isOpen = !!expanded[b.key];
+            const valStr = typeof b.value === 'string' ? b.value : JSON.stringify(b.value);
+            const preview = valStr.length > 140 ? valStr.slice(0, 140) + '…' : valStr;
+            return (
+              <div key={b.key} className="border-b border-[var(--border)]">
+                <button
+                  type="button"
+                  onClick={() => setExpanded((s) => ({ ...s, [b.key]: !isOpen }))}
+                  className="w-full text-left px-3 py-2 hover:bg-[var(--bg-primary)] transition-colors"
+                >
+                  <div className="flex items-baseline gap-2">
+                    <span className="text-[11px] font-mono text-[var(--accent)] truncate flex-1">{b.key}</span>
+                    {b.pinned && <span className="text-[9px] text-yellow-400">📌</span>}
+                  </div>
+                  <div className="text-[11px] text-[var(--text-secondary)] mt-0.5 truncate">
+                    {preview}
+                  </div>
+                  {b.description && (
+                    <div className="text-[10px] text-gray-500 italic mt-0.5 truncate">{b.description}</div>
+                  )}
+                </button>
+                {isOpen && (
+                  <pre className="px-3 pb-3 text-[10px] font-mono whitespace-pre-wrap break-words text-[var(--text-secondary)]">
+                    {tryPrettyJson(valStr)}
+                  </pre>
+                )}
+              </div>
+            );
+          })}
+        </div>
+
+        <div className="px-4 py-2 border-t border-[var(--border)] text-[10px] text-[var(--text-secondary)]">
+          Read-only. Edit / delete via Settings → Memory (Temper UI for KG).
+        </div>
+      </div>
+    </div>
+  );
+}

package/bin/forge-server.mjs

@@ -349,7 +349,7 @@ function cleanupOrphans() {
     }
     // Kill standalone processes: our instance's + orphans without any tag
     try {
-      const out = execSync(`ps aux | grep -E 'telegram-standalone|terminal-standalone|workspace-standalone|browser-bridge-standalone|chat-standalone' | grep -v grep`, {
+      const out = execSync(`ps aux | grep -E 'telegram-standalone|terminal-standalone|workspace-standalone|browser-bridge-standalone|chat-standalone|memory-standalone' | grep -v grep`, {
         encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
       }).trim();
       for (const line of out.split('\n').filter(Boolean)) {
@@ -376,7 +376,7 @@ function cleanupOrphans() {
           cmd = execSync(`ps -p ${pid} -o command=`, { encoding: 'utf-8', timeout: 2000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
         } catch { continue; }
         // Skip legit holders: next-server + our standalones (handled above)
-        if (/next-server|next start|telegram-standalone|terminal-standalone|workspace-standalone|browser-bridge-standalone|chat-standalone/.test(cmd)) continue;
+        if (/next-server|next start|telegram-standalone|terminal-standalone|workspace-standalone|browser-bridge-standalone|chat-standalone|memory-standalone/.test(cmd)) continue;
         // Only kill tsx-loaded scripts (typical zombie debug runner shape)
         if (!/tsx/.test(cmd)) continue;
         console.log(`[forge] Killing zombie task-runner (pid=${pid}): ${cmd.slice(0, 120)}`);
@@ -425,6 +425,7 @@ function startServices(daemonize = false) {
   spawnService('Workspace daemon', join(ROOT, 'lib', 'workspace-standalone.ts'));
   spawnService('Browser bridge',  join(ROOT, 'lib', 'browser-bridge-standalone.ts'));
   spawnService('Chat',            join(ROOT, 'lib', 'chat-standalone.ts'));
+  spawnService('Memory worker',   join(ROOT, 'lib', 'memory-standalone.ts'));
 
   const childPids = services.map(c => c.pid).filter(Boolean);
   savePids(childPids);

package/components/MonitorPanel.tsx

@@ -9,6 +9,7 @@ interface MonitorData {
     telegram: { running: boolean; pid: string; startedAt?: string };
     workspace: { running: boolean; pid: string; startedAt?: string };
     browserBridge?: { running: boolean; pid: string; startedAt?: string };
+    memory?: { running: boolean; pid: string; startedAt?: string };
     chat?: {
       running: boolean;
       pid: string;
@@ -60,6 +61,7 @@ export default function MonitorPanel({ onClose }: { onClose: () => void }) {
                   { label: 'Telegram Bot', ...data.processes.telegram },
                   { label: 'Workspace Daemon', ...data.processes.workspace },
                   ...(data.processes.browserBridge ? [{ label: 'Browser Bridge', ...data.processes.browserBridge }] : []),
+                  ...(data.processes.memory ? [{ label: 'Memory Worker', ...data.processes.memory }] : []),
                   { label: 'Tunnel', ...data.processes.tunnel },
                 ].map(p => (
                   <div key={p.label} className="flex items-center gap-2 text-xs">

package/lib/chat/agent-loop.ts

@@ -16,16 +16,17 @@ import { loadSettings } from '../settings';
 import {
   appendMessage,
   getSession,
-  listMessages,
+  listMessagesCapped,
 } from './session-store';
 import {
   dispatchTool,
   BUILTIN_TOOL_DEFS,
   type BuiltinHandler,
 } from './tool-dispatcher';
-import { renderMemoryContext } from './temper';
 import { getMemoryStore } from './memory-store';
+import { buildMemoryContext } from './build-memory-context';
 import { buildMemoryTools } from './memory-tools';
+import { estimateTokens } from '../memory/token-estimate';
 import {
   listInstalledConnectors,
   getConnector,
@@ -41,6 +42,28 @@ import type {
 
 const MAX_ITERATIONS = 6;
 const MAX_TOKENS = 16000;
+// Working-window budgets for the LLM history. Capped by message count
+// AND by token estimate (whichever hits first), see design §8. Older
+// raw is summarized by the memory-standalone Temper Summary sub-task
+// and recalled via buildMemoryContext as compact blocks instead.
+const HISTORY_MSG_BUDGET = 60;
+const HISTORY_TOKEN_BUDGET = 8000;
+
+// After clipping to last N, the first kept message may be a tool_result
+// whose tool_use was cut. Anthropic/OpenAI both reject that, so drop
+// leading tool_result-bearing user messages until the slice starts clean.
+function trimOrphanToolResults(history: Message[]): Message[] {
+  let i = 0;
+  while (i < history.length) {
+    const m = history[i];
+    const hasToolResult = m.role === 'user'
+      && Array.isArray(m.blocks)
+      && m.blocks.some((b) => (b as any).type === 'tool_result');
+    if (!hasToolResult) break;
+    i += 1;
+  }
+  return i === 0 ? history : history.slice(i);
+}
 
 export interface AgentEvent {
   type:
@@ -59,7 +82,7 @@ export type AgentCallbacks = {
   onEvent: (event: AgentEvent) => void;
 };
 
-interface ProviderResolution {
+export interface ProviderResolution {
   name: string;
   type: 'anthropic' | 'openai';
   apiKey: string;
@@ -126,7 +149,7 @@ export function pickApiKey(profile: { apiKey?: string; env?: Record<string, stri
   return env.OPENAI_API_KEY || '';
 }
 
-function resolveProvider(sessionProvider: string | null, sessionModel: string | null): ProviderResolution | { error: string } {
+export function resolveProvider(sessionProvider: string | null, sessionModel: string | null): ProviderResolution | { error: string } {
   const settings = loadSettings();
   const agents = settings.agents || {};
 
@@ -372,18 +395,24 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
   for (const t of memTools) memHandlers[t.def.name] = t.handle;
 
   if (memStore.enabled) {
-    const [bp, ba, sp] = await Promise.allSettled([
+    // Inspector strip (memory_status event) wants the full inventory —
+    // keep its own listBlocks call. The prompt-injection text comes
+    // from buildMemoryContext which excludes internal bookkeeping
+    // (cursor / health) and combines pinned + query-driven retrieval
+    // hits in one pass.
+    const [bp, ba, sp, ctx] = await Promise.allSettled([
       memStore.listBlocks({ pinned: true, scope: 'both' }),
       memStore.listBlocks({ scope: 'both' }),
       memStore.search(args.userText, 8),
+      buildMemoryContext({ store: memStore, currentUserMessage: args.userText }),
     ]);
     const pinnedBlocks = bp.status === 'fulfilled' ? bp.value : [];
     const allBlocks = ba.status === 'fulfilled' ? ba.value : [];
     const searchHits = sp.status === 'fulfilled' ? sp.value : [];
-    const firstErr = [bp, ba, sp].find((r) => r.status === 'rejected') as PromiseRejectedResult | undefined;
+    const firstErr = [bp, ba, sp, ctx].find((r) => r.status === 'rejected') as PromiseRejectedResult | undefined;
     const memError = firstErr ? (firstErr.reason instanceof Error ? firstErr.reason.message : String(firstErr.reason)) : undefined;
 
-    memContext = renderMemoryContext(allBlocks, searchHits);
+    memContext = ctx.status === 'fulfilled' ? ctx.value.text : '';
 
     cb({
       type: 'memory_status',
@@ -470,7 +499,9 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
     while (iter < MAX_ITERATIONS) {
       iter += 1;
 
-      const history = listMessages(args.sessionId);
+      const history = trimOrphanToolResults(
+        listMessagesCapped(args.sessionId, HISTORY_MSG_BUDGET, HISTORY_TOKEN_BUDGET, estimateTokens),
+      );
 
       assistantBlocksAccum = [];
       let currentTextBuf = '';

package/lib/chat/build-memory-context.ts

@@ -0,0 +1,91 @@
+/**
+ * buildMemoryContext — assemble the memory chunk for the agent-loop
+ * system prompt.
+ *
+ * Wraps store.listBlocks (for pinned + recall) and store.search (for
+ * query-driven retrieval) and post-filters out internal bookkeeping
+ * blocks like the summarizer cursor/health by key prefix. The actual
+ * string rendering reuses renderMemoryContext(blocks, hits) — this
+ * helper is just the assembly + filtering layer so callers don't have
+ * to think about it.
+ *
+ * Why post-filter instead of extending MemoryStore.search/listBlocks
+ * with scope filters: the existing API is flat key/value across both
+ * backends (LocalMemoryStore + Temper) and we want zero changes there.
+ * Forge owns the key naming convention (see lib/memory/keys.ts), so we
+ * own the prefix-exclusion decision client-side.
+ */
+
+import type { MemoryBlock, MemoryStore, SearchHit } from './memory-store';
+import { renderMemoryContext } from './temper';
+import { INTERNAL_KEY_PREFIXES } from '../memory/keys';
+
+export interface BuildMemoryContextOpts {
+  store: MemoryStore;
+  /** Used as `store.search(query)` — typically the latest user message. */
+  currentUserMessage?: string;
+  /** Cap on hits returned from store.search. Default 6. */
+  topK?: number;
+  /** Cap on inlined pinned blocks. Default 50 (renderMemoryContext default). */
+  maxBlocks?: number;
+  /** Prefixes that mark internal-only blocks (cursor / health / etc).
+   *  Defaults to lib/memory/keys.INTERNAL_KEY_PREFIXES. */
+  excludeKeyPrefixes?: readonly string[];
+}
+
+export interface BuildMemoryContextResult {
+  text: string;
+  blocks: MemoryBlock[];
+  hits: SearchHit[];
+}
+
+export async function buildMemoryContext(opts: BuildMemoryContextOpts): Promise<BuildMemoryContextResult> {
+  const {
+    store,
+    currentUserMessage,
+    topK = 6,
+    maxBlocks = 50,
+    excludeKeyPrefixes = INTERNAL_KEY_PREFIXES,
+  } = opts;
+
+  const blocks = filterInternal(
+    await safe(() => store.listBlocks({ pinned: true }), [] as MemoryBlock[]),
+    excludeKeyPrefixes,
+  ).slice(0, maxBlocks);
+
+  const q = (currentUserMessage || '').trim();
+  let hits: SearchHit[] = [];
+  if (q) {
+    const rawHits = await safe(() => store.search(q, topK), [] as SearchHit[]);
+    hits = filterInternalHits(rawHits, excludeKeyPrefixes);
+  }
+
+  return { text: renderMemoryContext(blocks, hits), blocks, hits };
+}
+
+function filterInternal(blocks: MemoryBlock[], prefixes: readonly string[]): MemoryBlock[] {
+  if (prefixes.length === 0) return blocks;
+  return blocks.filter((b) => !prefixes.some((p) => b.key.startsWith(p)));
+}
+
+function filterInternalHits(hits: SearchHit[], prefixes: readonly string[]): SearchHit[] {
+  if (prefixes.length === 0) return hits;
+  // SearchHit.id encodes its source: LocalMemoryStore returns 'block:<key>'
+  // for block-derived hits. Temper returns Graphiti UUIDs — those won't
+  // match prefixes, so they pass through (correct: Temper hits aren't
+  // direct block references).
+  return hits.filter((h) => {
+    if (!h.id?.startsWith('block:')) return true;
+    const key = h.id.slice('block:'.length);
+    return !prefixes.some((p) => key.startsWith(p));
+  });
+}
+
+async function safe<T>(fn: () => Promise<T>, fallback: T): Promise<T> {
+  try {
+    return await fn();
+  } catch (err) {
+    console.warn('[buildMemoryContext]', err instanceof Error ? err.message : err);
+    return fallback;
+  }
+}

package/lib/chat/llm/openai.ts

@@ -77,11 +77,14 @@ export const openaiAdapter: LlmAdapter = {
       };
     }
 
+    // Some providers (litellm/vLLM) reject `tools: []` — they want the
+    // field omitted entirely when there are no tools.
+    const hasTools = Object.keys(tools).length > 0;
     const result = streamText({
       model: client(req.model),
       system: req.system,
       messages: historyToModelMessages(req.history),
-      tools,
+      ...(hasTools ? { tools } : {}),
       maxOutputTokens: req.maxTokens,
     });
 

package/lib/chat/local-memory.ts

@@ -133,26 +133,43 @@ export class LocalMemoryStore implements MemoryStore {
     const q = (query || '').trim();
     if (!q) return [];
     const cap = Math.min(50, Math.max(1, limit));
-    const like = `%${q.replace(/[%_]/g, (m) => '\\' + m)}%`;
+    // Tokenize on whitespace and OR-match. Natural-language queries
+    // like "tell me about the X" can't be AND-matched (stop words
+    // wouldn't appear in stored content), so OR keeps recall useful.
+    // Drop tokens shorter than 3 chars to avoid runaway noise. If
+    // every token is too short, fall back to a single-substring match
+    // on the raw query.
+    const allTokens = q.split(/\s+/).filter((t) => t.length > 0);
+    const tokens = allTokens.filter((t) => t.length >= 3);
+    const useTokens = tokens.length > 0 ? tokens : [q];
+    const likes = useTokens.map((t) => `%${t.replace(/[%_]/g, (m) => '\\' + m)}%`);
     const conn = db();
 
+    const blockWhere = useTokens
+      .map(() => `(value LIKE ? ESCAPE '\\' OR key LIKE ? ESCAPE '\\' OR description LIKE ? ESCAPE '\\')`)
+      .join(' OR ');
+    const blockParams: unknown[] = [this.ns];
+    for (const like of likes) { blockParams.push(like, like, like); }
+    blockParams.push(cap);
     const blockHits = conn.prepare(
       `SELECT key, value, description, updated_at
          FROM memory_blocks
         WHERE ns = ?
-          AND (value LIKE ? ESCAPE '\\' OR key LIKE ? ESCAPE '\\' OR description LIKE ? ESCAPE '\\')
+          AND (${blockWhere})
         ORDER BY pinned DESC, updated_at DESC
         LIMIT ?`,
-    ).all(this.ns, like, like, like, cap) as Array<Pick<BlockRow, 'key' | 'value' | 'description' | 'updated_at'>>;
+    ).all(...blockParams) as Array<Pick<BlockRow, 'key' | 'value' | 'description' | 'updated_at'>>;
 
+    const episodeWhere = useTokens.map(() => `content LIKE ? ESCAPE '\\'`).join(' OR ');
+    const episodeParams: unknown[] = [this.ns, ...likes, cap];
     const episodeHits = conn.prepare(
       `SELECT id, content, reference_time, created_at
          FROM memory_episodes
         WHERE ns = ?
-          AND content LIKE ? ESCAPE '\\'
+          AND (${episodeWhere})
         ORDER BY created_at DESC
         LIMIT ?`,
-    ).all(this.ns, like, cap) as Array<Pick<EpisodeRow, 'id' | 'content' | 'reference_time' | 'created_at'>>;
+    ).all(...episodeParams) as Array<Pick<EpisodeRow, 'id' | 'content' | 'reference_time' | 'created_at'>>;
 
     const hits: SearchHit[] = [];
     for (const b of blockHits) {