claude-smart 0.2.42 → 0.2.44

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/plugin/index.ts

@@ -0,0 +1,327 @@
+// Reflexio Embedded — Openclaw plugin entry.
+//
+// Registers lifecycle hooks against the Openclaw Plugin API:
+//   - before_prompt_build: TTL sweep, workspace setup, system prompt injection
+//   - before_compaction:   run extractor subagent over the session transcript
+//   - before_reset:        run extractor subagent before the transcript is wiped
+//   - session_end:         run extractor subagent on session termination
+//
+// The TTL sweep + extractor spawning logic lives in ./hook/handler.ts and is
+// re-used verbatim — this file is only the SDK wiring.
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import {
+  injectBootstrapReminder,
+  spawnExtractor,
+  ttlSweepProfiles,
+} from "./hook/handler.ts";
+import { setupWorkspaceResources } from "./hook/setup.ts";
+import { writeProfile } from "./lib/write-profile.ts";
+import { writePlaybook } from "./lib/write-playbook.ts";
+import { search } from "./lib/search.ts";
+import type { InferFn } from "./lib/openclaw-cli.ts";
+import { runConsolidation } from "./lib/consolidate.ts";
+import {
+  prepareSimpleCompletionModelForAgent,
+  completeWithPreparedSimpleCompletionModel,
+} from "openclaw/plugin-sdk/agent-runtime";
+
+export default definePluginEntry({
+  id: "reflexio-embedded",
+  name: "Reflexio Embedded",
+  description:
+    "Reflexio-style user profile and playbook extraction using Openclaw's native memory engine, hooks, and sub-agents.",
+  register(api) {
+    const log = api.logger;
+    const pluginDir = import.meta.dirname || __dirname;
+
+    // Load agent system prompts from the plugin's own directory
+    let extractorSystemPrompt: string | undefined;
+    try {
+      extractorSystemPrompt = fs.readFileSync(
+        path.join(pluginDir, "agents", "reflexio-extractor.md"),
+        "utf8",
+      );
+    } catch {
+      log.warn?.("[reflexio-embedded] could not load reflexio-extractor.md agent definition");
+    }
+
+    // before_prompt_build: workspace setup, TTL sweep, and system-prompt injection.
+    api.on("before_prompt_build", async () => {
+      try {
+        setupWorkspaceResources(pluginDir);
+      } catch (err) {
+        log.error?.(`[reflexio-embedded] workspace setup failed: ${err}`);
+      }
+      try {
+        await ttlSweepProfiles(resolveWorkspaceDir());
+      } catch (err) {
+        log.error?.(`[reflexio-embedded] ttl sweep failed: ${err}`);
+      }
+      return {
+        prependSystemContext: injectBootstrapReminder(),
+      };
+    });
+
+    // before_compaction: spawn extractor BEFORE the LLM compacts history so we
+    // still have the raw transcript to extract from.
+    api.on("before_compaction", async (event, ctx) => {
+      try {
+        await ttlSweepProfiles(ctx.workspaceDir);
+        await spawnExtractor({
+          runtime: api.runtime,
+          workspaceDir: ctx.workspaceDir,
+          sessionKey: ctx.sessionKey,
+          messages: event.messages,
+          sessionFile: event.sessionFile,
+          extraSystemPrompt: extractorSystemPrompt,
+          log,
+          reason: "before_compaction",
+        });
+      } catch (err) {
+        log.error?.(`[reflexio-embedded] before_compaction failed: ${err}`);
+      }
+    });
+
+    // before_reset: user ran /reset — flush current transcript to the extractor.
+    api.on("before_reset", async (event, ctx) => {
+      try {
+        await ttlSweepProfiles(ctx.workspaceDir);
+        await spawnExtractor({
+          runtime: api.runtime,
+          workspaceDir: ctx.workspaceDir,
+          sessionKey: ctx.sessionKey,
+          messages: event.messages,
+          sessionFile: event.sessionFile,
+          extraSystemPrompt: extractorSystemPrompt,
+          log,
+          reason: `before_reset:${event.reason ?? "unknown"}`,
+        });
+      } catch (err) {
+        log.error?.(`[reflexio-embedded] before_reset failed: ${err}`);
+      }
+    });
+
+    // session_end: fires when a session terminates for any reason (stop, idle,
+    // daily rollover, etc.).
+    api.on("session_end", async (event, ctx) => {
+      try {
+        await ttlSweepProfiles(ctx.workspaceDir);
+        await spawnExtractor({
+          runtime: api.runtime,
+          workspaceDir: ctx.workspaceDir,
+          sessionKey: ctx.sessionKey ?? event.sessionKey,
+          messages: undefined, // transcript lives on disk at this point
+          sessionFile: event.sessionFile,
+          extraSystemPrompt: extractorSystemPrompt,
+          log,
+          reason: `session_end:${event.reason ?? "unknown"}`,
+        });
+      } catch (err) {
+        log.error?.(`[reflexio-embedded] session_end failed: ${err}`);
+      }
+    });
+
+    // ──────────────────────────────────────────────────────────
+    // Agent tools — deterministic control flow for writes + search
+    // ──────────────────────────────────────────────────────────
+    const runner = api.runtime.system.runCommandWithTimeout;
+
+    // In-process LLM inference via SDK simple completion API.
+    // Bypasses sessions, lanes, and CLI — no lock contention.
+    const inferFn: InferFn = async (prompt) => {
+      try {
+        const cfg = api.runtime.config.loadConfig();
+        const prepared = await prepareSimpleCompletionModelForAgent({
+          cfg,
+          agentId: "main",
+        });
+        if ("error" in prepared) {
+          console.error(`[reflexio] inferFn: model preparation failed: ${prepared.error}`);
+          return null;
+        }
+        const result = await completeWithPreparedSimpleCompletionModel({
+          model: prepared.model,
+          auth: prepared.auth,
+          context: {
+            systemPrompt: "You are a concise assistant. Respond with only what is asked, no preamble.",
+            messages: [{ role: "user" as const, content: [{ type: "text" as const, text: prompt }], timestamp: Date.now() }],
+          },
+          options: { maxTokens: 800 },
+        });
+        const text = result.content
+          .filter((c: { type: string }) => c.type === "text")
+          .map((c: { type: string; text?: string }) => c.text ?? "")
+          .join("");
+        console.info(`[reflexio] inferFn: success, responseLen=${text.length}`);
+        return text.trim() || null;
+      } catch (err) {
+        console.error(`[reflexio] inferFn: failed: ${err}`);
+        return null;
+      }
+    };
+
+    const config = api.pluginConfig ?? {
+      dedup: { shallow_threshold: 0.4, top_k: 5 },
+      consolidation: { threshold_hours: 24 },
+    };
+
+    /**
+     * Resolve the agent's workspace directory.
+     * Mirrors Openclaw's resolveDefaultAgentWorkspaceDir logic:
+     *   ~/.openclaw/workspace (default)
+     *   ~/.openclaw/workspace-{profile} (if OPENCLAW_PROFILE is set)
+     */
+    function resolveWorkspaceDir(): string {
+      const profile = process.env.OPENCLAW_PROFILE?.trim();
+      if (profile && profile.toLowerCase() !== "default") {
+        return path.join(os.homedir(), ".openclaw", `workspace-${profile}`);
+      }
+      return path.join(os.homedir(), ".openclaw", "workspace");
+    }
+
+    api.registerTool({
+      name: "reflexio_write_profile",
+      description:
+        "Write a user profile to .reflexio/profiles/ with automatic query preprocessing, memory search, contradiction detection, dedup, and old-file cleanup. Returns the new file path.",
+      parameters: {
+        type: "object",
+        properties: {
+          slug: { type: "string", description: "kebab-case topic, e.g. diet-vegan" },
+          ttl: {
+            type: "string",
+            description: "one_day | one_week | one_month | one_quarter | one_year | infinity",
+          },
+          body: { type: "string", description: "1-3 sentences, one fact per profile" },
+        },
+        required: ["slug", "ttl", "body"],
+      },
+      optional: true,
+      async execute(_id: string, params: { slug: string; ttl: string; body: string }) {
+        const workspaceDir = resolveWorkspaceDir();
+        const filePath = await writeProfile({
+          slug: params.slug,
+          ttl: params.ttl,
+          body: params.body,
+          workspace: workspaceDir,
+          config: config.dedup,
+          runner,
+          inferFn,
+        });
+        return { content: [{ type: "text" as const, text: filePath }] };
+      },
+    });
+
+    api.registerTool({
+      name: "reflexio_write_playbook",
+      description:
+        "Write a playbook to .reflexio/playbooks/ with automatic dedup and contradiction detection. Returns the new file path.",
+      parameters: {
+        type: "object",
+        properties: {
+          slug: { type: "string", description: "kebab-case trigger summary, e.g. commit-no-trailers" },
+          body: {
+            type: "string",
+            description: "Playbook body with ## When, ## What, ## Why sections",
+          },
+        },
+        required: ["slug", "body"],
+      },
+      optional: true,
+      async execute(_id: string, params: { slug: string; body: string }) {
+        const workspaceDir = resolveWorkspaceDir();
+        const filePath = await writePlaybook({
+          slug: params.slug,
+          body: params.body,
+          workspace: workspaceDir,
+          config: config.dedup,
+          runner,
+          inferFn,
+        });
+        return { content: [{ type: "text" as const, text: filePath }] };
+      },
+    });
+
+    api.registerTool({
+      name: "reflexio_search",
+      description:
+        "Search .reflexio/ memory with automatic query preprocessing for better results. Returns JSON with results array.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "raw query — preprocessing is automatic" },
+        },
+        required: ["query"],
+      },
+      async execute(_id: string, params: { query: string }) {
+        const results = await search(params.query, 5, undefined, runner, inferFn);
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify({ results }, null, 2) }],
+        };
+      },
+    });
+
+    // ──────────────────────────────────────────────────────────
+    // Consolidation + Heartbeat
+    // ──────────────────────────────────────────────────────────
+    let consolidationRunning = false;
+
+    function getConsolidationStateFile(): string {
+      return path.join(resolveWorkspaceDir(), ".reflexio", "consolidation-state.json");
+    }
+
+    api.registerTool({
+      name: "reflexio_run_consolidation",
+      description:
+        "Run a full consolidation sweep: TTL sweep, cluster similar files, LLM-judge each cluster, write deduplicated facts, delete originals, reindex memory. Returns a summary.",
+      parameters: { type: "object", properties: {} },
+      optional: true,
+      async execute() {
+        if (consolidationRunning) {
+          return { content: [{ type: "text" as const, text: "Consolidation already running." }] };
+        }
+        consolidationRunning = true;
+        const workspaceDir = resolveWorkspaceDir();
+        const stateFile = getConsolidationStateFile();
+        // Fire and forget — don't block the agent's turn
+        runConsolidation({ workspaceDir, runner, inferFn }).then((result) => {
+          const state = { last_consolidation: new Date().toISOString() };
+          fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+          fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), "utf8");
+          console.info(`[reflexio] consolidation: background complete. wrote=${result.filesWritten} deleted=${result.filesDeleted}`);
+        }).catch((err) => {
+          console.error(`[reflexio] consolidation: background failed: ${err}`);
+        }).finally(() => {
+          consolidationRunning = false;
+        });
+        return { content: [{ type: "text" as const, text: "Consolidation started in background." }] };
+      },
+    });
+
+    api.registerTool({
+      name: "reflexio_consolidation_check",
+      description:
+        "Check if reflexio consolidation is due. Returns OK or ALERT. Called by the agent on heartbeat.",
+      parameters: { type: "object", properties: {} },
+      async execute() {
+        const thresholdHours = config.consolidation?.threshold_hours ?? 24;
+        try {
+          const state = JSON.parse(fs.readFileSync(getConsolidationStateFile(), "utf8"));
+          const elapsedMs = Date.now() - new Date(state.last_consolidation).getTime();
+          const elapsedHours = elapsedMs / 3_600_000;
+          if (elapsedHours < thresholdHours) {
+            const remaining = Math.round(thresholdHours - elapsedHours);
+            return { content: [{ type: "text" as const, text: `OK: Last consolidation ${Math.round(elapsedHours)}h ago. Next due in ${remaining}h.` }] };
+          }
+        } catch {
+          // no state file = never consolidated
+        }
+        return { content: [{ type: "text" as const, text: "ALERT: Consolidation due." }] };
+      },
+    });
+
+  },
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/plugin/lib/consolidate.ts

@@ -0,0 +1,233 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import { writeProfileFile, writePlaybookFile, deleteFile, type Ttl } from "./io.ts";
+import { memorySearch, reindexMemory, type CommandRunner, type InferFn } from "./openclaw-cli.ts";
+import { ttlSweepProfiles } from "../hook/handler.ts";
+
+export interface ConsolidationResult {
+  profilesClustered: number;
+  playbooksClustered: number;
+  filesWritten: number;
+  filesDeleted: number;
+}
+
+interface FileEntry {
+  id: string;
+  path: string;
+  content: string;
+  ttl?: string;
+  created?: string;
+}
+
+interface ConsolidationFact {
+  slug: string;
+  body: string;
+  source_ids: string[];
+}
+
+interface LlmConsolidationResult {
+  action: "keep_all" | "consolidate";
+  facts?: ConsolidationFact[];
+  ids_to_delete?: string[];
+  rationale?: string;
+}
+
+const CONSOLIDATION_PROMPT = `You consolidate a cluster of similar items (profiles or playbooks).
+
+**One fact per file.** Each output entry must contain exactly ONE atomic fact (1-2 sentences). Do NOT combine unrelated facts.
+
+Decisions:
+- "keep_all" — items are already distinct, no redundancy.
+- "consolidate" — deduplicate, resolve contradictions (most recent wins), split into individual facts.
+
+Answer with ONLY a JSON object:
+{"action": "keep_all"} or {"action": "consolidate", "facts": [{"slug": "kebab-case", "body": "single fact"}], "ids_to_delete": ["id1", "id2"], "rationale": "why"}
+
+Cluster:
+{cluster}`;
+
+/**
+ * Load all .md files from a .reflexio subdirectory, extracting frontmatter fields.
+ */
+function loadFiles(dir: string): FileEntry[] {
+  if (!fs.existsSync(dir)) return [];
+  const entries: FileEntry[] = [];
+  for (const name of fs.readdirSync(dir)) {
+    if (!name.endsWith(".md")) continue;
+    const full = path.join(dir, name);
+    let raw: string;
+    try {
+      raw = fs.readFileSync(full, "utf8");
+    } catch {
+      continue;
+    }
+    const idMatch = /^id:\s*(\S+)/m.exec(raw);
+    const ttlMatch = /^ttl:\s*(\S+)/m.exec(raw);
+    const createdMatch = /^created:\s*(\S+)/m.exec(raw);
+    const body = raw.split("---").slice(2).join("---").trim();
+    if (!idMatch || !body) continue;
+    entries.push({
+      id: idMatch[1],
+      path: full,
+      content: body,
+      ttl: ttlMatch?.[1],
+      created: createdMatch?.[1],
+    });
+  }
+  return entries;
+}
+
+/**
+ * Cluster files by similarity using memory search.
+ * Returns groups of 2+ related files. Each file appears in at most one cluster.
+ */
+async function clusterFiles(
+  files: FileEntry[],
+  type: "profile" | "playbook",
+  workspaceDir: string,
+  runner: CommandRunner
+): Promise<FileEntry[][]> {
+  const visited = new Set<string>();
+  const clusters: FileEntry[][] = [];
+
+  for (const file of files) {
+    if (visited.has(file.id)) continue;
+    visited.add(file.id);
+
+    const results = await memorySearch(file.content, 10, runner);
+    console.info(`[reflexio] clustering: file=${file.id} searchResults=${results.length} paths=[${results.map((r) => r.path).join(", ")}]`);
+    const typeDir = type === "profile" ? "/profiles/" : "/playbooks/";
+    const neighbors = results
+      .filter((r) => r.path.includes(typeDir))
+      .map((r) => {
+        // Match by path — memory search returns relative paths, loaded files have absolute
+        const absPath = r.path.startsWith("/") ? r.path : path.join(workspaceDir, r.path);
+        const match = files.find((f) => f.path === absPath);
+        if (!match) console.info(`[reflexio] clustering: no file match for path=${r.path} absPath=${absPath}`);
+        return match;
+      })
+      .filter((f): f is FileEntry => f !== undefined && f.id !== file.id && !visited.has(f.id));
+    console.info(`[reflexio] clustering: file=${file.id} neighbors=${neighbors.length} neighborIds=[${neighbors.map((n) => n.id).join(", ")}]`);
+
+    if (neighbors.length === 0) continue;
+
+    const cluster = [file, ...neighbors.slice(0, 9)];
+    for (const member of cluster) visited.add(member.id);
+    clusters.push(cluster);
+  }
+
+  return clusters;
+}
+
+/**
+ * Format cluster items for the LLM prompt.
+ */
+function formatCluster(cluster: FileEntry[]): string {
+  return cluster
+    .map((f) => `- id: ${f.id}\n  created: ${f.created ?? "unknown"}\n  content: ${f.content}`)
+    .join("\n\n");
+}
+
+/**
+ * Pick the most conservative TTL from a cluster of profiles.
+ */
+function pickSmallestTtl(cluster: FileEntry[]): Ttl {
+  const order: Ttl[] = ["one_day", "one_week", "one_month", "one_quarter", "one_year", "infinity"];
+  let smallest = order.length - 1;
+  for (const file of cluster) {
+    const idx = order.indexOf(file.ttl as Ttl);
+    if (idx >= 0 && idx < smallest) smallest = idx;
+  }
+  return order[smallest];
+}
+
+/**
+ * Run a full consolidation sweep: TTL sweep → cluster → LLM judge → write/delete.
+ * Uses inferFn (SDK simple completion) for LLM — bypasses lanes entirely.
+ */
+export async function runConsolidation(opts: {
+  workspaceDir: string;
+  runner: CommandRunner;
+  inferFn: InferFn;
+}): Promise<ConsolidationResult> {
+  const result: ConsolidationResult = { profilesClustered: 0, playbooksClustered: 0, filesWritten: 0, filesDeleted: 0 };
+  console.info(`[reflexio] consolidation: starting, workspace=${opts.workspaceDir}`);
+
+  // 1. TTL sweep
+  await ttlSweepProfiles(opts.workspaceDir);
+  console.info(`[reflexio] consolidation: TTL sweep done`);
+
+  // 2. Process profiles, then playbooks
+  for (const type of ["profile", "playbook"] as const) {
+    const dir = path.join(opts.workspaceDir, ".reflexio", type === "profile" ? "profiles" : "playbooks");
+    const files = loadFiles(dir);
+    console.info(`[reflexio] consolidation: loaded ${files.length} ${type} files`);
+    if (files.length < 2) continue;
+
+    const clusters = await clusterFiles(files, type, opts.workspaceDir, opts.runner);
+    console.info(`[reflexio] consolidation: found ${clusters.length} ${type} cluster(s) with >1 member`);
+
+    for (const cluster of clusters) {
+      console.info(`[reflexio] consolidation: processing ${type} cluster of ${cluster.length} items: ${cluster.map((f) => f.id).join(", ")}`);
+
+      const prompt = CONSOLIDATION_PROMPT.replace("{cluster}", formatCluster(cluster));
+      const llmResult = await opts.inferFn(prompt);
+
+      if (!llmResult) {
+        console.error(`[reflexio] consolidation: inferFn returned empty for cluster, skipping`);
+        continue;
+      }
+
+      let decision: LlmConsolidationResult;
+      try {
+        decision = JSON.parse(llmResult);
+      } catch (err) {
+        console.error(`[reflexio] consolidation: JSON parse failed: ${err}, skipping cluster`);
+        continue;
+      }
+
+      console.info(`[reflexio] consolidation: decision="${decision.action}" rationale="${(decision.rationale ?? "").slice(0, 100)}"`);
+
+      if (decision.action === "keep_all") continue;
+
+      if (decision.action === "consolidate" && decision.facts && decision.ids_to_delete) {
+        // Build id→file lookup for deletion
+        const idToFile = new Map(cluster.map((f) => [f.id, f]));
+
+        // Write new fact files
+        for (const fact of decision.facts) {
+          if (type === "profile") {
+            const sourceFiles = (fact.source_ids ?? []).map((id) => idToFile.get(id)).filter((f): f is FileEntry => f !== undefined);
+            const ttl = sourceFiles.length > 0 ? pickSmallestTtl(sourceFiles) : pickSmallestTtl(cluster);
+            const supersedes = fact.source_ids?.filter((id) => idToFile.has(id));
+            writeProfileFile({ slug: fact.slug, ttl, body: fact.body, supersedes, workspace: opts.workspaceDir });
+            result.filesWritten++;
+          } else {
+            const supersedes = fact.source_ids?.filter((id) => idToFile.has(id));
+            writePlaybookFile({ slug: fact.slug, body: fact.body, supersedes, workspace: opts.workspaceDir });
+            result.filesWritten++;
+          }
+        }
+
+        // Delete old files
+        for (const id of decision.ids_to_delete) {
+          const file = idToFile.get(id);
+          if (file) {
+            deleteFile(file.path);
+            result.filesDeleted++;
+          }
+        }
+
+        if (type === "profile") result.profilesClustered += cluster.length;
+        else result.playbooksClustered += cluster.length;
+      }
+    }
+  }
+
+  // 3. Reindex memory
+  await reindexMemory(opts.runner);
+  console.info(`[reflexio] consolidation: complete. wrote=${result.filesWritten} deleted=${result.filesDeleted}`);
+
+  return result;
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/plugin/lib/dedup.ts

@@ -0,0 +1,80 @@
+import type { InferFn } from "./openclaw-cli.ts";
+
+const PREPROCESS_PROMPT = `Rewrite the following text into a single descriptive but concise sentence that captures the core facts or topics. Expand with 2-3 important synonyms or related terms to improve search matching. Remove conversational filler. Return ONLY the rewritten text.
+
+Text: "{rawText}"`;
+
+const DEDUP_PROMPT = `EXISTING: "{existingContent}"
+NEW: "{newContent}"
+
+Compare these two entries:
+- If they are about different topics with no overlap, answer "keep_both".
+- Otherwise, merge them: resolve contradictions (NEW wins over EXISTING), deduplicate redundant statements, preserve all non-contradicted facts from both. Return the merged result as 1-3 concise sentences.
+
+Answer with ONLY a JSON object:
+{"decision": "keep_both"} or {"decision": "merge_and_resolve", "resolved": "<merged, deduped, resolved body>"}`;
+
+export type DedupResult =
+  | { decision: "keep_both" }
+  | { decision: "merge_and_resolve"; resolved: string };
+
+/**
+ * Rewrite raw text into a clean search query optimized for vector + FTS search.
+ * Falls back to raw text if openclaw infer is unavailable.
+ */
+export async function preprocessQuery(rawText: string, inferFn: InferFn): Promise<string> {
+  console.info(`[reflexio] preprocessQuery: inputLen=${rawText.length} input="${rawText.slice(0, 100)}"`);
+  const prompt = PREPROCESS_PROMPT.replace("{rawText}", rawText);
+  const result = await inferFn(prompt);
+  if (!result || result.trim().length === 0) {
+    console.info(`[reflexio] preprocessQuery: infer returned empty, falling back to raw text`);
+    return rawText;
+  }
+  console.info(`[reflexio] preprocessQuery: rewritten="${result.trim().slice(0, 120)}"`);
+  return result.trim();
+}
+
+/**
+ * Ask LLM to compare new content against existing content.
+ * Returns keep_both (different topics) or merge_and_resolve (with resolved body).
+ * Defaults to keep_both on any failure.
+ */
+export async function judgeDedup(
+  newContent: string,
+  existingContent: string,
+  inferFn: InferFn
+): Promise<DedupResult> {
+  console.info(`[reflexio] judgeDedup: existingLen=${existingContent.length} newLen=${newContent.length}`);
+  console.info(`[reflexio] judgeDedup: existing="${existingContent.slice(0, 100)}" new="${newContent.slice(0, 100)}"`);
+  const prompt = DEDUP_PROMPT
+    .replace("{existingContent}", existingContent)
+    .replace("{newContent}", newContent);
+
+  const result = await inferFn(prompt);
+  if (!result) {
+    console.info(`[reflexio] judgeDedup: infer returned empty, defaulting to keep_both`);
+    return { decision: "keep_both" };
+  }
+
+  console.info(`[reflexio] judgeDedup: raw result="${result.slice(0, 200)}"`);
+  try {
+    const parsed = JSON.parse(result);
+    if (parsed.decision === "merge_and_resolve" && typeof parsed.resolved === "string" && parsed.resolved.trim()) {
+      console.info(`[reflexio] judgeDedup: decision="merge_and_resolve" resolvedLen=${parsed.resolved.length}`);
+      return { decision: "merge_and_resolve", resolved: parsed.resolved.trim() };
+    }
+    console.info(`[reflexio] judgeDedup: decision="keep_both"`);
+    return { decision: "keep_both" };
+  } catch (err) {
+    console.error(`[reflexio] judgeDedup: JSON parse failed: ${err}, defaulting to keep_both`);
+    return { decision: "keep_both" };
+  }
+}
+
+/**
+ * Extract the `id:` value from a memory search snippet containing YAML frontmatter.
+ */
+export function extractId(snippet: string): string | null {
+  const match = /^id:\s*(\S+)/m.exec(snippet);
+  return match ? match[1] : null;
+}