synabun 1.3.0

package/hooks/claude-code/post-plan.mjs

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+
+/**
+ * SynaBun PostToolUse Hook — Plan Storage
+ *
+ * Matches: ^(Enter|Exit)PlanMode$
+ *
+ * EnterPlanMode: Injects a reminder to use AskUserQuestion for
+ * clarifications instead of plain-text questions.
+ *
+ * ExitPlanMode: When Claude exits plan mode (plan approved), this hook:
+ * 1. Finds the most recently modified plan file in ~/.claude/plans/
+ * 2. Auto-creates a child category under "plans" for the project if needed
+ * 3. Generates a local embedding and stores the plan in SQLite
+ * 4. Returns additionalContext confirming storage
+ *
+ * Input (stdin JSON):
+ *   { session_id, tool_name, tool_input, tool_response, cwd }
+ *
+ * Output (stdout JSON):
+ *   { additionalContext: "..." } on success, or {} on skip/error
+ */
+
+import { readFileSync, writeFileSync, appendFileSync, readdirSync, statSync, existsSync, mkdirSync } from 'node:fs';
+import { DatabaseSync } from 'node:sqlite';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { randomUUID } from 'node:crypto';
+import { detectProject, getMcpCategoriesPath, MCP_DATA_DIR, DATA_DIR } from './shared.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Debug log (append-only, survives across invocations)
+const DEBUG_LOG_PATH = join(DATA_DIR, 'plan-debug.log');
+function debugLog(msg) {
+  try {
+    const ts = new Date().toISOString();
+    appendFileSync(DEBUG_LOG_PATH, `[${ts}] ${msg}\n`, 'utf-8');
+  } catch { /* best-effort */ }
+}
+
+// Plans directory — project-local to avoid ~/.claude/ sensitive-file permission prompts
+const PLANS_DIR = join(DATA_DIR, 'plans');
+// Fallback: Claude Code's ExitPlanMode may still write to ~/.claude/plans/ internally
+const PLANS_DIR_FALLBACK = join(process.env.USERPROFILE || process.env.HOME || '', '.claude', 'plans');
+
+// Dedup tracker — records which plan files have already been stored
+const STORED_PLANS_PATH = join(DATA_DIR, 'stored-plans.json');
+
+// SQLite database path
+const DB_PATH = process.env.SQLITE_DB_PATH || join(MCP_DATA_DIR, 'memory.db');
+
+// ─── Stdin ───
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('{}');
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    setTimeout(() => resolve(data || '{}'), 3000);
+  });
+}
+
+// ─── Local embedding generation ───
+
+async function generateEmbedding(text) {
+  const embPath = join(__dirname, '..', '..', 'mcp-server', 'dist', 'services', 'local-embeddings.js');
+  if (!existsSync(embPath)) {
+    throw new Error('MCP server not built. Run: cd mcp-server && npm run build');
+  }
+  const { generateEmbedding: embed } = await import(pathToFileURL(embPath).href);
+  return embed(text);
+}
+
+// ─── Vector encoding ───
+
+function encodeVector(vector) {
+  const f32 = new Float32Array(vector);
+  return new Uint8Array(f32.buffer);
+}
+
+// ─── Database storage ───
+
+function storeInSQLite(id, vector, payload) {
+  const db = new DatabaseSync(DB_PATH);
+  db.exec('PRAGMA journal_mode = WAL');
+  db.exec('PRAGMA busy_timeout = 5000');
+
+  try {
+    db.prepare(`
+      INSERT OR REPLACE INTO memories
+        (id, vector, content, category, subcategory, project, tags, importance, source,
+         created_at, updated_at, accessed_at, access_count, related_files,
+         related_memory_ids, file_checksums, trashed_at, source_session_chunks)
+      VALUES
+        (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      id,
+      encodeVector(vector),
+      payload.content,
+      payload.category,
+      payload.subcategory || null,
+      payload.project,
+      JSON.stringify(payload.tags || []),
+      payload.importance || 5,
+      payload.source || 'auto-saved',
+      payload.created_at,
+      payload.updated_at,
+      payload.accessed_at,
+      payload.access_count || 0,
+      null, // related_files
+      null, // related_memory_ids
+      null, // file_checksums
+      null, // trashed_at
+      null, // source_session_chunks
+    );
+  } finally {
+    db.close();
+  }
+}
+
+// ─── Dedup tracker ───
+
+function loadStoredPlans() {
+  try {
+    if (!existsSync(STORED_PLANS_PATH)) return {};
+    return JSON.parse(readFileSync(STORED_PLANS_PATH, 'utf-8'));
+  } catch { return {}; }
+}
+
+function markPlanStored(fileName, memoryId) {
+  const stored = loadStoredPlans();
+  stored[fileName] = { memoryId, storedAt: new Date().toISOString() };
+  try {
+    if (!existsSync(dirname(STORED_PLANS_PATH))) mkdirSync(dirname(STORED_PLANS_PATH), { recursive: true });
+    writeFileSync(STORED_PLANS_PATH, JSON.stringify(stored, null, 2), 'utf-8');
+  } catch { /* best-effort */ }
+}
+
+// ─── Plan file discovery ───
+
+/**
+ * List all plan .md files, sorted by mtime descending.
+ * Each entry: { name, path, mtime }
+ */
+function listPlanFiles() {
+  const results = [];
+  for (const dir of [PLANS_DIR, PLANS_DIR_FALLBACK]) {
+    if (!existsSync(dir)) continue;
+    for (const f of readdirSync(dir).filter((f) => f.endsWith('.md'))) {
+      // Skip duplicates (same filename in both dirs — prefer primary)
+      if (results.some((r) => r.name === f)) continue;
+      const fullPath = join(dir, f);
+      const stat = statSync(fullPath);
+      results.push({ name: f, path: fullPath, mtime: stat.mtimeMs });
+    }
+  }
+  return results.sort((a, b) => b.mtime - a.mtime);
+}
+
+/**
+ * Match the correct plan file using tool_response content from ExitPlanMode.
+ * Strategies (in order):
+ *   1. Filename extraction — tool_response may reference the plan filename
+ *   2. Content matching — tool_response may contain the plan text; find the file whose content matches
+ * Returns null if no match or if the matched file is already stored.
+ */
+function findPlanByContent(toolResponse) {
+  if (!toolResponse || typeof toolResponse !== 'string') return null;
+
+  const stored = loadStoredPlans();
+  const files = listPlanFiles();
+  if (files.length === 0) return null;
+
+  // Strategy 1: Extract filename pattern (word-word-word.md) from response
+  const fnameMatch = toolResponse.match(/([a-z]+-[a-z]+-[a-z]+\.md)/);
+  if (fnameMatch) {
+    const matched = files.find((f) => f.name === fnameMatch[1]);
+    if (matched && !stored[matched.name]) return { ...matched, method: 'filename' };
+  }
+
+  // Strategy 2: Content matching — compare response text against each unstored plan file
+  // tool_response from ExitPlanMode likely contains the plan content itself
+  const responseTrimmed = toolResponse.trim();
+  if (responseTrimmed.length > 50) {
+    // Extract first meaningful line (H1 heading or first paragraph) for fast pre-filter
+    const responseFirstLine = responseTrimmed.split('\n').find((l) => l.trim())?.trim() || '';
+
+    for (const file of files) {
+      if (stored[file.name]) continue;
+      try {
+        const content = readFileSync(file.path, 'utf-8').trim();
+        // Exact match
+        if (content === responseTrimmed) return { ...file, method: 'exact-content' };
+        // Response contains the file content (response may have extra wrapper text)
+        if (responseTrimmed.includes(content)) return { ...file, method: 'content-in-response' };
+        // File content contains the response (file is the full plan, response is a subset)
+        if (content.includes(responseTrimmed)) return { ...file, method: 'response-in-content' };
+        // First-line match as fallback (H1 heading match)
+        if (responseFirstLine.length > 10) {
+          const fileFirstLine = content.split('\n').find((l) => l.trim())?.trim() || '';
+          if (fileFirstLine === responseFirstLine) return { ...file, method: 'heading-match' };
+        }
+      } catch { /* skip unreadable files */ }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Fallback: return the most recently modified unstored plan file.
+ * Used only when content matching fails (no tool_response or no match).
+ */
+function findLatestPlan() {
+  const stored = loadStoredPlans();
+  const files = listPlanFiles();
+  if (files.length === 0) return null;
+  const unstored = files.find((f) => !stored[f.name]);
+  return unstored ? { ...unstored, method: 'mtime-fallback' } : null;
+}
+
+// ─── Category management ───
+
+function ensureProjectCategory(project) {
+  const categoryName = `plans-${project}`;
+  const catPath = getMcpCategoriesPath();
+
+  try {
+    const data = JSON.parse(readFileSync(catPath, 'utf-8'));
+    const categories = data.categories || [];
+
+    // Check if child category already exists
+    if (categories.some((c) => c.name === categoryName)) {
+      return categoryName;
+    }
+
+    // Check if "plans" parent exists
+    if (!categories.some((c) => c.name === 'plans')) {
+      // Create parent if missing (shouldn't happen, but safety net)
+      categories.push({
+        name: 'plans',
+        description: 'Implementation plans stored after plan mode approval. Sub-categorized by project name.',
+        is_parent: true,
+        color: '#06d6a0',
+        created_at: new Date().toISOString(),
+      });
+    }
+
+    // Create child category for this project
+    categories.push({
+      name: categoryName,
+      description: `Implementation plans for ${project} project`,
+      parent: 'plans',
+      created_at: new Date().toISOString(),
+    });
+
+    data.categories = categories;
+    writeFileSync(catPath, JSON.stringify(data, null, 2), 'utf-8');
+
+    return categoryName;
+  } catch {
+    // If categories file can't be read/written, fall back to parent
+    return 'plans';
+  }
+}
+
+// ─── Neural Interface cache invalidation ───
+
+async function invalidateNeuralInterface() {
+  try {
+    // Trigger sync broadcast so the Neural Interface graph refreshes
+    const niUrl = process.env.SYNABUN_NI_URL || 'http://localhost:3344';
+    await fetch(`${niUrl}/api/memories?invalidate=true`, {
+      method: 'GET',
+      signal: AbortSignal.timeout(2000),
+    });
+  } catch { /* fire-and-forget */ }
+}
+
+// ─── Extract plan title from markdown ───
+
+function extractPlanTitle(content) {
+  // Look for first H1 heading
+  const h1Match = content.match(/^#\s+(.+)$/m);
+  if (h1Match) return h1Match[1].trim();
+
+  // Fall back to first non-empty line
+  const firstLine = content.split('\n').find((l) => l.trim());
+  return firstLine?.trim().slice(0, 100) || 'Untitled plan';
+}
+
+// ─── Main ───
+
+async function main() {
+  let input = {};
+  try {
+    const raw = await readStdin();
+    input = JSON.parse(raw);
+  } catch { /* proceed */ }
+
+  const toolName = input.tool_name || '';
+
+  debugLog(`Hook invoked — tool_name: "${toolName}", session: ${input.session_id || 'unknown'}, cwd: ${input.cwd || 'unknown'}`);
+
+  // Handle EnterPlanMode — remind Claude to use AskUserQuestion
+  if (toolName === 'EnterPlanMode') {
+    debugLog('EnterPlanMode fired — injecting AskUserQuestion reminder');
+    process.stdout.write(JSON.stringify({
+      additionalContext: `SynaBun: You are now in plan mode. When you have questions or need clarification from the user, you MUST use the \`AskUserQuestion\` tool — do NOT write questions as plain text. Load it via \`ToolSearch\` if its schema is not yet available. Use \`ExitPlanMode\` for final plan approval.\n\n**Plan file location**: Write plan files to \`${PLANS_DIR}/\` — NOT \`~/.claude/plans/\`. This avoids sensitive-file permission prompts that stall the session.`,
+    }));
+    return;
+  }
+
+  // Only handle ExitPlanMode beyond this point
+  if (toolName !== 'ExitPlanMode') {
+    process.stdout.write(JSON.stringify({}));
+    return;
+  }
+
+  // Match plan file: content-match first (session-accurate), mtime fallback
+  const toolResponse = typeof input.tool_response === 'string'
+    ? input.tool_response
+    : (input.tool_response != null ? JSON.stringify(input.tool_response) : '');
+
+  debugLog(`ExitPlanMode fired — tool_response length: ${toolResponse.length}, first 200 chars: ${toolResponse.slice(0, 200).replace(/\n/g, '\\n')}`);
+
+  const planFile = findPlanByContent(toolResponse) || findLatestPlan();
+  if (!planFile) {
+    process.stdout.write(JSON.stringify({
+      additionalContext: 'SynaBun: No unstored plan file found (all plans already in memory).',
+    }));
+    return;
+  }
+
+  const planContent = readFileSync(planFile.path, 'utf-8');
+  if (!planContent.trim()) {
+    process.stdout.write(JSON.stringify({}));
+    return;
+  }
+
+  const project = detectProject(input.cwd || '');
+  const planTitle = extractPlanTitle(planContent);
+
+  // Ensure child category exists under "plans"
+  const categoryName = ensureProjectCategory(project);
+
+  // Generate local embedding (Transformers.js, no API key needed)
+  const embedding = await generateEmbedding(planContent);
+
+  // Store in SQLite
+  const id = randomUUID();
+  const now = new Date().toISOString();
+
+  storeInSQLite(id, embedding, {
+    content: planContent,
+    category: categoryName,
+    project,
+    importance: 7,
+    tags: ['plan', 'implementation', project],
+    source: 'auto-saved',
+    subcategory: 'plan',
+    created_at: now,
+    updated_at: now,
+    accessed_at: now,
+    access_count: 0,
+  });
+
+  // Mark this plan as stored (dedup for future ExitPlanMode calls)
+  markPlanStored(planFile.name, id);
+
+  // Invalidate Neural Interface cache (fire-and-forget)
+  invalidateNeuralInterface();
+
+  // Confirm storage — include match method for diagnostics
+  const shortTitle = planTitle.length > 60 ? planTitle.slice(0, 60) + '...' : planTitle;
+  const matchInfo = planFile.method || 'unknown';
+  debugLog(`Stored plan: ${planFile.name} [${matchInfo}] → memory ${id} (project: ${project})`);
+  process.stdout.write(JSON.stringify({
+    additionalContext: `SynaBun: Plan stored in memory [${id}] — "${shortTitle}" (category: ${categoryName}, project: ${project}). Source file: ${planFile.name} [matched: ${matchInfo}]`,
+  }));
+}
+
+main().catch((err) => {
+  // On error, still output valid JSON so Claude Code doesn't break
+  process.stdout.write(JSON.stringify({
+    additionalContext: `SynaBun: Plan storage failed — ${err.message}. The plan file is still saved at ${PLANS_DIR}.`,
+  }));
+});

package/hooks/claude-code/post-remember.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+/**
+ * SynaBun PostToolUse Hook for Claude Code (unified handler)
+ *
+ * Matches: ^Edit$|^Write$|^NotebookEdit$|mcp__SynaBun__remember
+ *
+ * Two responsibilities:
+ *
+ * 1. EDIT TRACKING — When Claude uses Edit, Write, or NotebookEdit,
+ *    increments a pending-remember counter. If Claude finishes responding
+ *    with 3+ unremembered edits, the Stop hook will block it.
+ *
+ * 2. FLAG MANAGEMENT — When Claude calls `remember`:
+ *    - category "conversations" → clears pending-compact flag (compaction enforcement)
+ *    - any other category       → resets pending-remember flag (editCount→0,
+ *      keeps rememberCount/totalEdits so subsequent edits start a fresh segment)
+ *
+ * Input (stdin JSON):
+ *   { session_id, tool_name, tool_input: { ... }, tool_response: { ... } }
+ *
+ * Output (stdout JSON):
+ *   - On edit at threshold multiples (3, 6, 9...): { additionalContext: "..." }
+ *   - Otherwise: {} (side effects only)
+ */
+
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadCategories, buildCategoryReference, detectProject } from './shared.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DATA_DIR = join(__dirname, '..', '..', 'data');
+const PENDING_COMPACT_DIR = join(DATA_DIR, 'pending-compact');
+const PENDING_REMEMBER_DIR = join(DATA_DIR, 'pending-remember');
+
+// Ensure directories exist
+for (const dir of [PENDING_COMPACT_DIR, PENDING_REMEMBER_DIR]) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+const EDIT_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit']);
+const EDIT_THRESHOLD = 1;
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('{}');
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    setTimeout(() => resolve(data || '{}'), 2000);
+  });
+}
+
+async function main() {
+  let input = {};
+  try {
+    const raw = await readStdin();
+    input = JSON.parse(raw);
+  } catch { /* proceed */ }
+
+  const sessionId = input.session_id || '';
+  const toolName = input.tool_name || '';
+  const toolInput = input.tool_input || {};
+  const cwd = input.cwd || '';
+
+  if (!sessionId) {
+    process.stdout.write(JSON.stringify({}));
+    return;
+  }
+
+  // ─── EDIT TRACKING ───
+  if (EDIT_TOOLS.has(toolName)) {
+    const flagPath = join(PENDING_REMEMBER_DIR, `${sessionId}.json`);
+    let flag = { editCount: 0, retries: 0, files: [], firstEditAt: null };
+
+    // Read existing flag if present
+    if (existsSync(flagPath)) {
+      try {
+        flag = JSON.parse(readFileSync(flagPath, 'utf-8'));
+      } catch { /* start fresh */ }
+    }
+
+    // Increment edit counters
+    flag.editCount = (flag.editCount || 0) + 1;
+    flag.totalEdits = (flag.totalEdits || 0) + 1;
+    if (!flag.firstEditAt) flag.firstEditAt = new Date().toISOString();
+    flag.lastEditAt = new Date().toISOString();
+
+    // Track file path if available
+    const filePath = toolInput.file_path || toolInput.notebook_path || '';
+    if (filePath && Array.isArray(flag.files) && !flag.files.includes(filePath)) {
+      flag.files.push(filePath);
+    }
+
+    try {
+      writeFileSync(flagPath, JSON.stringify(flag));
+    } catch { /* ok */ }
+
+    // Proactive nudge at every multiple of threshold (3, 6, 9, ...)
+    if (flag.editCount > 0 && flag.editCount % EDIT_THRESHOLD === 0) {
+      let nudgeText;
+      if (flag.editCount <= EDIT_THRESHOLD) {
+        nudgeText = `SynaBun: ${flag.editCount} file edits so far — remember to store this work in memory before wrapping up.`;
+      } else if (flag.editCount <= EDIT_THRESHOLD * 2) {
+        nudgeText = `SynaBun: ${flag.editCount} file edits without storing to memory. Call \`remember\` soon to avoid losing context.`;
+      } else {
+        nudgeText = `SynaBun: ${flag.editCount} file edits — this is significant work. You MUST call \`remember\` before continuing.`;
+      }
+
+      // On first threshold hit, append the full category reference (lazy injection)
+      if (!flag.categoryTreeInjected) {
+        try {
+          const categories = loadCategories();
+          const project = detectProject(cwd);
+          const categoryRef = buildCategoryReference(categories, project);
+          nudgeText += `\n\n${categoryRef}`;
+          flag.categoryTreeInjected = true;
+          writeFileSync(flagPath, JSON.stringify(flag));
+        } catch { /* category tree optional — nudge still works without it */ }
+      }
+
+      process.stdout.write(JSON.stringify({ additionalContext: nudgeText }));
+    } else {
+      process.stdout.write(JSON.stringify({}));
+    }
+    return;
+  }
+
+  // ─── USER LEARNING CLEARING (remember or reflect for communication-style/personality) ───
+  // Since user learning is non-blocking (prompt-submit nudge only), any remember or
+  // reflect targeting communication-style clears the flag immediately.
+  const UL_CATEGORIES = ['communication-style', 'personality'];
+  const isRememberUL = toolName.includes('remember') && UL_CATEGORIES.includes(toolInput.category || '');
+  const isReflectUL = toolName.includes('reflect');
+
+  if (isRememberUL || isReflectUL) {
+    const ulFlagPath = join(PENDING_REMEMBER_DIR, `${sessionId}.json`);
+    if (existsSync(ulFlagPath)) {
+      try {
+        const ulFlag = JSON.parse(readFileSync(ulFlagPath, 'utf-8'));
+        if (ulFlag.userLearningPending && (isRememberUL || isReflectUL)) {
+          ulFlag.userLearningPending = false;
+          ulFlag.userLearningObserved = true;
+          writeFileSync(ulFlagPath, JSON.stringify(ulFlag));
+        }
+      } catch { /* ok */ }
+    }
+  }
+
+  // ─── REMEMBER FLAG CLEARING ───
+  // Both remember and reflect count as storing work — clear edit tracking for either.
+  if (toolName.includes('remember') || toolName.includes('reflect')) {
+    const category = toolInput.category || '';
+
+    if (category === 'conversations') {
+      // Clear ALL pending-compact flags (session ID may differ after compaction)
+      try {
+        if (existsSync(PENDING_COMPACT_DIR)) {
+          for (const f of readdirSync(PENDING_COMPACT_DIR).filter(f => f.endsWith('.json'))) {
+            try { unlinkSync(join(PENDING_COMPACT_DIR, f)); } catch { /* ok */ }
+          }
+        }
+      } catch { /* ok */ }
+      // Also reset pending-remember flag (conversations remember counts too)
+      const rememberFlagPath = join(PENDING_REMEMBER_DIR, `${sessionId}.json`);
+      if (existsSync(rememberFlagPath)) {
+        try {
+          let flag = {};
+          try { flag = JSON.parse(readFileSync(rememberFlagPath, 'utf-8')); } catch { /* fresh */ }
+          flag.editCount = 0;
+          flag.messageCount = 0;
+          flag.retries = 0;
+          flag.files = [];
+          flag.firstEditAt = null;
+          flag.lastEditAt = null;
+          flag.rememberCount = (flag.rememberCount || 0) + 1;
+          flag.lastRememberedAt = new Date().toISOString();
+          writeFileSync(rememberFlagPath, JSON.stringify(flag));
+        } catch { /* ok */ }
+      }
+    } else if (category) {
+      // Reset pending-remember flag (keep file, zero counters for next task segment)
+      const rememberFlagPath = join(PENDING_REMEMBER_DIR, `${sessionId}.json`);
+      if (existsSync(rememberFlagPath)) {
+        try {
+          let flag = {};
+          try { flag = JSON.parse(readFileSync(rememberFlagPath, 'utf-8')); } catch { /* start fresh */ }
+
+          const prevTotal = flag.totalEdits || flag.editCount || 0;
+          const prevRememberCount = flag.rememberCount || 0;
+
+          // Reset edit + message tracking but keep session-level stats
+          flag.editCount = 0;
+          flag.messageCount = 0;
+          flag.retries = 0;
+          flag.files = [];
+          flag.firstEditAt = null;
+          flag.lastEditAt = null;
+          flag.firstMessageAt = null;
+          flag.lastMessageAt = null;
+          flag.lastRememberedAt = new Date().toISOString();
+          flag.rememberCount = prevRememberCount + 1;
+          flag.totalEdits = prevTotal;
+
+          writeFileSync(rememberFlagPath, JSON.stringify(flag));
+        } catch {
+          // If reset fails, fall back to deleting
+          try { unlinkSync(rememberFlagPath); } catch { /* ok */ }
+        }
+      }
+    }
+  }
+
+  // Update loop memory tracking when remember is called during an active loop
+  if (toolName.includes('remember')) {
+    const LOOP_DIR = join(DATA_DIR, 'loop');
+    const loopPath = join(LOOP_DIR, `${sessionId}.json`);
+    if (existsSync(loopPath)) {
+      try {
+        const loop = JSON.parse(readFileSync(loopPath, 'utf-8'));
+        if (loop.active) {
+          loop.lastMemoryAt = loop.currentIteration || 0;
+          loop.memoryPending = false;
+          loop.memoryRetries = 0;
+          writeFileSync(loopPath, JSON.stringify(loop, null, 2));
+        }
+      } catch { /* ok */ }
+    }
+  }
+
+  // Always output empty (no additional context needed)
+  process.stdout.write(JSON.stringify({}));
+}
+
+main().catch(() => {
+  process.stdout.write(JSON.stringify({}));
+});