@bcmyguest/openmem 0.6.3 → 0.8.0

package/cli/coding-agent/session-facade.mjs

@@ -1,6 +1,7 @@
 import { callUnifiedTool } from "../mcp/memory-facade.mjs";
+import { recallBlock } from "./recall-frame.mjs";
 
-const HOOK_CONTEXT_MAX_CHARS = 8000;
+export const HOOK_CONTEXT_MAX_CHARS = 8000;
 
 function toolText(result) {
   const t = result?.content?.[0]?.text;
@@ -15,7 +16,7 @@ function toolText(result) {
   }
 }
 
-function recallText(result, limit) {
+function recallText(result, limit, maxChars = HOOK_CONTEXT_MAX_CHARS) {
   try {
     const value = JSON.parse(result?.content?.[0]?.text || "");
     const hits = value?.result?.results;
@@ -24,17 +25,25 @@ function recallText(result, limit) {
         .map((hit) => hit?.text ?? hit?.memory ?? hit?.content ?? "")
         .filter((item) => typeof item === "string" && item.trim())
         .join("\n\n")
-        .slice(0, HOOK_CONTEXT_MAX_CHARS);
+        .slice(0, maxChars);
     }
   } catch { /* use generic result text */ }
-  return toolText(result).slice(0, HOOK_CONTEXT_MAX_CHARS);
+  return toolText(result).slice(0, maxChars);
+}
+
+/**
+ * Hook or plugin recall text framed as untrusted data (recall-frame.mjs), at most HOOK_CONTEXT_MAX_CHARS
+ * characters frame included; "" for empty text.
+ */
+export function hookRecallBlock(text) {
+  return recallBlock(String(text ?? "").trim(), HOOK_CONTEXT_MAX_CHARS);
 }
 
 /** @param {ReturnType<import("../mcp/context.mjs").resolveMcpContext>} ctx */
-export async function sessionRecall(ctx, { query, bank, limit = 10, budget, maxTokens }, fetchFn = fetch) {
+export async function sessionRecall(ctx, { query, bank, limit = 10, budget, maxTokens, maxChars }, fetchFn = fetch) {
   const out = await callUnifiedTool(ctx, "memory_recall", { query, bank, limit, budget, maxTokens }, fetchFn);
   if (out.isError) throw new Error(toolText(out));
-  return recallText(out, limit);
+  return recallText(out, limit, maxChars);
 }
 
 /** @param {ReturnType<import("../mcp/context.mjs").resolveMcpContext>} ctx */
@@ -60,3 +69,18 @@ export async function sessionReflectOrSearch(ctx, { query, bank, limit = 12 }, f
   }
   return body;
 }
+
+/**
+ * True when the bank has pending or processing ingest (`memory_status` active > 0).
+ * Synchronous providers (mem0) and providers without ingest status (Cognee) report false.
+ */
+export async function sessionIngestActive(ctx, { bank }, fetchFn = fetch) {
+  const out = await callUnifiedTool(ctx, "memory_status", { bank }, fetchFn);
+  if (out.isError) throw new Error(toolText(out));
+  try {
+    const status = JSON.parse(out?.content?.[0]?.text || "");
+    return status?.supported !== false && Number(status?.active) > 0;
+  } catch {
+    return false;
+  }
+}

package/cli/coding-agent/toml-edit.mjs

@@ -0,0 +1,161 @@
+/**
+ * Text-preserving TOML edits: locate statements (table headers and key/value pairs) with a
+ * small lexer that understands strings, multi-line strings, comments and multi-line arrays,
+ * so an edit removes exactly one entry's text and leaves every other byte alone.
+ */
+
+const BARE_KEY = /[A-Za-z0-9_-]/;
+
+/** Offset just past the line break at or after `i` (or the end of the text). */
+function lineEnd(text, i) {
+  const nl = text.indexOf("\n", i);
+  return nl < 0 ? text.length : nl + 1;
+}
+
+/** Offset after the string starting at `i` (any of the four TOML string forms). */
+function skipString(text, i) {
+  const quote = text[i];
+  const triple = text.startsWith(quote.repeat(3), i);
+  if (triple) {
+    let j = i + 3;
+    while (j < text.length) {
+      if (quote === '"' && text[j] === "\\") { j += 2; continue; }
+      if (text.startsWith(quote.repeat(3), j)) {
+        j += 3;
+        // Up to two quotes may directly precede the closing delimiter.
+        for (let k = 0; k < 2 && text[j] === quote; k++) j++;
+        return j;
+      }
+      j++;
+    }
+    throw new SyntaxError("unterminated multi-line string");
+  }
+  let j = i + 1;
+  while (j < text.length && text[j] !== "\n") {
+    if (quote === '"' && text[j] === "\\") { j += 2; continue; }
+    if (text[j] === quote) return j + 1;
+    j++;
+  }
+  throw new SyntaxError("unterminated string");
+}
+
+/** Parse a dotted key at `i`; returns the segments and the offset after the key. */
+function parseKey(text, i) {
+  const parts = [];
+  for (;;) {
+    while (text[i] === " " || text[i] === "\t") i++;
+    if (text[i] === '"' || text[i] === "'") {
+      const end = skipString(text, i);
+      const raw = text.slice(i, end);
+      if (raw[0] === "'") parts.push(raw.slice(1, -1));
+      else {
+        try { parts.push(JSON.parse(raw)); } catch { parts.push(raw.slice(1, -1)); }
+      }
+      i = end;
+    } else {
+      const start = i;
+      while (i < text.length && BARE_KEY.test(text[i])) i++;
+      if (i === start) throw new SyntaxError(`bad key at offset ${start}`);
+      parts.push(text.slice(start, i));
+    }
+    while (text[i] === " " || text[i] === "\t") i++;
+    if (text[i] !== ".") return { parts, end: i };
+    i++;
+  }
+}
+
+/** Offset after a value starting at `i`, through the end of its last line (comment included). */
+function skipValue(text, i) {
+  let depth = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === '"' || c === "'") { i = skipString(text, i); continue; }
+    if (c === "#") { i = text.indexOf("\n", i); if (i < 0) return text.length; continue; }
+    if (c === "[" || c === "{") depth++;
+    else if (c === "]" || c === "}") depth--;
+    else if (c === "\n" && depth <= 0) return i + 1;
+    i++;
+  }
+  return text.length;
+}
+
+/**
+ * Statements of a TOML document in order: `{ kind: "table" | "array-table" | "kv", path, start, end }`.
+ * `path` is the full key path (a key/value pair includes its table's path); `start` is the
+ * offset of the statement's line and `end` the offset after its last line.
+ * @param {string} text
+ */
+export function tomlStatements(text) {
+  const out = [];
+  let table = [];
+  let i = 0;
+  while (i < text.length) {
+    const start = i;
+    while (text[i] === " " || text[i] === "\t" || text[i] === "\r") i++;
+    if (i >= text.length) break;
+    if (text[i] === "\n") { i++; continue; }
+    if (text[i] === "#") { i = lineEnd(text, i); continue; }
+    if (text[i] === "[") {
+      const array = text[i + 1] === "[";
+      const key = parseKey(text, i + (array ? 2 : 1));
+      table = key.parts;
+      out.push({ kind: array ? "array-table" : "table", path: table, start, end: lineEnd(text, key.end) });
+      i = lineEnd(text, key.end);
+      continue;
+    }
+    const key = parseKey(text, i);
+    if (text[key.end] !== "=") throw new SyntaxError(`expected "=" at offset ${key.end}`);
+    const end = skipValue(text, key.end + 1);
+    out.push({ kind: "kv", path: [...table, ...key.parts], start, end });
+    i = end;
+  }
+  return out;
+}
+
+const startsWith = (pathParts, prefix) => prefix.every((p, k) => pathParts[k] === p);
+
+/**
+ * Text spans to delete so no statement at or under `prefix` remains: whole tables (header through
+ * the table's last key/value pair, so comments that follow it stay) and single key/value pairs.
+ * @param {string} text
+ * @param {string[]} prefix
+ * @returns {{ start: number, end: number }[]}
+ */
+export function tomlSpansUnder(text, prefix) {
+  const statements = tomlStatements(text);
+  const spans = [];
+  for (let s = 0; s < statements.length; s++) {
+    const st = statements[s];
+    if (st.kind === "kv") {
+      if (startsWith(st.path, prefix)) spans.push({ start: st.start, end: st.end });
+      continue;
+    }
+    if (!startsWith(st.path, prefix)) continue;
+    let end = st.end;
+    let k = s + 1;
+    for (; k < statements.length && statements[k].kind === "kv"; k++) end = statements[k].end;
+    spans.push({ start: st.start, end });
+    s = k - 1;
+  }
+  return spans;
+}
+
+/** Remove `spans` from `text`, also dropping blank lines a removal would leave doubled. */
+export function removeSpans(text, spans) {
+  let out = text;
+  for (const { start, end } of [...spans].sort((a, b) => b.start - a.start)) {
+    let stop = end;
+    const before = out.slice(0, start);
+    if (start === 0 || /\n[ \t\r]*\n$/.test(before)) {
+      const m = /^(?:[ \t\r]*\n)+/.exec(out.slice(stop));
+      if (m) stop += m[0].length;
+    }
+    out = out.slice(0, start) + out.slice(stop);
+  }
+  return out;
+}
+
+/** Remove every statement at or under `prefix` (e.g. `["mcp_servers", "hindsight"]`). */
+export function removeTomlPath(text, prefix) {
+  return removeSpans(text, tomlSpansUnder(text, prefix));
+}

package/cli/context-management.mjs

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * Context management (smart compaction) per agent: `[context_proxy.agents]` in config.toml (a missing key
+ * follows `[context_proxy] enabled`; with neither set, opencode2 is on and the others off), the agent wiring (install-coding-agent) and the compose
+ * `context-proxy` service. Shared by the setup wizard step, install-coding-agent and `openmem context`.
+ */
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { contextRoot } from "./coding-agent/context-store.mjs";
+import { proxyCodeVersion, summarizeEvents } from "./coding-agent/session-db.mjs";
+import { agentsPointedAtContextProxy, ensureContextProxyKey, probeContextProxy } from "./coding-agent/install-context-proxy.mjs";
+import { isMainModule } from "./is-main.mjs";
+import { resolveStackRoot } from "./stack.mjs";
+import {
+  CONTEXT_AGENT_KEYS,
+  contextAgentsFromPmConfig,
+  contextProxyFromPmConfig,
+  loadPmConfig,
+  updatePmConfigContextAgents,
+} from "../wizard/lib/pm-config.mjs";
+
+/** Compose service and profile name (compose.yaml). */
+export const CONTEXT_PROXY_SERVICE = "context-proxy";
+/**
+ * Agents whose "on" needs the proxy service. Codex goes through LiteLLM's ChatGPT-subscription pass-through,
+ * which the pinned dev image has (PR #41522; docs/compatibility.md, footnote 9).
+ */
+export const SERVICE_AGENT_KEYS = ["claude-code", "opencode1", "codex"];
+/** How each config key is served. */
+export const CONTEXT_AGENT_ROUTE = {
+  "claude-code": "context-proxy",
+  opencode1: "context-proxy",
+  codex: "context-proxy (ChatGPT login, /backend-api/codex)",
+  opencode2: "native plugin",
+};
+const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const BIN = "openmem context";
+
+const HELP = `${BIN}: turn context management (smart compaction) on or off per agent
+
+Usage:
+  ${BIN} on  [--dry-run] [--agents a,b]   save [context_proxy.agents] <agent> = true, re-run
+                                           install-coding-agent (starts the context-proxy service
+                                           when a proxy-routed agent is on)
+  ${BIN} off [--dry-run] [--agents a,b]   save <agent> = false, re-run install-coding-agent (stops
+                                           the service when no proxy-routed agent is on)
+  ${BIN} status [--json]                  per-agent values, proxy health, agents pointed at it, and
+                                           the last 24 h of trims and fail-opens from the session store
+
+Agents: ${CONTEXT_AGENT_KEYS.join(", ")} (default: all). claude-code, opencode1 and codex go through
+the context-proxy service (codex keeps its ChatGPT login); opencode2 trims in its own plugin (on when
+config sets neither its key nor enabled).
+Docs: docs/context-management.md`;
+
+/** True when any agent that needs the service resolves on. */
+export function proxyServiceNeeded(agents) {
+  return SERVICE_AGENT_KEYS.some((k) => agents[k]);
+}
+
+/**
+ * Key file and store directories the compose service needs before `up`
+ * (env_file, and a bind mount with create_host_path: false).
+ */
+export function prepareContextProxyFiles(home, env = process.env) {
+  ensureContextProxyKey(home);
+  for (const sub of ["sessions", "blobs"]) fs.mkdirSync(path.join(contextRoot(home, env), sub), { recursive: true, mode: 0o700 });
+}
+
+/**
+ * True when compose reports a container for the service.
+ * @param {string[]} baseArgs `docker` arguments up to (not including) the compose subcommand
+ * @param {{ cwd?: string, env?: Record<string, string | undefined> }} [opts]
+ * @param {typeof spawnSync} [spawn]
+ */
+export function contextProxyRunning(baseArgs, opts = {}, spawn = spawnSync) {
+  const r = spawn("docker", [...baseArgs, "ps", "-q", CONTEXT_PROXY_SERVICE], { encoding: "utf8", ...opts });
+  return r.status === 0 && String(r.stdout || "").trim() !== "";
+}
+
+/** `docker` arguments for compose calls on the context-proxy profile from the stack root. */
+export function contextComposeArgs({ project, stackRoot }) {
+  return ["compose", "-p", project, ...(stackRoot ? ["--project-directory", stackRoot] : []), "--profile", CONTEXT_PROXY_SERVICE];
+}
+
+/**
+ * Start the service (`on`) or stop it when it runs and no agent points at it (`!on`). Skipped when the
+ * stack root has no compose.yaml. Returns what happened.
+ * @param {{ home: string, stackRoot?: string, project: string, on: boolean, dry?: boolean, env?: NodeJS.ProcessEnv,
+ *   spawn?: typeof spawnSync, log: { info: (m: string) => void, warn: (m: string) => void } }} opts
+ * @returns {"started"|"stopped"|"kept"|"not-running"|"no-stack"|"failed"|"dry-run"}
+ */
+export function ensureContextProxyService({ home, stackRoot, project, on, dry = false, env = process.env, spawn = spawnSync, log }) {
+  if (!stackRoot || !fs.existsSync(path.join(stackRoot, "compose.yaml"))) return "no-stack";
+  const base = contextComposeArgs({ project, stackRoot });
+  const opts = { cwd: stackRoot, env: { ...env } };
+  const run = (args) => {
+    const text = `docker ${args.join(" ")}`;
+    if (dry) {
+      log.info(`[dry-run] ${text}`);
+      return 0;
+    }
+    log.info(text);
+    return spawn("docker", args, { stdio: "inherit", ...opts }).status ?? 1;
+  };
+  if (on) {
+    if (!dry) prepareContextProxyFiles(home, env);
+    return run([...base, "up", "-d", CONTEXT_PROXY_SERVICE]) === 0 ? (dry ? "dry-run" : "started") : "failed";
+  }
+  if (!contextProxyRunning(base, opts, spawn)) return "not-running";
+  const pointed = dry ? [] : agentsPointedAtContextProxy(home);
+  if (pointed.length) {
+    log.warn(`context-proxy left running: ${pointed.join(", ")} still point at it`);
+    return "kept";
+  }
+  return run([...base, "stop", CONTEXT_PROXY_SERVICE]) === 0 ? (dry ? "dry-run" : "stopped") : "failed";
+}
+
+/** Proxy code version of the checkout the compose service mounts (stack root, else this package), or null. */
+function checkoutProxyVersion(stackRoot) {
+  for (const root of [stackRoot, PKG_ROOT].filter(Boolean)) {
+    try { return proxyCodeVersion(path.join(root, "proxy", "openmem_context")); } catch { /* not there */ }
+  }
+  return null;
+}
+
+/**
+ * Current state: per-agent values, port, whether the proxy answers, which agents point at it, and the
+ * session store's recent events (summarizeEvents) with the checkout's proxy code version to compare.
+ * @param {{ home: string, stackRoot?: string, fetch?: typeof fetch, env?: NodeJS.ProcessEnv, now?: number }} opts
+ */
+export async function contextStatus({ home, stackRoot, fetch, env = process.env, now }) {
+  const cfg = loadPmConfig(home, stackRoot || home).merged;
+  const { port } = contextProxyFromPmConfig(cfg);
+  const { agents, saved, enabledSaved } = contextAgentsFromPmConfig(cfg);
+  return {
+    enabled: contextProxyFromPmConfig(cfg).enabled,
+    enabledSaved,
+    agents: Object.fromEntries(CONTEXT_AGENT_KEYS.map((k) => [k, { on: agents[k], saved: saved.includes(k), route: CONTEXT_AGENT_ROUTE[k] }])),
+    port,
+    proxyUp: await probeContextProxy(port, fetch ? { fetch } : {}),
+    pointedAgents: agentsPointedAtContextProxy(home),
+    events: summarizeEvents(path.join(contextRoot(home, env), "sessions"), now === undefined ? {} : { now }),
+    checkoutProxyVersion: checkoutProxyVersion(stackRoot),
+  };
+}
+
+/** Text lines for the events part of `status`. */
+export function eventLines(s) {
+  const e = s.events;
+  const lines = [`last ${e.hours} h (${e.sessions} session${e.sessions === 1 ? "" : "s"}): ${e.trims} trim${e.trims === 1 ? "" : "s"}`
+    + (e.trims ? `, ~${e.tokensSaved} tokens saved (estimated ${e.tokensBefore} -> ${e.tokensAfter}), ${e.dropped} messages dropped` : "")
+    + `, ${e.failOpens} fail-open${e.failOpens === 1 ? "" : "s"} (request sent untrimmed)`];
+  for (const x of e.lastErrors) lines.push(`  ${x.at} ${x.error} at ${x.location} (${x.version}, session ${x.session})`);
+  lines.push(...usageLines(e.usage));
+  const running = e.latest.proxy;
+  if (running && s.checkoutProxyVersion) {
+    lines.push(`proxy code: ${running === s.checkoutProxyVersion ? `${running}, matches the checkout`
+      : `${running} in the last event, checkout is ${s.checkoutProxyVersion}; restart the context-proxy service to load it`}`);
+  }
+  lines.push("not recorded here: fail-opens before the session id is known or from the session database itself (proxy stderr only)");
+  return lines;
+}
+
+/** Prompt-cache lines from summarizeEvents' `usage`; none when no usage event was recorded. */
+function usageLines(u) {
+  if (!u?.requests) return [];
+  const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+  const ratio = u.hitRatio === null ? "n/a" : `${(u.hitRatio * 100).toFixed(1)}%`;
+  const lines = [`prompt cache: ${plural(u.requests, "request")} (${u.withCacheCounts} with cache counts), hit ratio ${ratio}`
+    + ` (read ${u.cacheReadTokens} / read + creation ${u.cacheCreationTokens} + uncached ${u.inputTokens})`];
+  const avg = (g) => (g.withCacheCounts ? Math.round(g.cacheCreationTokens / g.withCacheCounts) : "n/a");
+  lines.push(`  cache creation: ${u.newCut.cacheCreationTokens} on ${plural(u.newCut.requests, "request")} making a new cut`
+    + ` (avg ${avg(u.newCut)}), ${u.other.cacheCreationTokens} on ${plural(u.other.requests, "other")} (avg ${avg(u.other)})`);
+  const counts = Object.entries(u.breakpoints).map(([n, k]) => `${n}: ${k}`).join(", ");
+  if (counts) {
+    lines.push(`  cache_control breakpoints per request: ${counts}; top layouts `
+      + u.breakpointLayouts.map((x) => `${x.at} (${x.requests})`).join(", "));
+  }
+  return lines;
+}
+
+function parseArgs(argv) {
+  const flags = { action: argv[0], dry: false, json: false, agents: [], help: false, unknown: [] };
+  for (let i = 1; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--dry-run") flags.dry = true;
+    else if (a === "--json") flags.json = true;
+    else if (a === "--agents") flags.agents = String(argv[++i] || "").split(",").map((s) => s.trim()).filter(Boolean);
+    else if (a === "--help" || a === "-h") flags.help = true;
+    else flags.unknown.push(a);
+  }
+  if (["--help", "-h", "help"].includes(flags.action)) flags.help = true;
+  return flags;
+}
+
+/**
+ * `openmem context on|off|status`. Returns the exit code.
+ * @param {{ argv: string[], home: string, stackRoot: string, env?: NodeJS.ProcessEnv,
+ *   log?: { info: (m: string) => void, warn: (m: string) => void },
+ *   spawn?: typeof spawnSync, fetch?: typeof fetch }} opts
+ */
+export async function runContextCommand(opts) {
+  const { home, stackRoot } = opts;
+  const env = opts.env || process.env;
+  const log = opts.log || { info: (m) => console.log(m), warn: (m) => console.warn(m) };
+  const spawn = opts.spawn || spawnSync;
+  const flags = parseArgs(opts.argv);
+  if (flags.help) {
+    log.info(HELP);
+    return 0;
+  }
+  const badAgents = flags.agents.filter((a) => !CONTEXT_AGENT_KEYS.includes(a));
+  if (!["on", "off", "status"].includes(flags.action) || flags.unknown.length || badAgents.length) {
+    if (badAgents.length) log.warn(`unknown agent: ${badAgents.join(", ")} (known: ${CONTEXT_AGENT_KEYS.join(", ")})`);
+    log.warn(HELP);
+    return 2;
+  }
+  if (flags.action === "status") {
+    const s = await contextStatus({ home, stackRoot, fetch: opts.fetch, env });
+    if (flags.json) log.info(JSON.stringify(s, null, 2));
+    else {
+      for (const [k, a] of Object.entries(s.agents)) {
+        log.info(`${k.padEnd(12)} ${a.on ? "on " : "off"}  ${a.saved ? "saved" : s.enabledSaved ? `follows enabled = ${s.enabled}` : "default"}  (${a.route})`);
+      }
+      log.info(`context proxy http://127.0.0.1:${s.port}: ${s.proxyUp ? "up" : "not answering"}`);
+      log.info(`agents pointed at the proxy: ${s.pointedAgents.length ? s.pointedAgents.join(", ") : "none"}`);
+      for (const line of eventLines(s)) log.info(line);
+    }
+    return 0;
+  }
+  const on = flags.action === "on";
+  const keys = flags.agents.length ? flags.agents : CONTEXT_AGENT_KEYS;
+  const saved = updatePmConfigContextAgents(home, Object.fromEntries(keys.map((k) => [k, on])), { dry: flags.dry });
+  const summary = keys.map((k) => `${k} = ${on}`).join(", ");
+  log.info(`${saved.result === "dry-run" ? "[dry-run] would save" : "saved"} [context_proxy.agents] ${summary}`);
+  // install-coding-agent follows the saved values: it wires agents and starts or stops the service.
+  const args = [path.join(PKG_ROOT, "cli", "install-coding-agent.mjs"), "--yes"];
+  if (flags.dry) args.push("--dry-run");
+  return spawn(process.execPath, args, { stdio: "inherit", env }).status ?? 1;
+}
+
+if (isMainModule(import.meta.url)) {
+  const home = process.env.HOME || "";
+  const sr = resolveStackRoot({ pkgRoot: PKG_ROOT });
+  runContextCommand({ argv: process.argv.slice(2), home, stackRoot: sr.root }).then(
+    (code) => process.exit(code),
+    (err) => {
+      console.error(err);
+      process.exit(1);
+    },
+  );
+}

package/cli/feed-sync.mjs

@@ -3,9 +3,25 @@
 import { spawnSync } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { isMainModule } from "./is-main.mjs";
 
 const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const script = path.join(PKG_ROOT, "indexer", "feed_sync.py");
 
-const r = spawnSync("python3", [script, ...process.argv.slice(2)], { stdio: "inherit", cwd: PKG_ROOT });
-process.exit(r.status ?? 1);
+export function pythonCandidates(platform = process.platform, env = process.env) {
+  if (env.PYTHON) return [[env.PYTHON, []]];
+  return platform === "win32" ? [["py", ["-3"]], ["python", []]] : [["python3", []], ["python", []]];
+}
+
+if (isMainModule(import.meta.url)) {
+  let missing = true;
+  for (const [command, prefix] of pythonCandidates()) {
+    const result = spawnSync(command, [...prefix, script, ...process.argv.slice(2)], { stdio: "inherit", cwd: PKG_ROOT });
+    if (result.error?.code === "ENOENT") continue;
+    missing = false;
+    if (result.error) console.error(`feed-sync: ${result.error.message}`);
+    process.exit(result.status ?? 1);
+  }
+  if (missing) console.error("feed-sync: Python 3 not found; install Python 3 with PyYAML or set PYTHON to its executable");
+  process.exit(1);
+}