pi-orchestrator-config 4.2.0 → 4.3.2

package/extensions/orchestrator/markdown-transformer.ts

@@ -0,0 +1,313 @@
+/**
+ * Markdown transformer for rich TUI display formatting.
+ *
+ * Transforms assistant message markdown for display only —
+ * doesn't affect stored messages or model context.
+ *
+ * Uses pi 0.84.0's registerMarkdownTransformer() API.
+ */
+
+import type {
+  ExtensionAPI,
+  MarkdownTransformContext,
+} from "@earendil-works/pi-coding-agent";
+
+// ── Badge definitions ──
+
+/** Memory category → styled badge (inline code for visual distinction in TUI) */
+export const MEMORY_BADGES: Record<string, string> = {
+  preference: "`🎯 pref`",
+  lesson: "`📝 lesson`",
+  mistake: "`⚠️ mistake`",
+  pattern: "`🔄 pattern`",
+  decision: "`📌 decision`",
+  done: "`✅ done`",
+};
+
+/** Memory section header → emoji prefix */
+const SECTION_ICONS: Record<string, string> = {
+  "Active Preferences": "🎯",
+  "Active Lessons": "📝",
+  "Vetoes & Mistakes": "⚠️",
+  Patterns: "🔄",
+  "Recent Decisions": "📌",
+  "Recent Completions": "✅",
+  Pinned: "📌",
+  "Project Memory": "🧠",
+};
+
+/** Severity → styled badge for review findings */
+export const SEVERITY_BADGES: Record<string, string> = {
+  CRITICAL: "🔴 **CRITICAL**",
+  WARNING: "🟡 **WARNING**",
+  SUGGESTION: "🟢 SUGGESTION",
+  INFO: "🔵 INFO",
+};
+
+/** Task status → styled badge */
+export const TASK_STATUS_BADGES: Record<string, string> = {
+  pending: "⏳",
+  in_progress: "🔄",
+  completed: "✅",
+  deleted: "🗑️",
+};
+
+/** Async agent status → styled badge */
+export const ASYNC_STATUS_BADGES: Record<string, string> = {
+  running: "🟡 **running**",
+  queued: "🟡 queued",
+  complete: "🟢 **done**",
+  failed: "🔴 **failed**",
+  killed: "⚪ killed",
+};
+
+// ── Code block protection ──
+
+/**
+ * Apply a transform function only to text outside fenced code blocks.
+ * Code blocks (``` or ~~~) are preserved as-is.
+ */
+export function transformOutsideCodeBlocks(
+  markdown: string,
+  transform: (text: string) => string,
+): string {
+  const parts = markdown.split(/(```[\s\S]*?```|~~~[\s\S]*?~~~)/g);
+  return parts
+    .map((part, i) => (i % 2 === 1 ? part : transform(part)))
+    .join("");
+}
+
+/** Escape markdown metacharacters in a string to prevent formatting corruption. */
+function escapeMarkdown(text: string): string {
+  return text.replace(/([*_~`\\[\]()#>+\-!|{}])/g, "\\$1");
+}
+
+/**
+ * Wrap text in a CommonMark inline code span, safely handling backticks.
+ * Uses a delimiter longer than the longest backtick run in the content.
+ */
+function inlineCode(text: string): string {
+  const maxRun = (text.match(/`+/g) || []).reduce(
+    (max, run) => Math.max(max, run.length),
+    0,
+  );
+  const delim = "`".repeat(maxRun + 1);
+  // CommonMark requires a space after/before delimiter when content starts/ends with backtick
+  const needsSpace = text.startsWith("`") || text.endsWith("`");
+  return needsSpace ? `${delim} ${text} ${delim}` : `${delim}${text}${delim}`;
+}
+
+// ── Transform functions (exported for testing) ──
+
+/**
+ * Transform memory category tags into styled badges.
+ * Matches `- [category] text` in memory list items.
+ */
+export function transformMemoryBadges(markdown: string): string {
+  return transformOutsideCodeBlocks(markdown, (text) =>
+    text.replace(
+      /^(- )\[(preference|lesson|mistake|pattern|decision|done)\] /gm,
+      (_match, prefix, category) => {
+        const badge = MEMORY_BADGES[category];
+        return badge ? `${prefix}${badge} ` : _match;
+      },
+    ),
+  );
+}
+
+/**
+ * Transform memory section headers with emoji icons.
+ * `## Active Preferences` → `## 🎯 Active Preferences`
+ *
+ * Only matches exact section header lines (end-of-line or followed by ` [`
+ * for the Project Memory capacity header).
+ */
+export function transformMemorySectionHeaders(markdown: string): string {
+  const sectionPattern = Object.keys(SECTION_ICONS)
+    .map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+    .join("|");
+  const re = new RegExp(
+    `^(#{1,3}) (${sectionPattern})(?= \\[|$)`,
+    "gm",
+  );
+  return transformOutsideCodeBlocks(markdown, (text) =>
+    text.replace(re, (_match, hashes, section) => {
+      const icon = SECTION_ICONS[section];
+      return icon ? `${hashes} ${icon} ${section}` : _match;
+    }),
+  );
+}
+
+/**
+ * Transform coms message headers with styled formatting.
+ * `[from peer @ /path/to/cwd]` → `📨 **peer** \`@ /path/to/cwd\``
+ * `[from peer → self @ /path/to/cwd]` → `📨 **peer** → **self** \`@ /path/to/cwd\``
+ */
+export function transformComsHeaders(markdown: string): string {
+  return transformOutsideCodeBlocks(markdown, (text) =>
+    text.replace(
+      /\[from (\S+)(?: → (\S+))? @ ([^\]]+)\]/g,
+      (_match, peer, self, cwd) => {
+        const arrow = self ? ` → **${escapeMarkdown(self)}**` : "";
+        return `📨 **${escapeMarkdown(peer)}**${arrow} ${inlineCode(`@ ${cwd.trim()}`)}`;
+      },
+    ),
+  );
+}
+
+// ── Review findings (Deliverable 3) ──
+
+/** Shape of a single review finding from code reviewers */
+interface ReviewFinding {
+  severity?: string;
+  file?: string;
+  line?: number;
+  description?: string;
+  suggestion?: string;
+  impact?: string;
+  rule?: string;
+}
+
+/**
+ * Transform review findings JSON blocks into readable tables.
+ * Matches ```json blocks containing {"findings": [...]} and renders
+ * each finding with severity badges, file:line refs, and descriptions.
+ */
+export function transformReviewFindings(markdown: string): string {
+  return markdown.replace(
+    /```(?:json)?\s*\n(\{[\s\S]*?"findings"\s*:\s*\[[\s\S]*?\]\s*\})\s*\n```/g,
+    (_match, jsonStr) => {
+      try {
+        const parsed = JSON.parse(jsonStr);
+        if (!parsed || !Array.isArray(parsed.findings)) return _match;
+        const findings: ReviewFinding[] = parsed.findings;
+        if (findings.length === 0) return "✅ **No findings** — review passed";
+
+        const lines: string[] = [`**${findings.length} finding${findings.length !== 1 ? "s" : ""}:**`, ""];
+        for (const f of findings) {
+          const sev = SEVERITY_BADGES[(f.severity || "INFO").toUpperCase()] || f.severity || "INFO";
+          const loc = f.file ? `\`${f.file}${f.line ? `:${f.line}` : ""}\`` : "";
+          lines.push(`${sev}${loc ? ` — ${loc}` : ""}`);
+          if (f.description) lines.push(`  ${f.description}`);
+          if (f.suggestion) lines.push(`  💡 ${f.suggestion}`);
+          if (f.impact) lines.push(`  ⚡ ${f.impact}`);
+          lines.push("");
+        }
+        return lines.join("\n");
+      } catch {
+        return _match;
+      }
+    },
+  );
+}
+
+// ── Settings display (Deliverable 4) ──
+
+/**
+ * Transform settings display output into a styled table.
+ * Matches lines like `key = value (source: project)` or `key: value`
+ * from settings get output.
+ */
+export function transformSettingsDisplay(markdown: string): string {
+  return transformOutsideCodeBlocks(markdown, (text) => {
+    // Match blocks of settings lines: `key = value (source: ...)` pattern
+    return text.replace(
+      /^([ \t]*)([\w.]+)\s*=\s*(.+?)\s*\(source:\s*(\w+)\)\s*$/gm,
+      (_match, indent, key, value, source) => {
+        const sourceIcon = source === "project" ? "📁" : source === "global" ? "🌐" : source === "env" ? "🔧" : "⚙️";
+        return `${indent}\`${key}\` = **${value.trim()}** ${sourceIcon} _${source}_`;
+      },
+    );
+  });
+}
+
+// ── Task list formatting (Deliverable 5) ──
+
+/**
+ * Transform task list status markers into styled badges.
+ * Matches patterns like `status: pending`, `status: in_progress`, `status: completed`
+ * in task list output lines, and also `[pending]`, `[in_progress]`, `[completed]` markers.
+ */
+export function transformTaskStatus(markdown: string): string {
+  return transformOutsideCodeBlocks(markdown, (text) => {
+    // Match `status: <value>` patterns
+    let result = text.replace(
+      /\bstatus:\s*(pending|in_progress|completed|deleted)\b/g,
+      (_match, status) => {
+        const badge = TASK_STATUS_BADGES[status];
+        return badge ? `status: ${badge} ${status}` : _match;
+      },
+    );
+    // Match `[pending]`, `[in_progress]`, `[completed]` standalone markers
+    result = result.replace(
+      /\[(pending|in_progress|completed|deleted)\](?!\()/g,
+      (_match, status) => {
+        const badge = TASK_STATUS_BADGES[status];
+        return badge ? `${badge} ${status}` : _match;
+      },
+    );
+    return result;
+  });
+}
+
+// ── Async agent status formatting (Deliverable 6) ──
+
+/**
+ * Transform async agent status indicators into styled badges.
+ * Matches patterns like `status: running`, `[running]`, `[complete]`, etc.
+ * Also formats duration strings like `duration: 45s` or `(12.3s)`.
+ */
+export function transformAsyncStatus(markdown: string): string {
+  return transformOutsideCodeBlocks(markdown, (text) => {
+    // Match `status: <value>` patterns for async agents
+    let result = text.replace(
+      /\bstatus:\s*(running|queued|complete|failed|killed)\b/g,
+      (_match, status) => {
+        const badge = ASYNC_STATUS_BADGES[status];
+        return badge ? `status: ${badge}` : _match;
+      },
+    );
+    // Match `[running]`, `[complete]`, `[failed]` standalone markers
+    result = result.replace(
+      /\[(running|queued|complete|failed|killed)\](?!\()/g,
+      (_match, status) => {
+        const badge = ASYNC_STATUS_BADGES[status];
+        return badge ? badge : _match;
+      },
+    );
+    return result;
+  });
+}
+
+// ── Main dispatcher ──
+
+/**
+ * Main markdown transformer — dispatches to individual transformers.
+ * Only transforms completed assistant messages; skips streaming to avoid flicker.
+ */
+export function transformMarkdown(
+  markdown: string,
+  context: MarkdownTransformContext,
+): string {
+  if (context.messageType !== "assistant" || context.isStreaming) {
+    return markdown;
+  }
+
+  let result = markdown;
+  result = transformMemoryBadges(result);
+  result = transformMemorySectionHeaders(result);
+  result = transformComsHeaders(result);
+  result = transformSettingsDisplay(result);
+  result = transformTaskStatus(result);
+  result = transformAsyncStatus(result);
+  // Review findings last — its output should not be mutated by other transforms
+  result = transformReviewFindings(result);
+  return result;
+}
+
+// ── Registration ──
+
+export function registerMarkdownTransformer(pi: ExtensionAPI): void {
+  if (typeof (pi as any).registerMarkdownTransformer !== "function") return;
+  pi.registerMarkdownTransformer(transformMarkdown);
+}

package/extensions/orchestrator/memory-embeddings.ts

@@ -3,15 +3,17 @@
  *
  * Embeds memory entries and search queries using Xenova/bge-small-en-v1.5 via
  * @huggingface/transformers (in-process ONNX, no Python, no subprocess).
- * Stores embeddings in .pi/memory/embeddings.json.
+ * Stores embeddings in .pi/memory/embeddings.jsonl (JSONL persistence, issue #724).
+ * Legacy embeddings.json auto-migrated on first access.
  *
  * Falls back gracefully when the model is unavailable — callers always get a
  * result (possibly empty) and never throw.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
 import { join } from "node:path";
 import { createHash } from "node:crypto";
+import { createCachedStore } from "./state-jsonl.js";
+import type { JsonlStateStore } from "./state-jsonl.js";
 
 const EMBEDDING_DIM = 384;
 export const EMBEDDING_POOLING = "mean";
@@ -31,41 +33,41 @@ interface EmbeddingStore {
   entries: Record<string, number[]>; // text hash → vector
 }
 
+const STORE_FILENAME_JSONL = "embeddings.jsonl";
+const LEGACY_STORE_FILENAME = "embeddings.json";
+
+function getEmbeddingStore(cwd: string): JsonlStateStore<EmbeddingStore> {
+  return createCachedStore<EmbeddingStore>(
+    join(cwd, ".pi", "memory"), STORE_FILENAME_JSONL, LEGACY_STORE_FILENAME, { compactThreshold: 30 },
+  );
+}
+
 function getStorePath(cwd: string): string {
-  return join(cwd, ".pi", "memory", "embeddings.json");
+  return join(cwd, ".pi", "memory", STORE_FILENAME_JSONL);
 }
 
 function loadStore(cwd: string): EmbeddingStore {
-  const storePath = getStorePath(cwd);
-  if (existsSync(storePath)) {
-    try {
-      const store = JSON.parse(readFileSync(storePath, "utf-8")) as EmbeddingStore;
-      // Invalidate cache when pooling strategy changes — CLS and mean vectors are incompatible
-      if (store.pooling !== EMBEDDING_POOLING) {
-        console.debug(`[memory-embeddings] pooling changed (${store.pooling ?? "cls"} → ${EMBEDDING_POOLING}), clearing ${Object.keys(store.entries).length} cached embeddings`);
-        store.entries = {};
-        store.pooling = EMBEDDING_POOLING;
-        queryCache.clear();
-        saveStore(cwd, store);
-      }
-      return store;
-    } catch {
-      // Corrupted file — start fresh
+  const store = getEmbeddingStore(cwd);
+  const data = store.read();
+  if (data !== null) {
+    // Invalidate cache when pooling strategy changes — CLS and mean vectors are incompatible
+    if (data.pooling !== EMBEDDING_POOLING) {
+      // pooling strategy changed — clear incompatible cached embeddings
+      data.entries = {};
+      data.pooling = EMBEDDING_POOLING;
+      queryCache.clear();
+      saveStore(cwd, data);
     }
+    return data;
   }
   return { model: "Xenova/bge-small-en-v1.5", dim: EMBEDDING_DIM, pooling: EMBEDDING_POOLING, entries: {} };
 }
 
 function saveStore(cwd: string, store: EmbeddingStore): void {
   try {
-    const dir = join(cwd, ".pi", "memory");
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    const target = getStorePath(cwd);
-    const tmp = target + ".tmp";
-    writeFileSync(tmp, JSON.stringify(store), "utf-8");
-    renameSync(tmp, target);
-  } catch (err: any) {
-    console.debug("[memory-embeddings] save failed:", err?.message?.slice(0, 100));
+    getEmbeddingStore(cwd).write(store);
+  } catch {
+    // save failed — non-fatal, embeddings will be recomputed on next access
   }
 }
 
@@ -92,8 +94,8 @@ async function getPipeline(): Promise<any> {
       });
       pipelineInstance = extractor;
       return extractor;
-    } catch (err: any) {
-      console.debug("[memory-embeddings] model init failed:", err?.message?.slice(0, 100));
+    } catch {
+      // model init failed — vector search will be unavailable
       // Don't permanently disable — allow retry on next call
       return null;
     } finally {
@@ -123,8 +125,8 @@ async function embed(texts: string[]): Promise<number[][] | null> {
       vectors.push(Array.from(result[i].data as Float32Array));
     }
     return vectors;
-  } catch (err: any) {
-    console.debug("[memory-embeddings] embed failed:", err?.message?.slice(0, 100));
+  } catch {
+    // embed failed — return null, caller handles gracefully
     return null;
   }
 }
@@ -189,8 +191,8 @@ export async function embedEntry(cwd: string, text: string, category?: string):
 
     store.entries[hash] = vectors[0];
     saveStore(cwd, store);
-  } catch (err: any) {
-    console.debug("[memory-embeddings] embedEntry failed:", err?.message?.slice(0, 100));
+  } catch {
+    // embedEntry failed — non-fatal
   }
 }
 
@@ -205,8 +207,8 @@ export function removeEmbedding(cwd: string, text: string, category?: string): v
       delete store.entries[hash];
       saveStore(cwd, store);
     }
-  } catch (err: any) {
-    console.debug("[memory-embeddings] removeEmbedding failed:", err?.message?.slice(0, 100));
+  } catch {
+    // removeEmbedding failed — non-fatal, stale embedding is harmless
   }
 }
 

package/extensions/orchestrator/memory-provenance.ts

@@ -1,14 +1,18 @@
 /**
- * Provenance pending merge — dream writes a sidecar JSON; onComplete merges
- * into memory-scores.json without asking the LLM to edit scores JSON.
+ * Provenance pending merge — dream writes a sidecar JSONL; onComplete merges
+ * into memory-scores.jsonl without asking the LLM to edit scores JSONL.
  *
- * Sidecar: `.pi/memory/provenance-pending.json`
- * Shape: { entries: [{ category, text, sourceSession?, derivedFrom?, informs? }] }
+ * Sidecar: `.pi/memory/provenance-pending.jsonl`
+ * Shape per line: { category, text, sourceSession?, derivedFrom?, informs? }
+ *
+ * Persistence: JsonlStateStore (issue #724). Legacy JSON auto-migrated.
  */
 
-import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { unlinkSync } from "node:fs";
+import { join } from "node:path";
 import { entryHash, loadScores, saveScores, type MemoryCategory } from "./memory-scoring.js";
+import { createCachedStore } from "./state-jsonl.js";
+import type { JsonlStateStore } from "./state-jsonl.js";
 
 export interface ProvenancePendingItem {
   category: MemoryCategory | string;
@@ -22,39 +26,38 @@ export interface ProvenancePendingFile {
   entries: ProvenancePendingItem[];
 }
 
+const PROVENANCE_FILENAME_JSONL = "provenance-pending.jsonl";
+const LEGACY_PROVENANCE_FILENAME = "provenance-pending.json";
+
+function getProvenanceStore(cwd: string): JsonlStateStore<ProvenancePendingFile> {
+  return createCachedStore<ProvenancePendingFile>(
+    join(cwd, ".pi", "memory"), PROVENANCE_FILENAME_JSONL, LEGACY_PROVENANCE_FILENAME,
+  );
+}
+
 export function getProvenancePendingPath(cwd: string): string {
-  return join(cwd, ".pi", "memory", "provenance-pending.json");
+  return join(cwd, ".pi", "memory", PROVENANCE_FILENAME_JSONL);
 }
 
 export function writeProvenancePending(
   cwd: string,
   entries: ProvenancePendingItem[],
 ): void {
-  const path = getProvenancePendingPath(cwd);
-  const dir = dirname(path);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   const payload: ProvenancePendingFile = { entries };
-  writeFileSync(path, JSON.stringify(payload, null, 2) + "\n", "utf-8");
+  getProvenanceStore(cwd).write(payload);
 }
 
 /**
- * Merge provenance-pending.json into scores, then delete the sidecar.
+ * Merge provenance-pending.jsonl into scores, then delete the sidecar.
  * Returns number of entries updated.
  */
 export function mergeProvenancePending(cwd: string): number {
-  const path = getProvenancePendingPath(cwd);
-  if (!existsSync(path)) return 0;
-
-  let pending: ProvenancePendingFile;
-  try {
-    pending = JSON.parse(readFileSync(path, "utf-8")) as ProvenancePendingFile;
-  } catch (e: any) {
-    console.debug("[memory-provenance] parse failed:", e?.message || e);
-    return 0;
-  }
-
+  const store = getProvenanceStore(cwd);
+  const pending = store.read();
   if (!pending?.entries?.length) {
-    try { unlinkSync(path); } catch { /* ignore */ }
+    // Clean up empty/absent sidecar
+    const p = getProvenancePendingPath(cwd);
+    try { unlinkSync(p); } catch { /* ignore */ }
     return 0;
   }
 
@@ -75,6 +78,7 @@ export function mergeProvenancePending(cwd: string): number {
 
   if (updated > 0) saveScores(cwd, scores);
 
-  try { unlinkSync(path); } catch { /* ignore */ }
+  // Delete the consumed sidecar
+  try { unlinkSync(getProvenancePendingPath(cwd)); } catch { /* ignore */ }
   return updated;
 }

package/extensions/orchestrator/memory-scoring.ts

@@ -9,11 +9,16 @@
  * Clean-room TypeScript implementation under MIT — not a code translation.
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { createLogger } from "../shared/logger.js";
+import { join } from "node:path";
+import { createCachedStore } from "./state-jsonl.js";
+import type { JsonlStateStore } from "./state-jsonl.js";
 
 // ── Types ──────────────────────────────────────────────────────────────────
 
+const memLog = createLogger("memory");
+memLog.debug("memory-scoring module loaded");
+
 export type MemoryCategory = "preference" | "lesson" | "pattern" | "decision" | "done" | "mistake";
 export type CueType = "explicit" | "structural" | "behavioral" | "recurrence";
 export type UserState = "auto" | "pinned" | "forgotten";
@@ -175,33 +180,33 @@ export function entryHash(text: string): string {
 }
 
 // ── Scores File I/O ────────────────────────────────────────────────────────
+// Persistence: append-only JSONL via JsonlStateStore (issue #724).
+// Legacy memory-scores.json is auto-migrated on first access.
+
+const SCORES_FILENAME_JSONL = "memory-scores.jsonl";
+const LEGACY_SCORES_FILENAME = "memory-scores.json";
 
-const SCORES_FILENAME = "memory-scores.json";
+function getScoresStore(cwd: string): JsonlStateStore<ScoresFile> {
+  return createCachedStore<ScoresFile>(
+    join(cwd, ".pi", "memory"), SCORES_FILENAME_JSONL, LEGACY_SCORES_FILENAME, { compactThreshold: 50 },
+  );
+}
 
 export function getScoresPath(cwd: string): string {
-  return join(cwd, ".pi", "memory", SCORES_FILENAME);
+  return join(cwd, ".pi", "memory", SCORES_FILENAME_JSONL);
 }
 
 export function loadScores(cwd: string): ScoresFile {
-  const path = getScoresPath(cwd);
-  if (!existsSync(path)) {
-    return { entries: {}, lastRebuild: new Date().toISOString() };
-  }
-  try {
-    const raw = readFileSync(path, "utf-8");
-    return JSON.parse(raw) as ScoresFile;
-  } catch {
+  const store = getScoresStore(cwd);
+  const data = store.read();
+  if (data === null) {
     return { entries: {}, lastRebuild: new Date().toISOString() };
   }
+  return data;
 }
 
 export function saveScores(cwd: string, scores: ScoresFile): void {
-  const path = getScoresPath(cwd);
-  const dir = dirname(path);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(path, JSON.stringify(scores, null, 2) + "\n", "utf-8");
+  getScoresStore(cwd).write(scores);
 }
 
 // ── Internal Types ─────────────────────────────────────────────────────────

package/extensions/orchestrator/memory-tools.ts

@@ -12,6 +12,7 @@
  * Clean-room TypeScript implementation under MIT — not a code translation.
  */
 
+import { createLogger } from "../shared/logger.js";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
@@ -61,7 +62,7 @@ function registerMemorySearch(pi: ExtensionAPI, state: { embeddingsMigrated: boo
           await embedMissing(cwd, topicEntries);
           state.embeddingsMigrated = true; // Only mark done on success
         } catch {
-          console.debug("[memory] embedding migration failed, will retry next search");
+          log.debug("memory: embedding migration failed, will retry next search");
         }
       }
       const scores = loadScores(cwd);
@@ -159,6 +160,7 @@ function registerMemorySearch(pi: ExtensionAPI, state: { embeddingsMigrated: boo
         return `- [${r.category}] ${r.text}${pin} — score: ${typeof r.score === "number" ? r.score.toFixed(2) : r.score}, evidence: ${r.evidenceCount}${sim}${prov}`;
       });
 
+      log.info("memory_search", params.query, results.length);
       const text = `Found ${results.length} memories matching "${params.query}":\n\n${lines.join("\n")}`;
       return { content: [{ type: "text", text }] };
     },
@@ -188,6 +190,7 @@ function registerMemoryReinforce(pi: ExtensionAPI): void {
       const reinforced = reinforce(ctx.cwd, entryLine);
 
       if (reinforced) {
+        log.info("memory_reinforce", params.entryText.slice(0, 60));
         const scores = loadScores(ctx.cwd);
         const hash = entryHash(entryLine);
         const entry = scores.entries[hash];
@@ -199,7 +202,7 @@ function registerMemoryReinforce(pi: ExtensionAPI): void {
               (promo.details.length ? ` (${promo.details.join("; ")})` : "");
           }
         } catch (e: any) {
-          console.debug("[memory] promote-after-reinforce failed:", e?.message || e);
+          log.debug("memory: promote-after-reinforce failed:", e?.message || e);
         }
         return {
           content: [{
@@ -410,7 +413,7 @@ function registerMemoryAdd(pi: ExtensionAPI): void {
           }
         }
       } catch (err) {
-        console.debug(`[memory] memory_add: vector dedup skipped: ${err}`);
+        log.debug(`memory: memory_add: vector dedup skipped: ${err}`);
       }
 
       // Exact match check (fast O(n) string comparison after expensive vector check)
@@ -522,6 +525,7 @@ function registerMemoryAdd(pi: ExtensionAPI): void {
       // Embed the new entry for future similarity searches
       await embedEntry(cwd, text, category);
 
+      log.info("memory_add", category, text.slice(0, 60));
       const pin = isPinned ? " (pinned)" : "";
       return {
         content: [{ type: "text", text: `Added: [${category}] ${text}${pin}` }],
@@ -602,6 +606,7 @@ function registerMemoryRemove(pi: ExtensionAPI): void {
         saveScores(cwd, scores);
       }
 
+      log.info("memory_remove", category, text.slice(0, 60));
       return {
         content: [{ type: "text", text: `Removed: [${category}] ${text}` }],
       };
@@ -866,6 +871,8 @@ function registerMemoryConsolidate(pi: ExtensionAPI): void {
 
 // ── registerMemoryTools (entry point) ───────────────────────────────
 
+const log = createLogger("memory");
+
 export function registerMemoryTools(pi: ExtensionAPI): void {
   // Only register in the orchestrator, not subagents
   if (process.env.PI_SUBAGENT_CHILD === "1") return;