omo-memory 0.1.13 → 0.1.14

package/README.md

@@ -106,6 +106,7 @@ The response contains a new `sessionId` and project metadata only. It deliberate
 ```
 
 This is local routing, not transcript scraping. OMO Memory does not automatically read full Codex or Grok transcripts. Hooks should record concise user actions, decisions, QA evidence, and handoffs; they should retrieve memory only when the user explicitly asks for OMO Memory or when the current user input can be matched to recorded intent.
+The packaged `scripts/omo-memory-user-prompt.mjs` helper is the supported UserPromptSubmit hook target for adapters that can invoke a command with the hook payload on stdin. It records only the current user prompt as a redacted `user_prompt` event, ignores assistant output, and exits successfully without blocking the host when OMO Memory is unavailable.
 
 Use explicit retrieval for memory reads:
 

package/dist/globalMemory.js

@@ -6,6 +6,22 @@ import { migrate } from "./memoryDb.js";
 import { resolveProjectContext } from "./projectContext.js";
 const STATE_DB_SUFFIX = join(".omo", "memory", "state.sqlite");
 const REQUIRED_TABLES = ["schema_meta", "projects", "events"];
+const PRUNED_DIR_NAMES = new Set([
+    ".cache",
+    ".git",
+    ".hg",
+    ".next",
+    ".pnpm-store",
+    ".turbo",
+    ".venv",
+    ".yarn",
+    "Library",
+    "build",
+    "dist",
+    "node_modules",
+    "target",
+    "vendor",
+]);
 export function initGlobalMemory(globalDbPath) {
     mkdirSync(dirname(globalDbPath), { recursive: true });
     const db = new Database(globalDbPath);
@@ -105,7 +121,7 @@ function findStateDbs(rootPath) {
         }
         for (const entry of entries) {
             const entryPath = join(path, entry.name);
-            if (entry.isDirectory())
+            if (entry.isDirectory() && shouldVisitDirectory(entry.name, entryPath))
                 visit(entryPath);
             else if (entry.isFile() && entryPath.endsWith(STATE_DB_SUFFIX))
                 dbPaths.push(entryPath);
@@ -114,6 +130,11 @@ function findStateDbs(rootPath) {
     visit(rootPath);
     return dbPaths.sort();
 }
+function shouldVisitDirectory(name, path) {
+    if (path.endsWith(join(".omo", "memory")))
+        return true;
+    return !PRUNED_DIR_NAMES.has(name);
+}
 function scanSourceDb(dbPath) {
     let db;
     try {

package/dist/graphTui.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { BoxRenderable, createCliRenderer, TextRenderable } from "@opentui/core";
+import { classCode, graphContent } from "./graphTuiCanvas.js";
 const SNAPSHOT_ENV = "OMO_MEMORY_GRAPH_TUI_SNAPSHOT";
 const COLORS = {
     background: "#101419",
@@ -76,7 +77,7 @@ export async function runGraphTui(options) {
         graph = loadGraph(state);
         state = { ...state, selectedId: graph.detail?.id ?? null };
         title.content = titleText(graph, state.options.query);
-        nodesText.content = nodesContent(graph);
+        nodesText.content = graphContent(graph);
         detailText.content = detailContent(graph);
         footer.content = "q quit | ArrowUp/ArrowDown/Tab select | Legend: D durable, W working, T temporary, E ephemeral";
         renderer.requestRender();
@@ -133,13 +134,7 @@ async function createGraphSnapshot(options) {
         dbPath: options.dbPath,
         ...(options.query === undefined ? {} : { query: options.query }),
     });
-    const details = graph.nodes
-        .map((node) => projectOntologyGraph({
-        dbPath: options.dbPath,
-        ...(options.query === undefined ? {} : { query: options.query }),
-        selectedId: node.id,
-    }).detail)
-        .filter((detail) => detail !== null);
+    const details = graph.detail === null ? [] : [graph.detail];
     return { graph, details };
 }
 function parseSnapshot(raw) {
@@ -160,23 +155,37 @@ function isGraphSnapshot(value) {
 }
 function loadGraph(state) {
     const selectedId = state.selectedId ?? state.snapshot.graph.detail?.id ?? state.snapshot.graph.nodes[0]?.id ?? null;
-    const detail = selectedId === null ? state.snapshot.graph.detail : (state.snapshot.details.find((item) => item.id === selectedId) ?? null);
+    const selectedNode = selectedId === null ? undefined : state.snapshot.graph.nodes.find((node) => node.id === selectedId);
+    const detail = selectedId === null ? state.snapshot.graph.detail : (state.snapshot.details.find((item) => item.id === selectedId) ?? nodeDetail(selectedNode) ?? null);
     return {
         ...state.snapshot.graph,
         nodes: state.snapshot.graph.nodes.map((node) => ({ ...node, selected: node.id === selectedId })),
         detail,
     };
 }
+function nodeDetail(node) {
+    if (node === undefined)
+        return null;
+    return {
+        id: node.id,
+        label: node.label,
+        kind: node.kind,
+        description: node.description,
+        aliases: node.aliases,
+        retentionClass: node.retentionClass,
+        score: node.score,
+        scoreLabel: node.scoreLabel,
+        refCount: node.refCount,
+        projectSpread: node.projectSpread,
+        firstSeen: node.firstSeen,
+        lastSeen: node.lastSeen,
+        project: node.project,
+    };
+}
 function titleText(graph, query) {
     const queryLabel = query === undefined ? "all concepts" : `query "${query}"`;
     return `OMO Ontology Graph - ${queryLabel} - ${graph.nodes.length} nodes / ${graph.edges.length} edges`;
 }
-function nodesContent(graph) {
-    if (graph.nodes.length === 0)
-        return graph.message ?? "No ontology graph data is available yet.";
-    const edges = graph.edges.map((edge) => `  ${edge.sourceId} -> ${edge.targetId} [${edge.label}]`);
-    return [...graph.nodes.map((node) => nodeLine(node)), "", "Relations", ...(edges.length === 0 ? ["  none in current filter"] : edges)].join("\n");
-}
 function detailContent(graph) {
     if (graph.detail === null)
         return graph.message ?? "No ontology graph data is available yet.";
@@ -203,8 +212,8 @@ function writeCaptureFrame(graph, query) {
     process.stdout.write([
         titleText(graph, query),
         "",
-        "Nodes",
-        nodesContent(graph),
+        "Graph",
+        graphContent(graph),
         "",
         "Detail",
         detailContent(graph),
@@ -213,20 +222,6 @@ function writeCaptureFrame(graph, query) {
         "",
     ].join("\n"));
 }
-function nodeLine(node) {
-    const marker = node.selected ? ">" : " ";
-    return `${marker} ${classCode(node.retentionClass)} ${node.label} (${node.kind}, ${node.scoreLabel}, refs ${node.refCount})`;
-}
-function classCode(retentionClass) {
-    const normalized = retentionClass.toLowerCase();
-    if (normalized === "durable")
-        return "D";
-    if (normalized === "temporary")
-        return "T";
-    if (normalized === "ephemeral")
-        return "E";
-    return "W";
-}
 function nextSelectedId(nodes, selectedId, keyName) {
     if (nodes.length === 0)
         return null;

package/dist/graphTuiCanvas.js

@@ -0,0 +1,104 @@
+const GRAPH_WIDTH = 66;
+const GRAPH_HEIGHT = 24;
+const NODE_LIMIT = 28;
+export function graphContent(graph) {
+    if (graph.nodes.length === 0)
+        return graph.message ?? "No ontology graph data is available yet.";
+    const drawnNodes = graph.nodes.slice(0, NODE_LIMIT);
+    const positions = layoutNodes(drawnNodes);
+    const rows = Array.from({ length: GRAPH_HEIGHT }, () => Array.from({ length: GRAPH_WIDTH }, () => " "));
+    for (const edge of graph.edges) {
+        const source = positions.get(edge.sourceId);
+        const target = positions.get(edge.targetId);
+        if (source === undefined || target === undefined)
+            continue;
+        drawEdge(rows, source, target);
+    }
+    for (const node of drawnNodes) {
+        const position = positions.get(node.id);
+        if (position === undefined)
+            continue;
+        drawNode(rows, node, position);
+    }
+    const graphLines = rows.map((row) => row.join("").trimEnd());
+    const legend = drawnNodes.map((node) => nodeLine(node));
+    return [...graphLines, "", "Nodes", ...legend, "", "Relations", ...relationLines(graph, positions)].join("\n");
+}
+export function nodeLine(node) {
+    const marker = node.selected ? ">" : " ";
+    return `${marker} ${classCode(node.retentionClass)} ${node.label} (${node.kind}, ${node.scoreLabel}, refs ${node.refCount})`;
+}
+export function classCode(retentionClass) {
+    const normalized = retentionClass.toLowerCase();
+    if (normalized === "durable")
+        return "D";
+    if (normalized === "temporary")
+        return "T";
+    if (normalized === "ephemeral")
+        return "E";
+    return "W";
+}
+function layoutNodes(nodes) {
+    const centerX = Math.floor(GRAPH_WIDTH / 2);
+    const centerY = Math.floor(GRAPH_HEIGHT / 2);
+    const radiusX = Math.max(8, Math.floor(GRAPH_WIDTH / 2) - 8);
+    const radiusY = Math.max(4, Math.floor(GRAPH_HEIGHT / 2) - 3);
+    const positions = new Map();
+    nodes.forEach((node, index) => {
+        const angle = (2 * Math.PI * index) / Math.max(1, nodes.length);
+        const scorePull = Math.max(0.55, 1 - Math.min(90, node.score) / 220);
+        positions.set(node.id, {
+            x: clamp(Math.round(centerX + Math.cos(angle) * radiusX * scorePull), 2, GRAPH_WIDTH - 3),
+            y: clamp(Math.round(centerY + Math.sin(angle) * radiusY * scorePull), 1, GRAPH_HEIGHT - 2),
+        });
+    });
+    return positions;
+}
+function drawEdge(rows, source, target) {
+    const steps = Math.max(Math.abs(target.x - source.x), Math.abs(target.y - source.y), 1);
+    for (let index = 1; index < steps; index += 1) {
+        const x = Math.round(source.x + ((target.x - source.x) * index) / steps);
+        const y = Math.round(source.y + ((target.y - source.y) * index) / steps);
+        const row = rows[y];
+        const current = row?.[x];
+        if (row === undefined || current === undefined || current !== " ")
+            continue;
+        row[x] = edgeGlyph(source, target);
+    }
+}
+function edgeGlyph(source, target) {
+    const dx = target.x - source.x;
+    const dy = target.y - source.y;
+    if (Math.abs(dx) > Math.abs(dy) * 2)
+        return "-";
+    if (Math.abs(dy) > Math.abs(dx) * 2)
+        return "|";
+    return dx * dy > 0 ? "\\" : "/";
+}
+function drawNode(rows, node, point) {
+    const glyph = node.selected ? "●" : classCode(node.retentionClass);
+    const label = `${glyph}${shortLabel(node.label)}`;
+    const startX = clamp(point.x - Math.floor(label.length / 2), 0, Math.max(0, GRAPH_WIDTH - label.length));
+    for (let index = 0; index < label.length; index += 1) {
+        const row = rows[point.y];
+        if (row === undefined)
+            continue;
+        row[startX + index] = label[index] ?? " ";
+    }
+}
+function shortLabel(label) {
+    const compact = label.replace(/\s+/g, " ").trim();
+    return compact.length <= 11 ? compact : compact.slice(0, 10);
+}
+function relationLines(graph, positions) {
+    const visible = graph.edges.filter((edge) => positions.has(edge.sourceId) && positions.has(edge.targetId)).slice(0, 12);
+    if (visible.length === 0)
+        return ["  none in current filter"];
+    return visible.map((edge) => `  ${nodeLabel(graph, edge.sourceId)} -> ${nodeLabel(graph, edge.targetId)} [${edge.label}]`);
+}
+function nodeLabel(graph, nodeId) {
+    return graph.nodes.find((node) => node.id === nodeId)?.label ?? nodeId;
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}

package/dist/ontologyGraph.js

@@ -1,4 +1,5 @@
 import { migrate, openMemoryDb } from "./memoryDb.js";
+import { readGraphEdges } from "./ontologyGraphEdges.js";
 import { redactSecrets, sanitizeGitRemote } from "./privacy.js";
 function isRecord(value) {
     return value !== null && typeof value === "object";
@@ -55,21 +56,6 @@ function parseConceptRow(value) {
         gitRemote: nullableText(value["gitRemote"]),
     };
 }
-function parseRelationRow(value) {
-    if (!isRecord(value)) {
-        throw new Error("invalid relation row");
-    }
-    return {
-        id: text(value["id"]),
-        projectId: text(value["projectId"]),
-        sourceId: text(value["sourceId"]),
-        targetId: text(value["targetId"]),
-        relation: text(value["relation"]),
-        weight: numberValue(value["weight"]),
-        repoRoot: text(value["repoRoot"]),
-        gitRemote: nullableText(value["gitRemote"]),
-    };
-}
 function matchesQuery(row, query) {
     const haystack = `${row.label}\n${row.description ?? ""}\n${row.aliases.join("\n")}`.toLowerCase();
     return haystack.includes(query);
@@ -88,6 +74,8 @@ function toNode(row, selectedId) {
         scoreLabel: `${score} ${retentionClass}`,
         refCount: Math.round(row.refCount),
         projectSpread: Math.round(row.projectSpread),
+        firstSeen: row.firstSeen,
+        lastSeen: row.lastSeen,
         project: projectFrom(row),
         selected: selectedId === row.id,
     };
@@ -111,19 +99,6 @@ function toDetail(row) {
         project: projectFrom(row),
     };
 }
-function toEdge(row) {
-    const weight = Number(row.weight.toFixed(2));
-    const relation = redactSecrets(row.relation);
-    return {
-        id: row.id,
-        sourceId: row.sourceId,
-        targetId: row.targetId,
-        relation,
-        label: `${relation} ${weight.toFixed(2)}`,
-        weight,
-        project: projectFrom(row),
-    };
-}
 export function projectOntologyGraph(options) {
     const db = openMemoryDb(options.dbPath);
     try {
@@ -148,21 +123,9 @@ export function projectOntologyGraph(options) {
         const selectedId = options.selectedId && conceptIds.has(options.selectedId) ? options.selectedId : (conceptRows[0]?.id ?? null);
         const nodes = conceptRows.map((row) => toNode(row, selectedId));
         const selectedRow = selectedId === null ? undefined : conceptRows.find((row) => row.id === selectedId);
-        const relationRows = db
-            .prepare(`
-        SELECT r.id, r.project_id AS projectId, r.source_id AS sourceId, r.target_id AS targetId,
-          r.relation, COALESCE(r.weight, 1) AS weight, p.repo_root AS repoRoot, p.git_remote AS gitRemote
-        FROM relations r
-        JOIN projects p ON p.id = r.project_id
-        WHERE r.source_type = 'concept' AND r.target_type = 'concept' AND r.valid_to IS NULL
-        ORDER BY lower(r.relation) ASC, r.id ASC
-      `)
-            .all()
-            .map(parseRelationRow)
-            .filter((row) => conceptIds.has(row.sourceId) && conceptIds.has(row.targetId));
         return {
             nodes,
-            edges: relationRows.map(toEdge),
+            edges: readGraphEdges(db, conceptIds),
             detail: selectedRow === undefined ? null : toDetail(selectedRow),
             message: nodes.length === 0 ? "No ontology graph data is available yet." : null,
         };

package/dist/ontologyGraphEdges.js

@@ -0,0 +1,86 @@
+import { redactSecrets, sanitizeGitRemote } from "./privacy.js";
+export function readGraphEdges(db, conceptIds) {
+    const relationRows = db
+        .prepare(`
+      SELECT r.id, r.project_id AS projectId, r.source_id AS sourceId, r.target_id AS targetId,
+        r.relation, COALESCE(r.weight, 1) AS weight, p.repo_root AS repoRoot, p.git_remote AS gitRemote
+      FROM relations r
+      JOIN projects p ON p.id = r.project_id
+      WHERE r.source_type = 'concept' AND r.target_type = 'concept' AND r.valid_to IS NULL
+      ORDER BY lower(r.relation) ASC, r.id ASC
+    `)
+        .all()
+        .map(parseRelationRow)
+        .filter((row) => conceptIds.has(row.sourceId) && conceptIds.has(row.targetId));
+    const edgeRows = relationRows.length === 0 ? readCoOccurrenceRows(db, conceptIds) : relationRows;
+    return edgeRows.map(toEdge);
+}
+function readCoOccurrenceRows(db, conceptIds) {
+    return db
+        .prepare(`
+      SELECT 'co:' || a.target_id || ':' || b.target_id AS id,
+        a.project_id AS projectId, a.target_id AS sourceId, b.target_id AS targetId,
+        'co_occurs' AS relation, COUNT(*) AS weight, p.repo_root AS repoRoot, p.git_remote AS gitRemote
+      FROM memory_references a
+      JOIN memory_references b
+        ON b.project_id = a.project_id
+        AND b.source_type = a.source_type
+        AND b.source_id = a.source_id
+        AND b.target_type = 'concept'
+        AND a.target_id < b.target_id
+      JOIN projects p ON p.id = a.project_id
+      WHERE a.source_type = 'event' AND a.target_type = 'concept'
+      GROUP BY a.project_id, a.target_id, b.target_id
+      ORDER BY COUNT(*) DESC, a.target_id ASC, b.target_id ASC
+      LIMIT 160
+    `)
+        .all()
+        .map(parseRelationRow)
+        .filter((row) => conceptIds.has(row.sourceId) && conceptIds.has(row.targetId));
+}
+function parseRelationRow(value) {
+    if (!isRecord(value))
+        throw new Error("invalid relation row");
+    return {
+        id: text(value["id"]),
+        projectId: text(value["projectId"]),
+        sourceId: text(value["sourceId"]),
+        targetId: text(value["targetId"]),
+        relation: text(value["relation"]),
+        weight: numberValue(value["weight"]),
+        repoRoot: text(value["repoRoot"]),
+        gitRemote: nullableText(value["gitRemote"]),
+    };
+}
+function toEdge(row) {
+    const weight = Number(row.weight.toFixed(2));
+    const relation = redactSecrets(row.relation);
+    return {
+        id: row.id,
+        sourceId: row.sourceId,
+        targetId: row.targetId,
+        relation,
+        label: `${relation} ${weight.toFixed(2)}`,
+        weight,
+        project: projectFrom(row),
+    };
+}
+function projectFrom(row) {
+    return {
+        id: row.projectId,
+        repoRoot: redactSecrets(row.repoRoot),
+        gitRemote: sanitizeGitRemote(row.gitRemote),
+    };
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object";
+}
+function text(value) {
+    return typeof value === "string" ? value : String(value ?? "");
+}
+function nullableText(value) {
+    return value === null || value === undefined ? null : text(value);
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : Number(value ?? 0);
+}

package/docs/adapter-integration.md

@@ -118,14 +118,14 @@ During the session, hooks should write concise user-action summaries, task state
 }
 ```
 
-This package is the local MCP-to-SQLite router. It does not scrape host transcripts or centralize cloud state. Hosts and adapters must call the MCP tools at their own lifecycle points.
+This package is the local MCP-to-SQLite router. It does not scrape host transcripts, store assistant output, or centralize cloud state. Hosts and adapters must call the MCP tools at their own lifecycle points.
 
 Retrieval is opt-in or intent-gated:
 
 - Use `memory_recent_events` only when the user explicitly asks for recent OMO Memory context.
 - Use `memory_recall_events` when the current user input has a concrete query that can be matched to recorded summaries, decisions, or evidence.
 - Do not automatically attach the last session to every user prompt.
-- Do not store raw user prompts by default; record concise, redacted action summaries.
+- To preserve user intent across sessions, adapters may invoke the packaged `scripts/omo-memory-user-prompt.mjs` UserPromptSubmit helper with the hook payload on stdin. The helper records only the current user prompt as a redacted `user_prompt` event and ignores assistant output.
 
 Use these tools:
 

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "omo-memory",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Host-neutral local SQLite memory and session ledger for OMO adapters, exposed through CLI and MCP.",
   "type": "module",
   "files": [
     "dist",
     "docs",
+    "scripts/omo-memory-user-prompt.mjs",
     "README.md"
   ],
   "bin": {
@@ -32,9 +33,10 @@
     "start": "node dist/cli.js",
     "prepack": "npm run build",
     "presmoke": "npm run build",
-    "smoke": "npm run smoke:cli && npm run smoke:mcp",
+    "smoke": "npm run smoke:cli && npm run smoke:mcp && npm run smoke:hook",
     "smoke:cli": "node scripts/smoke-cli.mjs",
     "smoke:mcp": "node scripts/smoke-mcp.mjs",
+    "smoke:hook": "node scripts/verify-user-prompt-hook.mjs",
     "mcp": "node dist/cli.js mcp",
     "issue:epic": "node scripts/create-epic-issue.mjs"
   },

package/scripts/omo-memory-user-prompt.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+
+const MAX_SUMMARY_CHARS = 4000;
+
+const host = process.env["OMO_MEMORY_HOST"] ?? "unknown";
+const adapter = process.env["OMO_MEMORY_ADAPTER"] ?? "unknown";
+
+const input = readStdin();
+const payload = parseJson(input);
+const prompt = extractPrompt(payload);
+
+if (prompt === null) process.exit(0);
+
+const summary = truncate(prompt.replace(/\s+/g, " ").trim(), MAX_SUMMARY_CHARS);
+if (summary.length === 0) process.exit(0);
+
+const hookSessionId = readString(payload, "sessionId") ?? readString(payload, "session_id");
+const workspaceRoot = readString(payload, "workspaceRoot") ?? readString(payload, "cwd");
+const metadata = {
+  source: "hook",
+  hookEventName: readString(payload, "hookEventName") ?? process.env["GROK_HOOK_EVENT"] ?? process.env["CODEX_HOOK_EVENT"] ?? "UserPromptSubmit",
+  host,
+  adapter,
+  ...(hookSessionId === null ? {} : { hookSessionId }),
+  ...(workspaceRoot === null ? {} : { workspaceRoot }),
+};
+
+const args = ["event", "record", "--type", "user_prompt", "--summary", summary, "--payload-json", JSON.stringify(metadata)];
+
+const result = runOmoMemory(args) ?? runNpx(args);
+if (result === undefined || result.status !== 0) process.exit(0);
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch (error) {
+    if (error instanceof Error) process.exit(0);
+    throw error;
+  }
+}
+
+function parseJson(raw) {
+  if (raw.trim().length === 0) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : {};
+  } catch (error) {
+    if (error instanceof SyntaxError) return {};
+    throw error;
+  }
+}
+
+function extractPrompt(value) {
+  if (!isRecord(value)) return null;
+  for (const key of ["prompt", "userPrompt", "user_prompt", "message", "text", "input"]) {
+    const direct = readString(value, key);
+    if (direct !== null) return direct;
+  }
+  const nestedPrompt =
+    readNestedString(value, ["toolInput", "prompt"]) ?? readNestedString(value, ["payload", "prompt"]) ?? readNestedString(value, ["data", "prompt"]);
+  if (nestedPrompt !== null) return nestedPrompt;
+  return null;
+}
+
+function readNestedString(value, path) {
+  let cursor = value;
+  for (const key of path) {
+    if (!isRecord(cursor)) return null;
+    cursor = cursor[key];
+  }
+  return typeof cursor === "string" ? cursor : null;
+}
+
+function readString(value, key) {
+  const item = value[key];
+  return typeof item === "string" ? item : null;
+}
+
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength - 15)} [TRUNCATED]`;
+}
+
+function runOmoMemory(args) {
+  const command = process.env["OMO_MEMORY_CLI"] ?? "omo-memory";
+  return run(command, args);
+}
+
+function runNpx(args) {
+  return run("npx", ["-y", "omo-memory", ...args]);
+}
+
+function run(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 5000,
+  });
+  if (result.error?.code === "ENOENT") return undefined;
+  return result;
+}
+
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}