yaml-flow 5.3.0 → 5.4.2

package/dist/cli/board-live-cards-cli.js

@@ -1,13 +1,13 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
+import * as fs7 from 'fs';
+import * as os3 from 'os';
+import * as path7 from 'path';
 import { randomUUID } from 'crypto';
 import { execFileSync, spawn, execFile } from 'child_process';
 import { fileURLToPath } from 'url';
 import fg from 'fast-glob';
 import { lockSync } from 'proper-lockfile';
-import jsonata2 from 'jsonata';
 import addFormats from 'ajv-formats';
+import jsonata2 from 'jsonata';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -2964,7 +2964,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve3.call(this, root, ref);
+      let _sch = resolve6.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -2991,7 +2991,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve3(root, ref) {
+    function resolve6(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3205,8 +3205,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path2) {
-      let input = path2;
+    function removeDotSegments(path8) {
+      let input = path8;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3404,8 +3404,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path2, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path2 && path2 !== "/" ? path2 : void 0;
+        const [path8, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path8 && path8 !== "/" ? path8 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -3563,7 +3563,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve3(baseURI, relativeURI, options) {
+    function resolve6(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3790,7 +3790,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve3,
+      resolve: resolve6,
       resolveComponent,
       equal,
       serialize,
@@ -7740,25 +7740,25 @@ function parseRootPathNamespace(pathValue) {
   const match = ROOT_PATH_NAMESPACE_RE.exec(pathValue);
   return match ? match[1] : null;
 }
-function validateJsonataExprWithNamespaces(expr, path2, allowedNamespaces, errors) {
+function validateJsonataExprWithNamespaces(expr, path8, allowedNamespaces, errors) {
   try {
     jsonata2(expr);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    errors.push(`${path2}: invalid JSONata expression (${message})`);
+    errors.push(`${path8}: invalid JSONata expression (${message})`);
     return;
   }
   const usedNamespaces = referencedNamespaces(expr);
   for (const namespace of usedNamespaces) {
     if (!allowedNamespaces.has(namespace)) {
-      errors.push(`${path2}: disallowed namespace "${namespace}" in expression`);
+      errors.push(`${path8}: disallowed namespace "${namespace}" in expression`);
     }
   }
 }
-function walkViewPathReferences(value, path2, errors) {
+function walkViewPathReferences(value, path8, errors) {
   if (Array.isArray(value)) {
     value.forEach((entry, index) => {
-      walkViewPathReferences(entry, `${path2}/${index}`, errors);
+      walkViewPathReferences(entry, `${path8}/${index}`, errors);
     });
     return;
   }
@@ -7766,14 +7766,14 @@ function walkViewPathReferences(value, path2, errors) {
     const rootNamespace = parseRootPathNamespace(value);
     if (!rootNamespace) return;
     if (!(/* @__PURE__ */ new Set(["card_data", "requires", "fetched_sources", "computed_values"])).has(rootNamespace)) {
-      errors.push(`${path2}: disallowed namespace "${rootNamespace}" in view reference`);
+      errors.push(`${path8}: disallowed namespace "${rootNamespace}" in view reference`);
     }
     return;
   }
   if (!value || typeof value !== "object") return;
   const record = value;
   for (const [key, next] of Object.entries(record)) {
-    walkViewPathReferences(next, `${path2}/${key}`, errors);
+    walkViewPathReferences(next, `${path8}/${key}`, errors);
   }
 }
 function getValidator() {
@@ -7787,8 +7787,8 @@ function validateLiveCardSchema(node) {
   const validate = getValidator();
   const valid = validate(node);
   const errors = (validate.errors ?? []).map((e) => {
-    const path2 = e.instancePath || "/";
-    return `${path2}: ${e.message ?? "unknown error"}`;
+    const path8 = e.instancePath || "/";
+    return `${path8}: ${e.message ?? "unknown error"}`;
   });
   if (node && typeof node === "object" && !Array.isArray(node)) {
     const source_defs = node.source_defs;
@@ -7887,1098 +7887,1696 @@ function validateLiveCardDefinition(node) {
   if (!runtime.ok) return { ok: false, errors: runtime.errors };
   return { ok: true, errors: [] };
 }
-
-// src/card-compute/index.ts
-function deepGet(obj, path2) {
-  if (!path2 || !obj) return void 0;
-  const parts = path2.split(".");
-  let cur = obj;
-  for (let i = 0; i < parts.length; i++) {
-    if (cur == null) return void 0;
-    cur = cur[parts[i]];
-  }
-  return cur;
-}
-function deepSet(obj, path2, value) {
-  const parts = path2.split(".");
-  let cur = obj;
-  for (let i = 0; i < parts.length - 1; i++) {
-    if (cur[parts[i]] == null || typeof cur[parts[i]] !== "object") cur[parts[i]] = {};
-    cur = cur[parts[i]];
-  }
-  cur[parts[parts.length - 1]] = value;
-}
-async function run(node, options) {
-  if (!node?.compute?.length) return node;
-  if (!node.card_data) node.card_data = {};
-  node.computed_values = {};
-  node._sourcesData = options?.sourcesData ?? {};
-  const ctx = {
-    card_data: node.card_data,
-    requires: node.requires ?? {},
-    fetched_sources: node._sourcesData,
-    computed_values: node.computed_values
-  };
-  for (const step of node.compute) {
-    try {
-      const val = await jsonata2(step.expr).evaluate(ctx);
-      deepSet(node.computed_values, step.bindTo, val);
-      ctx.computed_values = node.computed_values;
-    } catch (err) {
-      console.error(`CardCompute.run error on "${node.id ?? "?"}.${step.bindTo}":`, err);
+function createBoardCommandHandlers(deps) {
+  function cmdInit(args) {
+    const dir = args[0];
+    if (!dir) {
+      throw new Error("Usage: board-live-cards init <dir> [--task-executor <script>] [--chat-handler <script>] [--inference-adapter <script>] [--runtime-out <dir>]");
+    }
+    const teIdx = args.indexOf("--task-executor");
+    const taskExecutor = teIdx !== -1 ? args[teIdx + 1] : void 0;
+    const chIdx = args.indexOf("--chat-handler");
+    const chatHandler = chIdx !== -1 ? args[chIdx + 1] : void 0;
+    const iaIdx = args.indexOf("--inference-adapter");
+    const inferenceAdapter = iaIdx !== -1 ? args[iaIdx + 1] : void 0;
+    const roIdx = args.indexOf("--runtime-out");
+    const runtimeOut = roIdx !== -1 ? args[roIdx + 1] : void 0;
+    if (roIdx !== -1 && !runtimeOut) {
+      throw new Error("Usage: board-live-cards init <dir> [--task-executor <script>] [--chat-handler <script>] [--inference-adapter <script>] [--runtime-out <dir>]");
+    }
+    const result = deps.initBoard(dir);
+    if (taskExecutor) {
+      const teExtraIdx = args.indexOf("--task-executor-extra");
+      let teExtra;
+      if (teExtraIdx !== -1 && args[teExtraIdx + 1]) {
+        try {
+          teExtra = JSON.parse(args[teExtraIdx + 1]);
+        } catch {
+        }
+      }
+      const teConfig = { command: taskExecutor, ...teExtra ? { extra: teExtra } : {} };
+      fs7.writeFileSync(path7.join(dir, ".task-executor"), JSON.stringify(teConfig, null, 2), "utf-8");
     }
-  }
-  return node;
-}
-async function evalExpr(expr, node) {
-  const ctx = {
-    card_data: node.card_data ?? {},
-    requires: node.requires ?? {},
-    fetched_sources: node._sourcesData ?? {},
-    computed_values: node.computed_values ?? {}
-  };
-  return jsonata2(expr).evaluate(ctx);
-}
-function resolve(node, path2) {
-  if (path2.startsWith("fetched_sources.")) {
-    return deepGet(node._sourcesData ?? {}, path2.slice("fetched_sources.".length));
-  }
-  return deepGet(node, path2);
-}
-var VALID_ELEMENT_KINDS = /* @__PURE__ */ new Set([
-  "metric",
-  "table",
-  "editable-table",
-  "chart",
-  "form",
-  "filter",
-  "list",
-  "notes",
-  "todo",
-  "alert",
-  "narrative",
-  "badge",
-  "text",
-  "markdown",
-  "ref",
-  "custom",
-  "actions"
-]);
-var ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "meta", "requires", "provides", "view", "card_data", "compute", "source_defs"]);
-function validateNode(node) {
-  const errors = [];
-  if (!node || typeof node !== "object" || Array.isArray(node)) {
-    return { ok: false, errors: ["Node must be a non-null object"] };
-  }
-  const n = node;
-  if (typeof n.id !== "string" || !n.id) errors.push("id: required, must be a non-empty string");
-  for (const key of Object.keys(n)) {
-    if (!ALLOWED_KEYS.has(key)) errors.push(`Unknown top-level key: "${key}"`);
-  }
-  if (n.card_data == null || typeof n.card_data !== "object" || Array.isArray(n.card_data)) {
-    errors.push("card_data: required, must be an object");
-  }
-  if (n.meta != null) {
-    if (typeof n.meta !== "object" || Array.isArray(n.meta)) {
-      errors.push("meta: must be an object");
-    } else {
-      const meta = n.meta;
-      if (meta.title != null && typeof meta.title !== "string") errors.push("meta.title: must be a string");
-      if (meta.tags != null && !Array.isArray(meta.tags)) errors.push("meta.tags: must be an array");
+    if (chatHandler) {
+      fs7.writeFileSync(path7.join(dir, ".chat-handler"), chatHandler, "utf-8");
     }
-  }
-  if (n.requires != null && !Array.isArray(n.requires)) errors.push("requires: must be an array of strings");
-  if (n.provides != null) {
-    if (!Array.isArray(n.provides)) {
-      errors.push("provides: must be an array of { bindTo, ref } bindings");
-    } else {
-      n.provides.forEach((p, i) => {
-        if (!p || typeof p !== "object" || Array.isArray(p)) {
-          errors.push(`provides[${i}]: must be an object with bindTo and ref`);
-        } else {
-          const b = p;
-          if (typeof b.bindTo !== "string" || !b.bindTo) errors.push(`provides[${i}]: missing required "bindTo" string`);
-          if (typeof b.ref !== "string" || !b.ref) errors.push(`provides[${i}]: missing required "ref" string`);
-        }
-      });
+    if (inferenceAdapter) {
+      fs7.writeFileSync(path7.join(dir, ".inference-adapter"), inferenceAdapter, "utf-8");
     }
-  }
-  if (n.compute != null) {
-    if (!Array.isArray(n.compute)) {
-      errors.push("compute: must be an array of compute steps");
+    const runtimeOutDir = deps.configureRuntimeOutDir(dir, runtimeOut);
+    const live = deps.loadBoard(dir);
+    deps.writeJsonAtomic(deps.resolveStatusSnapshotPath(dir), deps.buildBoardStatusObject(dir, live));
+    if (result === "exists") {
+      console.log(`Board already initialized at ${path7.resolve(dir)}${taskExecutor ? ` (task-executor updated: ${taskExecutor})` : ""} (runtime-out: ${runtimeOutDir})`);
     } else {
-      n.compute.forEach((step, i) => {
-        if (!step || typeof step !== "object" || Array.isArray(step)) {
-          errors.push(`compute[${i}]: must be a compute step object`);
-        } else {
-          const s = step;
-          if (typeof s.bindTo !== "string" || !s.bindTo) errors.push(`compute[${i}]: missing required "bindTo" property`);
-          if (typeof s.expr !== "string" || !s.expr) errors.push(`compute[${i}]: missing required "expr" string (JSONata expression)`);
-        }
-      });
+      console.log(`Board initialized at ${path7.resolve(dir)}${taskExecutor ? ` (task-executor: ${taskExecutor})` : ""} (runtime-out: ${runtimeOutDir})`);
     }
   }
-  if (n.source_defs != null) {
-    if (!Array.isArray(n.source_defs)) {
-      errors.push("source_defs: must be an array");
-    } else {
-      const bindTos = /* @__PURE__ */ new Set();
-      const outputFiles = /* @__PURE__ */ new Set();
-      n.source_defs.forEach((src, i) => {
-        if (!src || typeof src !== "object" || Array.isArray(src)) {
-          errors.push(`source_defs[${i}]: must be an object`);
-        } else {
-          const s = src;
-          if (typeof s.bindTo !== "string" || !s.bindTo) {
-            errors.push(`source_defs[${i}]: missing required "bindTo" property`);
-          } else {
-            if (bindTos.has(s.bindTo)) {
-              errors.push(`source_defs[${i}]: bindTo "${s.bindTo}" is not unique across source_defs`);
-            }
-            bindTos.add(s.bindTo);
-          }
-          if (typeof s.outputFile !== "string" || !s.outputFile) {
-            errors.push(`source_defs[${i}]: missing required "outputFile" property`);
-          } else {
-            if (outputFiles.has(s.outputFile)) {
-              errors.push(`source_defs[${i}]: outputFile "${s.outputFile}" is not unique across source_defs`);
-            }
-            outputFiles.add(s.outputFile);
-          }
-          if (s.optionalForCompletionGating != null && typeof s.optionalForCompletionGating !== "boolean") {
-            errors.push(`source_defs[${i}]: optionalForCompletionGating must be a boolean`);
-          }
-        }
-      });
+  function cmdStatus(args) {
+    const rgIdx = args.indexOf("--rg");
+    const asJson = args.includes("--json");
+    const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
+    if (!dir) {
+      console.error("Usage: board-live-cards status --rg <dir>");
+      process.exit(1);
     }
-  }
-  if (n.view != null) {
-    if (typeof n.view !== "object" || Array.isArray(n.view)) {
-      errors.push("view: must be an object");
+    const statusOutPath = deps.resolveStatusSnapshotPath(dir);
+    let statusObject;
+    if (fs7.existsSync(statusOutPath)) {
+      statusObject = JSON.parse(fs7.readFileSync(statusOutPath, "utf-8"));
     } else {
-      const view = n.view;
-      if (!Array.isArray(view.elements) || view.elements.length === 0) {
-        errors.push("view.elements: required, must be a non-empty array");
-      } else {
-        view.elements.forEach((elem, i) => {
-          if (!elem || typeof elem !== "object") {
-            errors.push(`view.elements[${i}]: must be an object`);
-            return;
-          }
-          if (!elem.kind || typeof elem.kind !== "string") {
-            errors.push(`view.elements[${i}].kind: required, must be a string`);
-          } else if (!VALID_ELEMENT_KINDS.has(elem.kind)) {
-            errors.push(`view.elements[${i}].kind: unknown kind "${elem.kind}". Valid: ${[...VALID_ELEMENT_KINDS].join(", ")}`);
-          }
-          if (elem.data != null && (typeof elem.data !== "object" || Array.isArray(elem.data))) {
-            errors.push(`view.elements[${i}].data: must be an object`);
-          }
-        });
-      }
-      if (view.layout != null && (typeof view.layout !== "object" || Array.isArray(view.layout))) errors.push("view.layout: must be an object");
-      if (view.features != null && (typeof view.features !== "object" || Array.isArray(view.features))) errors.push("view.features: must be an object");
+      statusObject = deps.buildBoardStatusObject(dir, deps.loadBoard(dir));
+      deps.writeJsonAtomic(statusOutPath, statusObject);
     }
-  }
-  return { ok: errors.length === 0, errors };
-}
-async function enrichSources(source_defs, context) {
-  if (!source_defs || source_defs.length === 0) return [];
-  const evalCtx = {
-    card_data: context.card_data ?? {},
-    requires: context.requires ?? {}
-  };
-  return Promise.all(
-    source_defs.map(async (src) => {
-      const _projections = {};
-      if (src.projections && typeof src.projections === "object" && !Array.isArray(src.projections)) {
-        for (const [key, expr] of Object.entries(src.projections)) {
-          if (typeof expr === "string" && expr.trim().length > 0) {
+    if (asJson) {
+      console.log(JSON.stringify(statusObject, null, 2));
+      return;
+    }
+    console.log(`Board: ${statusObject.meta.board.path}`);
+    console.log(`Tasks: ${statusObject.summary.card_count}`);
+    console.log("");
+    for (const card of statusObject.cards) {
+      const dataKeys = card.provides_runtime.join(", ");
+      console.log(`  ${card.status.padEnd(12)} ${card.name}${dataKeys ? ` \u2014 [${dataKeys}]` : ""}`);
+    }
+    console.log("");
+    console.log(`Schedule: ${statusObject.summary.eligible} eligible, ${statusObject.summary.pending} pending, ${statusObject.summary.blocked} blocked, ${statusObject.summary.unresolved} unresolved`);
+  }
+  function cmdValidateCard(args) {
+    const cardIdx = args.indexOf("--card");
+    const globIdx = args.indexOf("--card-glob");
+    const rgIdx = args.indexOf("--rg");
+    const cardFile = cardIdx !== -1 ? args[cardIdx + 1] : void 0;
+    const cardGlob = globIdx !== -1 ? args[globIdx + 1] : void 0;
+    const boardDir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
+    if (!cardFile && !cardGlob || cardFile && cardGlob) {
+      throw new Error("Usage: board-live-cards validate-card (--card <card.json> | --card-glob <glob>) [--rg <boardDir>]");
+    }
+    let teConfig;
+    if (boardDir) {
+      teConfig = deps.readTaskExecutorConfig(boardDir);
+      if (!teConfig) {
+        throw new Error(`--rg specified but no .task-executor found in ${boardDir}`);
+      }
+    }
+    const files = cardFile ? [path7.resolve(cardFile)] : deps.resolveCardGlobMatches(cardGlob);
+    if (files.length === 0) {
+      throw new Error(`No card files matched glob: ${cardGlob}`);
+    }
+    let failures = 0;
+    for (const f of files) {
+      const label = path7.relative(process.cwd(), f) || f;
+      if (!fs7.existsSync(f)) {
+        console.error(`FAIL  ${label}: file not found`);
+        failures++;
+        continue;
+      }
+      let card;
+      try {
+        card = JSON.parse(fs7.readFileSync(f, "utf-8"));
+      } catch (err) {
+        console.error(`FAIL  ${label}: invalid JSON \u2014 ${err instanceof Error ? err.message : String(err)}`);
+        failures++;
+        continue;
+      }
+      const result = deps.validateLiveCardDefinition(card);
+      const sourceErrors = [];
+      if (teConfig && Array.isArray(card.source_defs)) {
+        for (const src of card.source_defs) {
+          const bindTo = typeof src.bindTo === "string" ? src.bindTo : "(unknown)";
+          const tmpFile = path7.join(os3.tmpdir(), `validate-src-${bindTo}-${Date.now()}.json`);
+          try {
+            fs7.writeFileSync(tmpFile, JSON.stringify(src), "utf-8");
+            let stdout;
             try {
-              _projections[key] = await jsonata2(expr).evaluate(evalCtx);
+              stdout = deps.execCommandSync(teConfig.command, ["validate-source-def", "--in", tmpFile], { shell: true, timeout: 1e4 });
+            } catch (execErr) {
+              stdout = typeof execErr?.stdout === "string" ? execErr.stdout : Buffer.isBuffer(execErr?.stdout) ? execErr.stdout.toString("utf-8") : "";
+              if (!stdout.trim()) {
+                sourceErrors.push(`source "${bindTo}": executor validate-source-def failed \u2014 ${execErr instanceof Error ? execErr.message : String(execErr)}`);
+                continue;
+              }
+            }
+            const parsed = JSON.parse(stdout.trim());
+            if (!parsed.ok && Array.isArray(parsed.errors)) {
+              for (const error of parsed.errors) {
+                sourceErrors.push(`source "${bindTo}": ${error}`);
+              }
+            }
+          } catch (err) {
+            sourceErrors.push(`source "${bindTo}": executor validate-source-def failed \u2014 ${err instanceof Error ? err.message : String(err)}`);
+          } finally {
+            try {
+              fs7.unlinkSync(tmpFile);
             } catch {
-              _projections[key] = void 0;
             }
           }
         }
       }
-      return { ...src, _projections };
-    })
-  );
-}
-var CardCompute = {
-  run,
-  eval: evalExpr,
-  resolve,
-  validate: validateNode,
-  enrichSources
-};
-
-// src/cli/board-live-cards-cli.ts
-var BOARD_FILE = "board-graph.json";
-var JOURNAL_FILE = "board-journal.jsonl";
-var TASK_EXECUTOR_LOG_FILE = "task-executor.jsonl";
-var INFERENCE_ADAPTER_LOG_FILE = "inference-adapter.jsonl";
-var INVENTORY_FILE = "cards-inventory.jsonl";
-var RUNTIME_OUT_FILE = ".runtime-out";
-var DEFAULT_RUNTIME_OUT_DIR = "runtime-out";
-var RUNTIME_STATUS_FILE = "board-livegraph-status.json";
-var RUNTIME_CARDS_DIR = "cards";
-var RUNTIME_DATA_OBJECTS_DIR = "data-objects";
-var INFERENCE_ADAPTER_FILE = ".inference-adapter";
-var TASK_EXECUTOR_FILE = ".task-executor";
-var DEFAULT_TASK_COMPLETION_RULE = "all_required_sources_fetched";
-function readTaskExecutorConfig(boardDir) {
-  const executorFile = path.join(boardDir, TASK_EXECUTOR_FILE);
-  if (!fs.existsSync(executorFile)) return void 0;
-  const raw = fs.readFileSync(executorFile, "utf-8").trim();
-  if (!raw) return void 0;
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && typeof parsed.command === "string") {
-      return parsed;
+      const allErrors = [...result.errors, ...sourceErrors];
+      if (allErrors.length === 0) {
+        console.log(`OK    ${label}`);
+      } else {
+        console.error(`FAIL  ${label}:`);
+        for (const error of allErrors) {
+          console.error(`        ${error}`);
+        }
+        failures++;
+      }
     }
-  } catch {
-  }
-  return { command: raw };
-}
-var EMPTY_CONFIG = { settings: { completion: "manual", refreshStrategy: "data-changed" }, tasks: {} };
-var BoardJournal = class {
-  journalPath;
-  lastDrainedId;
-  constructor(journalPath, lastDrainedJournalId) {
-    this.journalPath = journalPath;
-    this.lastDrainedId = lastDrainedJournalId;
+    if (failures > 0) {
+      throw new Error(`${failures} of ${files.length} card(s) failed validation.`);
+    }
+    console.log(`
+${files.length} card(s) passed validation.`);
   }
-  append(event) {
-    const entry = { id: randomUUID(), event };
-    fs.appendFileSync(this.journalPath, JSON.stringify(entry) + "\n", "utf-8");
-  }
-  drain() {
-    if (!fs.existsSync(this.journalPath)) return [];
-    const content = fs.readFileSync(this.journalPath, "utf-8").trim();
-    if (!content) return [];
-    const entries = content.split("\n").map((l) => JSON.parse(l));
-    let startIdx = 0;
-    if (this.lastDrainedId) {
-      const drainedIdx = entries.findIndex((e) => e.id === this.lastDrainedId);
-      if (drainedIdx !== -1) startIdx = drainedIdx + 1;
+  function cmdRemoveCard(args) {
+    const rgIdx = args.indexOf("--rg");
+    const idIdx = args.indexOf("--id");
+    const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
+    const cardId = idIdx !== -1 ? args[idIdx + 1] : void 0;
+    if (!dir || !cardId) {
+      console.error("Usage: board-live-cards remove-card --rg <dir> --id <card-id>");
+      process.exit(1);
     }
-    const undrained = entries.slice(startIdx);
-    if (undrained.length > 0) {
-      this.lastDrainedId = undrained[undrained.length - 1].id;
+    deps.appendEventToJournal(dir, {
+      type: "task-removal",
+      taskName: cardId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    void deps.processAccumulatedEventsInfinitePass(dir);
+    console.log(`Card "${cardId}" removed.`);
+  }
+  function cmdRetrigger(args) {
+    const rgIdx = args.indexOf("--rg");
+    const taskIdx = args.indexOf("--task");
+    const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
+    const taskName = taskIdx !== -1 ? args[taskIdx + 1] : void 0;
+    if (!dir || !taskName) {
+      console.error("Usage: board-live-cards retrigger --rg <dir> --task <task-name>");
+      process.exit(1);
     }
-    return undrained.map((e) => e.event);
-  }
-  get size() {
-    if (!fs.existsSync(this.journalPath)) return 0;
-    const content = fs.readFileSync(this.journalPath, "utf-8").trim();
-    if (!content) return 0;
-    const entries = content.split("\n").map((l) => JSON.parse(l));
-    if (!this.lastDrainedId) return entries.length;
-    const drainedIdx = entries.findIndex((e) => e.id === this.lastDrainedId);
-    return drainedIdx === -1 ? entries.length : entries.length - drainedIdx - 1;
-  }
-  get lastDrainedJournalId() {
-    return this.lastDrainedId;
+    deps.appendEventToJournal(dir, {
+      type: "task-restart",
+      taskName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    void deps.processAccumulatedEventsInfinitePass(dir);
+    console.log(`Task "${taskName}" retriggered.`);
   }
-};
-function readCardInventory(boardDir) {
-  const inventoryPath = path.join(boardDir, INVENTORY_FILE);
-  if (!fs.existsSync(inventoryPath)) return [];
-  const lines = fs.readFileSync(inventoryPath, "utf-8").split("\n").filter((l) => l.trim());
-  return lines.map((l) => JSON.parse(l));
-}
-function lookupCardPath(boardDir, cardId) {
-  const entries = readCardInventory(boardDir);
-  const entry = entries.find((e) => e.cardId === cardId);
-  return entry?.cardFilePath ?? null;
-}
-function appendCardInventory(boardDir, entry) {
-  const inventoryPath = path.join(boardDir, INVENTORY_FILE);
-  const normalized = { ...entry, cardFilePath: path.resolve(entry.cardFilePath) };
-  fs.appendFileSync(inventoryPath, JSON.stringify(normalized) + "\n");
+  return {
+    cmdInit,
+    cmdStatus,
+    cmdValidateCard,
+    cmdRemoveCard,
+    cmdRetrigger
+  };
 }
-function buildCardInventoryIndex(boardDir) {
-  const byCardId = /* @__PURE__ */ new Map();
-  const byCardPath = /* @__PURE__ */ new Map();
-  for (const entry of readCardInventory(boardDir)) {
-    const normalizedPath = path.resolve(entry.cardFilePath);
-    const normalizedEntry = {
-      ...entry,
-      cardFilePath: normalizedPath
-    };
-    const existingById = byCardId.get(entry.cardId);
-    if (existingById && existingById.cardFilePath !== normalizedPath) {
-      throw new Error(
-        `Inventory invariant violation: card id "${entry.cardId}" maps to multiple files: "${existingById.cardFilePath}" and "${normalizedPath}"`
-      );
+function createCallbackCommandHandlers(deps) {
+  function cmdTaskCompleted(args) {
+    const rgIdx = args.indexOf("--rg");
+    const tokenIdx = args.indexOf("--token");
+    const dataIdx = args.indexOf("--data");
+    const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
+    const token = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
+    if (!dir || !token) {
+      console.error("Usage: board-live-cards task-completed --rg <dir> --token <token> [--data <json>]");
+      process.exit(1);
     }
-    const existingByPath = byCardPath.get(normalizedPath);
-    if (existingByPath && existingByPath.cardId !== entry.cardId) {
-      throw new Error(
-        `Inventory invariant violation: file "${normalizedPath}" maps to multiple ids: "${existingByPath.cardId}" and "${entry.cardId}"`
-      );
+    const decoded = deps.decodeCallbackToken(token);
+    if (!decoded) {
+      console.error("Invalid callback token");
+      process.exit(1);
     }
-    byCardId.set(entry.cardId, normalizedEntry);
-    byCardPath.set(normalizedPath, normalizedEntry);
-  }
-  return { byCardId, byCardPath };
-}
-function initBoard(dir) {
-  const boardPath = path.join(dir, BOARD_FILE);
-  if (fs.existsSync(boardPath)) {
-    const envelope2 = JSON.parse(fs.readFileSync(boardPath, "utf-8"));
-    restore(envelope2.graph);
-    return "exists";
-  }
-  if (fs.existsSync(dir)) {
-    const entries = fs.readdirSync(dir);
-    if (entries.length > 0) {
-      throw new Error(`Directory "${dir}" is not empty and has no valid ${BOARD_FILE}`);
+    const data = dataIdx !== -1 ? JSON.parse(args[dataIdx + 1]) : {};
+    deps.writeRuntimeDataObjects(dir, data);
+    deps.appendEventToJournal(dir, {
+      type: "task-completed",
+      taskName: decoded.taskName,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    void deps.processAccumulatedEventsForced(dir);
+    console.log("Task completed.");
+  }
+  function cmdTaskFailed(args) {
+    const rgIdx = args.indexOf("--rg");
+    const tokenIdx = args.indexOf("--token");
+    const errorIdx = args.indexOf("--error");
+    const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
+    const token = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
+    const errorMsg = errorIdx !== -1 ? args[errorIdx + 1] : "unknown error";
+    if (!dir || !token) {
+      console.error("Usage: board-live-cards task-failed --rg <dir> --token <token> [--error <message>]");
+      process.exit(1);
+    }
+    const decoded = deps.decodeCallbackToken(token);
+    if (!decoded) {
+      console.error("Invalid callback token");
+      process.exit(1);
+    }
+    deps.appendEventToJournal(dir, {
+      type: "task-failed",
+      taskName: decoded.taskName,
+      error: errorMsg,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    void deps.processAccumulatedEventsForced(dir);
+    console.log("Task failed.");
+  }
+  function cmdSourceDataFetched(args) {
+    const tmpIdx = args.indexOf("--tmp");
+    const tokenIdx = args.indexOf("--token");
+    const tmpFile = tmpIdx !== -1 ? args[tmpIdx + 1] : void 0;
+    const token = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
+    if (!tmpFile || !token) {
+      console.error("Usage: board-live-cards source-data-fetched --tmp <tmp-file> --token <sourceToken>");
+      process.exit(1);
+    }
+    const payload = deps.decodeSourceToken(token);
+    if (!payload) {
+      console.error("Invalid source token");
+      process.exit(1);
+    }
+    const { cbk, rg, cid, b, d, cs } = payload;
+    const destPath = path7.join(rg, cid, d);
+    fs7.mkdirSync(path7.dirname(destPath), { recursive: true });
+    fs7.renameSync(tmpFile, destPath);
+    console.log(`[source-data-fetched] ${cid}.${b} -> ${cid}/${d}`);
+    const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const cbkDecoded = deps.decodeCallbackToken(cbk);
+    if (!cbkDecoded) {
+      console.error("Invalid callback token embedded in source token");
+      process.exit(1);
+    }
+    deps.appendEventToJournal(rg, {
+      type: "task-progress",
+      taskName: cbkDecoded.taskName,
+      update: { bindTo: b, outputFile: d, fetchedAt, sourceChecksum: cs },
+      timestamp: fetchedAt
+    });
+    void deps.processAccumulatedEventsInfinitePass(rg);
+  }
+  function cmdSourceDataFetchFailure(args) {
+    const tokenIdx = args.indexOf("--token");
+    const reasonIdx = args.indexOf("--reason");
+    const token = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
+    const reason = reasonIdx !== -1 ? args[reasonIdx + 1] : "unknown";
+    if (!token) {
+      console.error("Usage: board-live-cards source-data-fetch-failure --token <sourceToken> [--reason <msg>]");
+      process.exit(1);
     }
+    const payload = deps.decodeSourceToken(token);
+    if (!payload) {
+      console.error("Invalid source token");
+      process.exit(1);
+    }
+    const { cbk, rg, cid, b, d, cs } = payload;
+    console.log(`[source-data-fetch-failure] ${cid}.${b}: ${reason}`);
+    const cbkDecoded = deps.decodeCallbackToken(cbk);
+    if (!cbkDecoded) {
+      console.error("Invalid callback token embedded in source token");
+      process.exit(1);
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    deps.appendEventToJournal(rg, {
+      type: "task-progress",
+      taskName: cbkDecoded.taskName,
+      update: { bindTo: b, outputFile: d, failure: true, reason, sourceChecksum: cs },
+      timestamp
+    });
+    void deps.processAccumulatedEventsInfinitePass(rg);
+  }
+  function cmdTaskProgress(args) {
+    const rgIdx = args.indexOf("--rg");
+    const tokenIdx = args.indexOf("--token");
+    const updateIdx = args.indexOf("--update");
+    const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
+    const token = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
+    const updateJson = updateIdx !== -1 ? args[updateIdx + 1] : "{}";
+    if (!dir || !token) {
+      console.error("Usage: board-live-cards task-progress --rg <dir> --token <token> [--update <json>]");
+      process.exit(1);
+    }
+    const decoded = deps.decodeCallbackToken(token);
+    if (!decoded) {
+      console.error("Invalid callback token");
+      process.exit(1);
+    }
+    const update = updateJson ? JSON.parse(updateJson) : {};
+    deps.appendEventToJournal(dir, {
+      type: "task-progress",
+      taskName: decoded.taskName,
+      update,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    void deps.processAccumulatedEventsInfinitePass(dir);
   }
-  fs.mkdirSync(dir, { recursive: true });
-  const live = createLiveGraph(EMPTY_CONFIG);
-  const snap = snapshot(live);
-  const envelope = { lastDrainedJournalId: "", graph: snap };
-  fs.writeFileSync(boardPath, JSON.stringify(envelope, null, 2));
-  return "created";
-}
-function loadBoardEnvelope(dir) {
-  const raw = fs.readFileSync(path.join(dir, BOARD_FILE), "utf-8");
-  return JSON.parse(raw);
-}
-function loadBoard(dir) {
-  const envelope = loadBoardEnvelope(dir);
-  return restore(envelope.graph);
-}
-function saveBoard(dir, rg, journal) {
-  const snap = rg.snapshot();
-  const envelope = {
-    lastDrainedJournalId: journal.lastDrainedJournalId,
-    graph: snap
+  return {
+    cmdTaskCompleted,
+    cmdTaskFailed,
+    cmdTaskProgress,
+    cmdSourceDataFetched,
+    cmdSourceDataFetchFailure
   };
-  writeJsonAtomic(path.join(dir, BOARD_FILE), envelope);
-  const live = restore(snap);
-  const statusObject = buildBoardStatusObject(dir, live);
-  writeJsonAtomic(resolveStatusSnapshotPath(dir), statusObject);
 }
-function runtimeOutConfigPath(boardDir) {
-  return path.join(boardDir, RUNTIME_OUT_FILE);
-}
-function resolveConfiguredRuntimeOutDir(boardDir) {
-  const cfgPath = runtimeOutConfigPath(boardDir);
-  if (fs.existsSync(cfgPath)) {
-    const configured = fs.readFileSync(cfgPath, "utf-8").trim();
-    if (configured) {
-      return path.isAbsolute(configured) ? configured : path.resolve(boardDir, configured);
+function createNonCoreCommandHandlers(deps) {
+  function cmdRunSourceFetch(args) {
+    const inIdx = args.indexOf("--in");
+    const outIdx = args.indexOf("--out");
+    const errIdx = args.indexOf("--err");
+    const inFile = inIdx !== -1 ? args[inIdx + 1] : void 0;
+    const outFile = outIdx !== -1 ? args[outIdx + 1] : void 0;
+    const errFile = errIdx !== -1 ? args[errIdx + 1] : void 0;
+    if (!inFile || !outFile) {
+      console.error("Usage: board-live-cards run-source-fetch --in <source.json> --out <result.json> [--err <error.txt>]");
+      process.exit(1);
+    }
+    if (!fs7.existsSync(inFile)) {
+      const msg = `Input file not found: ${inFile}`;
+      if (errFile) fs7.writeFileSync(errFile, msg);
+      console.error(`[run-source-fetch] ${msg}`);
+      process.exit(1);
+    }
+    let source;
+    try {
+      const raw = fs7.readFileSync(inFile, "utf-8");
+      source = JSON.parse(raw);
+    } catch (err) {
+      const msg = `Failed to parse input file: ${err.message}`;
+      if (errFile) fs7.writeFileSync(errFile, msg);
+      console.error(`[run-source-fetch] ${msg}`);
+      process.exit(1);
+    }
+    if (!source.cli) {
+      const msg = "Source definition missing cli field (board-live-cards built-in executor only understands source.cli)";
+      if (errFile) fs7.writeFileSync(errFile, msg);
+      console.error(`[run-source-fetch] ${msg}`);
+      process.exit(1);
+    }
+    console.log(`[run-source-fetch] executing: ${source.cli}`);
+    const timeout = source.timeout ?? 12e4;
+    const sourceCwd = typeof source.cwd === "string" ? source.cwd : process.cwd();
+    const sourceBoardDir = typeof source.boardDir === "string" ? source.boardDir : void 0;
+    const cmdParts = deps.splitCommandLine(source.cli);
+    if (cmdParts.length === 0) {
+      const msg = "Source cli command is empty";
+      if (errFile) fs7.writeFileSync(errFile, msg);
+      console.error(`[run-source-fetch] ${msg}`);
+      process.exit(1);
+    }
+    const rawCmd = cmdParts[0];
+    const { cmd, args: cliArgs } = deps.resolveCommandInvocation(rawCmd, cmdParts.slice(1));
+    let stdout;
+    try {
+      stdout = deps.execCommandSync(cmd, cliArgs, {
+        shell: false,
+        encoding: "utf-8",
+        timeout,
+        cwd: sourceCwd,
+        env: {
+          ...process.env,
+          ...sourceBoardDir ? { BOARD_DIR: sourceBoardDir } : {}
+        }
+      });
+    } catch (err) {
+      const msg = err.message ?? String(err);
+      console.error(`[run-source-fetch] cli failed: ${msg}`);
+      if (errFile) fs7.writeFileSync(errFile, msg);
+      process.exit(1);
+    }
+    const result = stdout.trim();
+    try {
+      fs7.writeFileSync(outFile, result);
+      console.log(`[run-source-fetch] result written to ${outFile}`);
+    } catch (err) {
+      const msg = `Failed to write output file: ${err.message}`;
+      console.error(`[run-source-fetch] ${msg}`);
+      if (errFile) fs7.writeFileSync(errFile, msg);
+      process.exit(1);
     }
   }
-  const defaultDir = path.join(boardDir, DEFAULT_RUNTIME_OUT_DIR);
-  fs.writeFileSync(cfgPath, defaultDir, "utf-8");
-  return defaultDir;
-}
-function configureRuntimeOutDir(boardDir, runtimeOut) {
-  let resolved;
-  if (runtimeOut) {
-    resolved = path.isAbsolute(runtimeOut) ? runtimeOut : path.resolve(boardDir, runtimeOut);
-  } else {
-    resolved = path.join(boardDir, DEFAULT_RUNTIME_OUT_DIR);
-  }
-  fs.mkdirSync(resolved, { recursive: true });
-  fs.writeFileSync(runtimeOutConfigPath(boardDir), resolved, "utf-8");
-  return resolved;
-}
-function resolveStatusSnapshotPath(boardDir) {
-  return path.join(resolveConfiguredRuntimeOutDir(boardDir), RUNTIME_STATUS_FILE);
-}
-function resolveComputedValuesPath(boardDir, cardId) {
-  return path.join(resolveConfiguredRuntimeOutDir(boardDir), RUNTIME_CARDS_DIR, `${cardId}.computed.json`);
-}
-function resolveDataObjectsDirPath(boardDir) {
-  return path.join(resolveConfiguredRuntimeOutDir(boardDir), RUNTIME_DATA_OBJECTS_DIR);
-}
-function toDataObjectFileName(token) {
-  return token.replace(/[\\/]/g, "__");
-}
-function writeRuntimeDataObjects(boardDir, data) {
-  for (const [token, payload] of Object.entries(data)) {
-    if (!token) continue;
-    const fileName = toDataObjectFileName(token);
-    if (!fileName) continue;
-    const filePath = path.join(resolveDataObjectsDirPath(boardDir), fileName);
-    writeJsonAtomic(filePath, payload);
-  }
-}
-function writeJsonAtomic(filePath, payload) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
-  fs.writeFileSync(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
-  fs.renameSync(tmpPath, filePath);
-}
-function withBoardLock(boardDir, fn) {
-  const boardPath = path.join(boardDir, BOARD_FILE);
-  const release = lockSync(boardPath, { retries: { retries: 5, minTimeout: 100 } });
-  try {
-    return fn();
-  } finally {
-    release();
+  async function cmdProbeSource(args) {
+    const cardIdx = args.indexOf("--card");
+    const sourceIdxArg = args.indexOf("--source-idx");
+    const sourceBindArg = args.indexOf("--source-bind");
+    const mockProjectionsIdx = args.indexOf("--mock-projections");
+    const rgIdx = args.indexOf("--rg");
+    const outIdx = args.indexOf("--out");
+    const cardFilePath = cardIdx !== -1 ? args[cardIdx + 1] : void 0;
+    const sourceIdxVal = sourceIdxArg !== -1 ? parseInt(args[sourceIdxArg + 1], 10) : 0;
+    const sourceBindVal = sourceBindArg !== -1 ? args[sourceBindArg + 1] : void 0;
+    const mockProjectionsRaw = mockProjectionsIdx !== -1 ? args[mockProjectionsIdx + 1] : void 0;
+    const boardDirArg = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
+    const outFile = outIdx !== -1 ? args[outIdx + 1] : void 0;
+    if (!cardFilePath) {
+      console.error("Usage: board-live-cards probe-source --card <card.json> [--source-idx <n>] [--source-bind <name>] [--mock-projections <json>] [--rg <boardDir>] [--out <result.json>]");
+      process.exit(1);
+    }
+    let card;
+    try {
+      card = JSON.parse(fs7.readFileSync(path7.resolve(cardFilePath), "utf-8"));
+    } catch (e) {
+      console.error(`[probe-source] Cannot read card: ${e.message}`);
+      process.exit(1);
+    }
+    const source_defs = card.source_defs ?? [];
+    if (source_defs.length === 0) {
+      console.error(`[probe-source] Card "${card.id}" has no source_defs`);
+      process.exit(1);
+    }
+    let sourceIdx;
+    if (sourceBindVal) {
+      sourceIdx = source_defs.findIndex((s) => s.bindTo === sourceBindVal);
+      if (sourceIdx === -1) {
+        console.error(`[probe-source] No source with bindTo="${sourceBindVal}" in card "${card.id}"`);
+        process.exit(1);
+      }
+    } else {
+      sourceIdx = sourceIdxVal;
+      if (isNaN(sourceIdx) || sourceIdx < 0 || sourceIdx >= source_defs.length) {
+        console.error(`[probe-source] --source-idx ${sourceIdxVal} out of range (card has ${source_defs.length} source(s))`);
+        process.exit(1);
+      }
+    }
+    const sourceDef = source_defs[sourceIdx];
+    const cardDir = path7.resolve(path7.dirname(cardFilePath));
+    const boardDir = boardDirArg ? path7.resolve(boardDirArg) : cardDir;
+    let mockProjections = {};
+    if (mockProjectionsRaw) {
+      const raw = mockProjectionsRaw.startsWith("@") ? fs7.readFileSync(path7.resolve(mockProjectionsRaw.slice(1)), "utf-8") : mockProjectionsRaw;
+      try {
+        mockProjections = JSON.parse(raw);
+      } catch (e) {
+        console.error(`[probe-source] --mock-projections is not valid JSON: ${e.message}`);
+        process.exit(1);
+      }
+    }
+    const teConfig = deps.readTaskExecutorConfig(boardDir);
+    const taskExecutor = teConfig?.command;
+    const taskExecutorExtraB64 = teConfig?.extra ? Buffer.from(JSON.stringify(teConfig.extra)).toString("base64") : void 0;
+    const inPayload = {
+      ...sourceDef,
+      cwd: typeof sourceDef.cwd === "string" && sourceDef.cwd ? sourceDef.cwd : cardDir,
+      boardDir: typeof sourceDef.boardDir === "string" && sourceDef.boardDir ? sourceDef.boardDir : boardDir,
+      _projections: mockProjections
+    };
+    let sourceKind = "unknown";
+    if (taskExecutor) {
+      try {
+        const capRaw = deps.execCommandSync(taskExecutor, ["describe-capabilities"], {
+          shell: true,
+          timeout: 8e3,
+          encoding: "utf-8"
+        });
+        const caps = JSON.parse(String(capRaw));
+        const knownKinds = caps?.sourceKinds ? Object.keys(caps.sourceKinds) : [];
+        const defKeys = new Set(Object.keys(sourceDef));
+        sourceKind = knownKinds.find((k) => defKeys.has(k)) ?? "unknown";
+      } catch {
+      }
+    }
+    console.log(`[probe-source] card:        ${card.id}`);
+    console.log(`[probe-source] source[${sourceIdx}]:  bindTo="${sourceDef.bindTo}" kind=${sourceKind}`);
+    console.log(`[probe-source] _projections:       ${JSON.stringify(mockProjections)}`);
+    console.log(`[probe-source] executor:    ${taskExecutor ?? "built-in (source.cli only)"}`);
+    console.log("[probe-source] running fetch...");
+    const ts = Date.now();
+    const inFile = path7.join(os3.tmpdir(), `probe-in-${sourceDef.bindTo}-${ts}.json`);
+    const tmpOut = path7.join(os3.tmpdir(), `probe-out-${sourceDef.bindTo}-${ts}.json`);
+    const errFile = path7.join(os3.tmpdir(), `probe-err-${sourceDef.bindTo}-${ts}.txt`);
+    fs7.writeFileSync(inFile, JSON.stringify(inPayload, null, 2), "utf-8");
+    let passed = false;
+    let errorMsg;
+    let resultRaw;
+    try {
+      if (taskExecutor) {
+        const executorArgs = ["run-source-fetch", "--in", inFile, "--out", tmpOut, "--err", errFile];
+        if (taskExecutorExtraB64) executorArgs.push("--extra", taskExecutorExtraB64);
+        deps.execCommandSync(taskExecutor, executorArgs, {
+          shell: true,
+          timeout: sourceDef.timeout ?? 3e4
+        });
+      } else {
+        if (!inPayload.cli) {
+          throw new Error("No task-executor registered and source has no cli field \u2014 cannot probe with built-in executor");
+        }
+        const cmdParts = deps.splitCommandLine(inPayload.cli);
+        const rawCmd = cmdParts[0];
+        const { cmd, args: cliArgs } = deps.resolveCommandInvocation(rawCmd, cmdParts.slice(1));
+        const stdout = deps.execCommandSync(cmd, cliArgs, {
+          shell: false,
+          encoding: "utf-8",
+          timeout: sourceDef.timeout ?? 3e4,
+          cwd: inPayload.cwd
+        });
+        fs7.writeFileSync(tmpOut, String(stdout).trim(), "utf-8");
+      }
+      passed = fs7.existsSync(tmpOut);
+      if (passed) {
+        resultRaw = fs7.readFileSync(tmpOut, "utf-8");
+      } else {
+        errorMsg = fs7.existsSync(errFile) ? fs7.readFileSync(errFile, "utf-8").trim() : "executor produced no output file";
+      }
+    } catch (e) {
+      errorMsg = e.message ?? String(e);
+      if (!errorMsg && fs7.existsSync(errFile)) {
+        errorMsg = fs7.readFileSync(errFile, "utf-8").trim();
+      }
+    }
+    for (const f of [inFile, errFile]) {
+      try {
+        fs7.unlinkSync(f);
+      } catch {
+      }
+    }
+    if (passed && resultRaw !== void 0) {
+      const resultSize = resultRaw.length;
+      const sample = resultRaw.slice(0, 300);
+      console.log("[probe-source] STATUS:      PROBE_PASS");
+      console.log(`[probe-source] result size: ${resultSize} bytes`);
+      console.log(`[probe-source] sample:      ${sample}${resultSize > 300 ? "..." : ""}`);
+      if (outFile) {
+        fs7.writeFileSync(path7.resolve(outFile), resultRaw);
+        console.log(`[probe-source] result written to: ${outFile}`);
+      } else {
+        try {
+          fs7.unlinkSync(tmpOut);
+        } catch {
+        }
+      }
+    } else {
+      console.log("[probe-source] STATUS:      PROBE_FAIL");
+      if (errorMsg) console.log(`[probe-source] error:       ${errorMsg}`);
+      try {
+        if (fs7.existsSync(tmpOut)) fs7.unlinkSync(tmpOut);
+      } catch {
+      }
+    }
+    const summary = {
+      status: passed ? "PROBE_PASS" : "PROBE_FAIL",
+      cardId: card.id,
+      sourceIdx,
+      bindTo: sourceDef.bindTo,
+      sourceKind,
+      mockProjectionsKeys: Object.keys(mockProjections),
+      resultSizeBytes: resultRaw !== void 0 ? resultRaw.length : 0,
+      error: errorMsg ?? void 0
+    };
+    console.log(`[probe-source:result] ${JSON.stringify(summary)}`);
+    process.exit(passed ? 0 : 1);
+  }
+  function cmdDescribeTaskExecutorCapabilities(args) {
+    const rgIdx = args.indexOf("--rg");
+    const boardDir = rgIdx !== -1 ? path7.resolve(args[rgIdx + 1]) : void 0;
+    if (!boardDir) {
+      console.error("Usage: board-live-cards describe-task-executor-capabilities --rg <dir>");
+      process.exit(1);
+    }
+    const teConfig = deps.readTaskExecutorConfig(boardDir);
+    if (!teConfig) {
+      console.error(`[describe-task-executor-capabilities] No .task-executor registered in ${boardDir}`);
+      process.exit(1);
+    }
+    try {
+      const stdout = deps.execCommandSync(teConfig.command, ["describe-capabilities"], {
+        shell: true,
+        timeout: 1e4,
+        encoding: "utf-8"
+      });
+      process.stdout.write(String(stdout));
+      if (!String(stdout).endsWith("\n")) process.stdout.write("\n");
+    } catch (e) {
+      console.error(`[describe-task-executor-capabilities] Executor failed: ${e.message ?? e}`);
+      process.exit(1);
+    }
   }
-}
-function decodeCallbackToken2(token) {
-  try {
-    const payload = JSON.parse(Buffer.from(token, "base64url").toString());
-    if (typeof payload?.t === "string") return { taskName: payload.t };
-    return null;
-  } catch {
-    return null;
+  function cmdHelp() {
+    console.log(`
+board-live-cards-cli \u2014 LiveCards board CLI
+
+USAGE
+  board-live-cards-cli <command> [options]
+
+BOARD MANAGEMENT
+  init <dir> [--task-executor <script>] [--chat-handler <script>] [--inference-adapter <script>] [--runtime-out <dir>]
+    Create a new board in <dir>.
+    If --task-executor is given, writes <dir>/.task-executor with the script path.
+    If --chat-handler is given, writes <dir>/.chat-handler with the script path.
+    If --inference-adapter is given, writes <dir>/.inference-adapter with the script path.
+    Writes <dir>/.runtime-out (default: <dir>/runtime-out).
+    Published runtime files:
+      <runtime-out>/board-livegraph-status.json
+      <runtime-out>/cards/<card-id>.computed.json
+    Re-running init on an existing board is safe; handler registrations are updated.
+
+  status --rg <dir> [--json]
+    Read and print the published status snapshot from <runtime-out>/board-livegraph-status.json.
+    --json emits the stable machine-readable status object.
+
+CARD MANAGEMENT
+  upsert-card --rg <dir> (--card <card.json> | --card-glob <glob>) [--card-id <card-id>] [--restart]
+    Insert or update one or many cards.
+    Enforces strict one-to-one mapping between card id and file path:
+      - same id + same file path: update
+      - new id + new file path: insert
+      - id remap or file remap: rejected
+    If --card-id is provided, it must match the id inside the file.
+    --card-id is valid only with --card (single file), not with --card-glob.
+    --restart clears the task so it re-triggers from scratch.
+
+  validate-card (--card <card.json> | --card-glob <glob>) [--rg <boardDir>]
+    Validate one or many card JSON files without adding them to a board.
+    Checks JSON Schema structure, runtime expression syntax, and provides.ref namespaces.
+    When --rg is provided, also invokes the board's task executor validate-source-def
+    subcommand to structurally validate each source definition against supported kinds.
+    Exits with code 1 if any card fails validation.
+
+  remove-card --rg <dir> --id <card-id>
+    Remove a card and its task from the board.
+
+  retrigger --rg <dir> --task <task-name>
+    Mark a task not-started and drain to re-trigger it.
+
+TASK CALLBACKS  (called by task executor scripts)
+  task-completed --token <callbackToken> [--data <json>]
+    Signal successful task completion with optional JSON result data.
+
+  task-failed --token <callbackToken> [--error <message>]
+    Signal task failure with an optional error message.
+
+  task-progress --rg <dir> --token <callbackToken> [--update <json>]
+    Signal task progress with optional update payload (for waiting on more evidence, etc.).
+
+SOURCE CALLBACKS  (called internally by run-sourcedefs-internal)
+  source-data-fetched --tmp <file> --token <sourceToken>
+    Atomically rename <file> into the outputFile destination and record delivery
+    via journal events. Appends a task-progress event to re-invoke the card handler.
+
+  source-data-fetch-failure --token <sourceToken> [--reason <message>]
+    Record a source fetch failure via journal events and append a task-progress event.
+
+INTERNAL COMMANDS
+  process-accumulated-events --rg <dir>
+    Executes forced drain for this board.
+    This command is also used as the background relay worker.
+    By default it schedules a detached worker and returns quickly.
+    Internal workers run with --inline-loop to perform the settle loop.
+
+    Eventual-progress guarantee is relay-based (not per-call blocking guarantee):
+    1) at least one runner continues processing,
+    2) no crash/forced exit in relay window,
+    3) lock stays healthy,
+    4) event production eventually quiesces.
+
+  run-sourcedefs-internal --card <card.json> --token <callbackToken> --rg <dir>
+    Execute all source[] entries for a card, then report delivery or failure.
+    (Internal command \u2014 invoked by the card-handler. Not intended for direct use.)
+
+    If <dir>/.task-executor exists, invokes it with run-source-fetch subcommand:
+      <executor> run-source-fetch --in <source_json> --out <outfile> --err <errfile>
+
+    If no .task-executor is registered, uses board-live-cards built-in run-source-fetch.
+
+  run-source-fetch --in <source.json> --out <result.json> [--err <error.txt>]
+    Execute a source definition. Board-live-cards reads source.cli and executes it.
+    Writes result to --out. Presence of --out after exit indicates success.
+
+  describe-task-executor-capabilities --rg <dir>
+    Invoke the registered task-executor's describe-capabilities subcommand and
+    print its capabilities JSON to stdout.  Requires a .task-executor file in <dir>.
+
+  probe-source --card <card.json> [--source-idx <n>] [--source-bind <name>]
+               [--mock-projections <json>] [--rg <boardDir>] [--out <result.json>]
+    Validate that a card source can be fetched successfully.
+    Reads the card file, extracts the chosen source (default: index 0), builds the
+    run-source-fetch --in payload with the supplied _projections data, invokes the
+    registered task-executor (or built-in executor for source.cli), and reports pass/fail.
+    --mock-projections:     JSON string (or @file.json) providing pre-resolved _projections values
+                     the source needs.  Craft the minimal payload that exercises the
+                     source \u2014 e.g. '{"holdings":[{"ticker":"AAPL","quantity":10}]}'.
+                     If omitted, _projections is passed as empty ({}).
+    --source-idx:    0-based index into card.source_defs[]. Default: 0.
+    --source-bind:   Select source by its bindTo name instead of index.
+    --rg:            Board directory used to find .task-executor. Defaults to the
+                     directory containing the card file.
+    --out:           Optional path to write the raw fetch result JSON.
+    Prints a structured report ending with a [probe-source:result] JSON line.
+    Exits 0 on PROBE_PASS, 1 on PROBE_FAIL.
+
+  run-inference-internal --in <input.json> --token <inferenceToken>
+    Execute inference via registered .inference-adapter and forward result to inference-done.
+    inferenceToken encodes boardDir (rg), cardId (cid), callbackToken (cbk), checksum (cs).
+    (Internal command \u2014 invoked by the card-handler when custom completion rule is used.)
+
+  inference-done --tmp <result.json> --token <inferenceToken>
+    Persist llm_task_completion_inference on the card and append a task-progress event.
+    Reads boardDir/callbackToken/checksum from decoded inferenceToken; deletes --tmp file after reading.
+    (Internal command \u2014 invoked by run-inference-internal.)
+
+RUN-SOURCE-FETCH PROTOCOL
+  External task-executors implement:
+    <executor> run-source-fetch --in <source.json> --out <result.json> [--err <error.txt>]
+
+  INPUT:   --in file contains the full source_defs[x] definition object
+  OUTPUT:  --out file is written with the result to signal success.
+           --err file may be written to explain failure.
+
+  Exit code and --out presence determine success:
+    Exit 0 + --out file present \u2192 source delivery recorded, card re-evaluated.
+    Exit non-zero OR --out absent \u2192 source-data-fetch-failure recorded.
+
+BOARD-LIVE-CARDS BUILT-IN EXECUTOR
+  Understands source.cli field only:
+    "source_defs": [{ "cli": "node ../fetch-prices.js", "bindTo": "prices", "outputFile": "prices.json" }]
+
+  The source.cli command is executed with:
+    - Direct command invocation (no shell; quote-aware argument parsing)
+    - Stdout is captured and delivered to the card as-is
+    - Timeout from source.timeout (default 120s)
+
+  The source.cli command must:
+    - Execute successfully (exit 0)
+    - Write output to stdout
+    - Complete within the timeout
+
+  The output format is the concern of the card's compute function to interpret.
+
+  External task-executors can interpret source definitions however they want.
+
+EXAMPLES
+  board-live-cards-cli init ./my-board
+  board-live-cards-cli init ./my-board --task-executor ./executors/my-runner.py
+  board-live-cards-cli upsert-card --rg ./my-board --card cards/prices.json
+  board-live-cards-cli status --rg ./my-board
+  board-live-cards-cli retrigger --rg ./my-board --task price-fetch
+  board-live-cards-cli probe-source --card cards/card-market-prices.json --source-idx 0 --rg ./my-board --mock-projections '{"holdings":[{"ticker":"AAPL","quantity":10}]}'
+`.trimStart());
   }
+  return {
+    cmdHelp,
+    cmdRunSourceFetch,
+    cmdProbeSource,
+    cmdDescribeTaskExecutorCapabilities
+  };
 }
-function encodeSourceToken(payload) {
-  return Buffer.from(JSON.stringify(payload)).toString("base64url");
-}
-function decodeSourceToken(token) {
-  try {
-    const p = JSON.parse(Buffer.from(token, "base64url").toString());
-    if (typeof p?.cbk === "string" && typeof p?.cid === "string" && typeof p?.b === "string" && typeof p?.d === "string") {
-      return p;
+function createCardCommandHandlers(deps) {
+  function cmdUpsertCard(args) {
+    const rgIdx = args.indexOf("--rg");
+    const cardIdx = args.indexOf("--card");
+    const globIdx = args.indexOf("--card-glob");
+    const cardIdIdx = args.indexOf("--card-id");
+    const restart = args.includes("--restart");
+    const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
+    const cardFile = cardIdx !== -1 ? args[cardIdx + 1] : void 0;
+    const cardGlob = globIdx !== -1 ? args[globIdx + 1] : void 0;
+    const requestedCardId = cardIdIdx !== -1 ? args[cardIdIdx + 1] : void 0;
+    if (!dir || !cardFile && !cardGlob || cardFile && cardGlob) {
+      console.error("Usage: board-live-cards upsert-card --rg <dir> (--card <card.json> | --card-glob <glob>) [--card-id <card-id>] [--restart]");
+      process.exit(1);
+    }
+    if (cardGlob && requestedCardId) {
+      console.error("Usage: --card-id may be used only with --card (single file), not with --card-glob");
+      process.exit(1);
+    }
+    const cardFiles = cardFile ? [path7.resolve(cardFile)] : deps.resolveCardGlobMatches(cardGlob);
+    if (!cardFile && cardFiles.length === 0) {
+      console.error(`No card files matched glob: ${cardGlob}`);
+      process.exit(1);
+    }
+    const idx = deps.buildCardInventoryIndex(dir);
+    const batchByCardId = /* @__PURE__ */ new Map();
+    const batchByCardPath = /* @__PURE__ */ new Map();
+    const plans = [];
+    const logs = [];
+    for (const absCardPath of cardFiles) {
+      if (!fs7.existsSync(absCardPath)) {
+        console.error(`Card file not found: ${absCardPath}`);
+        process.exit(1);
+      }
+      const card = JSON.parse(fs7.readFileSync(absCardPath, "utf-8"));
+      if (!card.id) {
+        console.error(`Card JSON must have an "id" field (${absCardPath})`);
+        process.exit(1);
+      }
+      if (requestedCardId && requestedCardId !== card.id) {
+        console.error(
+          `Card id mismatch: --card-id "${requestedCardId}" does not match file id "${card.id}" (${absCardPath})`
+        );
+        process.exit(1);
+      }
+      const seenPathCardId = batchByCardPath.get(absCardPath);
+      if (seenPathCardId && seenPathCardId !== card.id) {
+        console.error(
+          `Upsert rejected: file "${absCardPath}" appears multiple times in batch with conflicting ids ("${seenPathCardId}" vs "${card.id}")`
+        );
+        process.exit(1);
+      }
+      const seenCardPath = batchByCardId.get(card.id);
+      if (seenCardPath && seenCardPath !== absCardPath) {
+        console.error(
+          `Upsert rejected: card id "${card.id}" appears multiple times in batch with conflicting files ("${seenCardPath}" vs "${absCardPath}")`
+        );
+        process.exit(1);
+      }
+      const existingById = idx.byCardId.get(card.id);
+      const existingByPath = idx.byCardPath.get(absCardPath);
+      if (existingByPath && existingByPath.cardId !== card.id) {
+        console.error(
+          `Upsert rejected: file "${absCardPath}" is already mapped to card id "${existingByPath.cardId}", cannot remap to "${card.id}"`
+        );
+        process.exit(1);
+      }
+      if (existingById && existingById.cardFilePath !== absCardPath) {
+        console.error(
+          `Upsert rejected: card id "${card.id}" is already mapped to file "${existingById.cardFilePath}", cannot remap to "${absCardPath}"`
+        );
+        process.exit(1);
+      }
+      batchByCardPath.set(absCardPath, card.id);
+      batchByCardId.set(card.id, absCardPath);
+      plans.push({
+        card,
+        absCardPath,
+        isInsert: !existingById
+      });
+    }
+    for (const plan of plans) {
+      const { card, absCardPath, isInsert } = plan;
+      if (isInsert) {
+        const newEntry = {
+          cardId: card.id,
+          cardFilePath: absCardPath,
+          addedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        deps.appendCardInventory(dir, newEntry);
+        idx.byCardId.set(card.id, newEntry);
+        idx.byCardPath.set(absCardPath, newEntry);
+      }
+      const taskConfig = deps.liveCardToTaskConfig(card);
+      deps.appendEventToJournal(dir, {
+        type: "task-upsert",
+        taskName: card.id,
+        taskConfig,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (restart) {
+        deps.appendEventToJournal(dir, {
+          type: "task-restart",
+          taskName: card.id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      logs.push(`Card "${card.id}" ${isInsert ? "upserted (inserted)" : "upserted (updated)"}${restart ? " (restarted)" : ""}.`);
+    }
+    void deps.processAccumulatedEventsInfinitePass(dir);
+    if (cardGlob) {
+      console.log(`Upserted ${cardFiles.length} cards from glob: ${cardGlob}${restart ? " (restarted)" : ""}`);
+    } else {
+      console.log(logs[0]);
     }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function markRequested(entry, requestedAt) {
-  entry.lastRequestedAt = requestedAt;
-}
-function markFetchFailed(entry, reason) {
-  entry.lastError = reason;
-  delete entry.lastFetchedAt;
-}
-function markFetchCompleted(entry, fetchedAt) {
-  entry.lastFetchedAt = fetchedAt;
-  delete entry.lastError;
-}
-function isSourceInFlight(entry) {
-  if (!entry?.lastRequestedAt) return false;
-  return !entry.lastFetchedAt || entry.lastFetchedAt < entry.lastRequestedAt;
-}
-function decideSourceAction(entry, queueRequestedAt) {
-  if (!entry?.lastRequestedAt) return "dispatch";
-  const inFlight = isSourceInFlight(entry);
-  if (inFlight) return "in-flight";
-  if (!entry.lastFetchedAt) return "dispatch";
-  if (entry.lastFetchedAt < queueRequestedAt) return "dispatch";
-  return "idle";
-}
-function nextEntryAfterFetchDelivery(entry, fetchedAt) {
-  const next = { ...entry };
-  markFetchCompleted(next, fetchedAt);
-  return next;
-}
-function nextEntryAfterFetchFailure(entry, reason) {
-  const next = { ...entry };
-  markFetchFailed(next, reason);
-  return next;
-}
-function runtimePath(boardDir, cardId) {
-  return path.join(boardDir, cardId, "runtime.json");
-}
-function readRuntimeState(boardDir, cardId) {
-  const p = runtimePath(boardDir, cardId);
-  if (!fs.existsSync(p)) return { _sources: {} };
-  try {
-    return JSON.parse(fs.readFileSync(p, "utf-8"));
-  } catch {
-    return { _sources: {} };
   }
+  return { cmdUpsertCard };
 }
-function writeRuntimeState(boardDir, cardId, state) {
-  const p = runtimePath(boardDir, cardId);
-  fs.mkdirSync(path.dirname(p), { recursive: true });
-  fs.writeFileSync(p, JSON.stringify(state, null, 2));
-}
-function appendEventToJournal(boardDir, event) {
-  const journalPath = path.join(boardDir, JOURNAL_FILE);
-  const entry = { id: randomUUID(), event };
-  fs.appendFileSync(journalPath, JSON.stringify(entry) + "\n", "utf-8");
-}
-function getUndrainedEntries(boardDir, lastDrainedId) {
-  const journalPath = path.join(boardDir, JOURNAL_FILE);
-  if (!fs.existsSync(journalPath)) return [];
-  const content = fs.readFileSync(journalPath, "utf-8").trim();
-  if (!content) return [];
-  const entries = content.split("\n").map((l) => JSON.parse(l));
-  if (!lastDrainedId) return entries;
-  const idx = entries.findIndex((e) => e.id === lastDrainedId);
-  return idx === -1 ? entries : entries.slice(idx + 1);
-}
-function determineLatestPendingAccumulated(boardDir) {
-  const boardPath = path.join(boardDir, BOARD_FILE);
-  if (!fs.existsSync(boardPath)) return 0;
-  try {
-    const envelope = loadBoardEnvelope(boardDir);
-    return getUndrainedEntries(boardDir, envelope.lastDrainedJournalId).length;
-  } catch {
-    return 0;
+function createExecutionCommandHandlers(deps) {
+  function invokeSourceDataFetched(sourceToken, tmpFile, callback) {
+    const { cmd, args } = deps.getCliInvocation("source-data-fetched", ["--tmp", tmpFile, "--token", sourceToken]);
+    deps.execCommandAsync(cmd, args, (err, stdout, stderr) => {
+      if (err) console.error(`[source-data-fetched] call failed:`, err.message);
+      if (stdout) console.log(stdout.trim());
+      if (stderr) console.error(stderr.trim());
+    });
   }
-}
-function shouldUseShellForCommand(cmd, forceShell) {
-  if (typeof forceShell === "boolean") return forceShell;
-  return process.platform === "win32" && /\.(cmd|bat)$/i.test(cmd);
-}
-var _gitBashPath;
-var GIT_BASH_CACHE_FILE = path.join(os.tmpdir(), ".board-live-cards-git-bash-cache.json");
-function findGitBash() {
-  if (_gitBashPath !== void 0) return _gitBashPath;
-  if (process.platform !== "win32") return _gitBashPath = false;
-  try {
-    const cached = JSON.parse(fs.readFileSync(GIT_BASH_CACHE_FILE, "utf8"));
-    if (cached.path === false || typeof cached.path === "string" && fs.existsSync(cached.path)) {
-      return _gitBashPath = cached.path;
+  function invokeSourceDataFetchFailure(sourceToken, reason, callback) {
+    const { cmd, args } = deps.getCliInvocation("source-data-fetch-failure", ["--token", sourceToken, "--reason", reason]);
+    deps.execCommandAsync(cmd, args, (err) => callback(err));
+  }
+  function cmdRunSources(args) {
+    const cardIdx = args.indexOf("--card");
+    const tokenIdx = args.indexOf("--token");
+    const rgIdx = args.indexOf("--rg");
+    const sourceChecksumsIdx = args.indexOf("--source-checksums");
+    const cardFilePath = cardIdx !== -1 ? args[cardIdx + 1] : void 0;
+    const callbackToken = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
+    const boardDir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
+    const sourceChecksumsJson = sourceChecksumsIdx !== -1 ? args[sourceChecksumsIdx + 1] : void 0;
+    const sourceChecksums = sourceChecksumsJson ? JSON.parse(sourceChecksumsJson) : void 0;
+    if (!cardFilePath || !callbackToken || !boardDir) {
+      console.error("Usage: board-live-cards run-sourcedefs-internal --card <path> --token <token> --rg <dir> [--source-checksums <json>]");
+      process.exit(1);
     }
-  } catch {
-  }
-  const candidates = [
-    process.env.SHELL,
-    process.env.PROGRAMFILES && path.join(process.env.PROGRAMFILES, "Git", "usr", "bin", "bash.exe"),
-    process.env.PROGRAMFILES && path.join(process.env.PROGRAMFILES, "Git", "bin", "bash.exe"),
-    process.env["PROGRAMFILES(X86)"] && path.join(process.env["PROGRAMFILES(X86)"], "Git", "bin", "bash.exe"),
-    process.env.LOCALAPPDATA && path.join(process.env.LOCALAPPDATA, "Programs", "Git", "bin", "bash.exe")
-  ];
-  for (const c of candidates) {
-    if (c && /bash(\.exe)?$/i.test(c) && fs.existsSync(c)) {
-      _gitBashPath = c;
+    const card = JSON.parse(fs7.readFileSync(cardFilePath, "utf-8"));
+    if (path7.basename(cardFilePath).startsWith("card-enriched-")) {
       try {
-        fs.writeFileSync(GIT_BASH_CACHE_FILE, JSON.stringify({ path: c }));
+        fs7.unlinkSync(cardFilePath);
       } catch {
       }
-      return _gitBashPath;
+    }
+    console.log(`[run-sourcedefs-internal] Processing card "${card.id}"`);
+    const teConfig = deps.readTaskExecutorConfig(boardDir);
+    const taskExecutor = teConfig?.command;
+    const taskExecutorExtraB64 = teConfig?.extra ? Buffer.from(JSON.stringify(teConfig.extra)).toString("base64") : void 0;
+    function runSource(src) {
+      const sourceChecksumForInvoke = src.outputFile ? sourceChecksums?.[src.outputFile] : void 0;
+      const sourceToken = deps.encodeSourceToken({
+        cbk: callbackToken,
+        rg: boardDir,
+        cid: card.id,
+        b: src.bindTo,
+        d: src.outputFile ?? "",
+        cs: sourceChecksumForInvoke
+      });
+      function reportFailure(reason) {
+        invokeSourceDataFetchFailure(sourceToken, reason, (err) => {
+          if (err) console.error(`[run-sourcedefs-internal] source-data-fetch-failure call failed:`, err.message);
+        });
+      }
+      function reportFetched(outFile2) {
+        invokeSourceDataFetched(sourceToken, outFile2);
+      }
+      if (taskExecutor) {
+        if (!src.outputFile) {
+          console.warn(`[run-sourcedefs-internal] source "${src.bindTo}" has no outputFile configured \u2014 cannot deliver`);
+          reportFailure("no outputFile configured");
+          return;
+        }
+        const inFile = path7.join(os3.tmpdir(), `card-source-in-${src.bindTo}-${Date.now()}.json`);
+        const outFile2 = path7.join(os3.tmpdir(), `card-source-out-${src.bindTo}-${Date.now()}.json`);
+        const errFile = path7.join(os3.tmpdir(), `card-source-err-${src.bindTo}-${Date.now()}.txt`);
+        const sourceForExecutor = {
+          ...src,
+          cwd: typeof src.cwd === "string" && src.cwd ? src.cwd : path7.dirname(cardFilePath || ""),
+          boardDir: typeof src.boardDir === "string" && src.boardDir ? src.boardDir : boardDir
+        };
+        deps.appendTaskExecutorLog(boardDir, sourceForExecutor, "external-task-executor");
+        fs7.writeFileSync(inFile, JSON.stringify(sourceForExecutor, null, 2), "utf-8");
+        const executorArgs = ["run-source-fetch", "--in", inFile, "--out", outFile2, "--err", errFile];
+        if (taskExecutorExtraB64) executorArgs.push("--extra", taskExecutorExtraB64);
+        console.log(`[run-sourcedefs-internal] task-executor: ${taskExecutor} ${executorArgs.join(" ")}`);
+        try {
+          deps.execCommandSync(taskExecutor, executorArgs, {
+            shell: true,
+            timeout: src.timeout ?? 12e4
+          });
+        } catch (err) {
+          const reason = err.message ?? String(err);
+          console.error(`[run-sourcedefs-internal] task-executor failed for source "${src.bindTo}":`, reason);
+          reportFailure(reason);
+          return;
+        }
+        if (fs7.existsSync(outFile2)) {
+          reportFetched(outFile2);
+        } else {
+          const errMsg = fs7.existsSync(errFile) ? fs7.readFileSync(errFile, "utf-8").trim() : "executor produced no output file";
+          console.warn(`[run-sourcedefs-internal] source "${src.bindTo}": ${errMsg}`);
+          reportFailure(errMsg);
+        }
+        return;
+      }
+      if (!src.outputFile) {
+        console.warn(`[run-sourcedefs-internal] source "${src.bindTo}" has no outputFile configured \u2014 cannot deliver`);
+        reportFailure("no outputFile configured");
+        return;
+      }
+      const outFile = path7.join(os3.tmpdir(), `card-source-out-${src.bindTo}-${Date.now()}.json`);
+      if (!src.cli) {
+        const errMsg = "source.cli is required for built-in source execution";
+        console.warn(`[run-sourcedefs-internal] source "${src.bindTo}": ${errMsg}`);
+        reportFailure(errMsg);
+        return;
+      }
+      const timeout = src.timeout ?? 12e4;
+      const sourceCwd = typeof src.cwd === "string" ? src.cwd : path7.dirname(cardFilePath || "");
+      const sourceBoardDir = typeof src.boardDir === "string" ? src.boardDir : boardDir;
+      const sourceForBuiltInExecutor = {
+        ...src,
+        cwd: sourceCwd,
+        boardDir: sourceBoardDir
+      };
+      deps.appendTaskExecutorLog(boardDir, sourceForBuiltInExecutor, "built-in-run-source-fetch");
+      const cmdParts = deps.splitCommandLine(src.cli);
+      if (cmdParts.length === 0) {
+        const errMsg = "source.cli command is empty";
+        console.warn(`[run-sourcedefs-internal] source "${src.bindTo}": ${errMsg}`);
+        reportFailure(errMsg);
+        return;
+      }
+      const rawCmd = cmdParts[0];
+      const { cmd, args: cliArgs } = deps.resolveCommandInvocation(rawCmd, cmdParts.slice(1));
+      let stdout;
+      try {
+        stdout = deps.execCommandSync(cmd, cliArgs, {
+          shell: false,
+          encoding: "utf-8",
+          timeout,
+          cwd: sourceCwd,
+          env: {
+            ...process.env,
+            ...sourceBoardDir ? { BOARD_DIR: sourceBoardDir } : {}
+          }
+        });
+      } catch (err) {
+        const reason = err.message ?? String(err);
+        console.error(`[run-sourcedefs-internal] source fetch failed for source "${src.bindTo}":`, reason);
+        reportFailure(reason);
+        return;
+      }
+      fs7.writeFileSync(outFile, stdout.trim(), "utf-8");
+      reportFetched(outFile);
+    }
+    const source_defs = card.source_defs ?? [];
+    for (const src of source_defs) {
+      runSource(src);
     }
   }
-  _gitBashPath = false;
-  try {
-    fs.writeFileSync(GIT_BASH_CACHE_FILE, JSON.stringify({ path: false }));
-  } catch {
-  }
-  return _gitBashPath;
-}
-function shellQuote(s) {
-  return "'" + s.replace(/'/g, "'\\''") + "'";
-}
-function spawnDetachedCommand(cmd, args) {
-  if (process.platform === "win32") {
-    const bash = findGitBash();
-    if (bash) {
-      const shellCmd = [cmd, ...args].map((a) => shellQuote(a.replace(/\\/g, "/"))).join(" ");
-      const child3 = spawn(bash, ["-c", shellCmd], { detached: true, stdio: "ignore", windowsHide: true });
-      child3.unref();
+  function cmdRunInference(args) {
+    const inIdx = args.indexOf("--in");
+    const tokenIdx = args.indexOf("--token");
+    const inFile = inIdx !== -1 ? args[inIdx + 1] : void 0;
+    const inferenceToken = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
+    if (!inFile || !inferenceToken) {
+      console.error("Usage: board-live-cards run-inference-internal --in <input.json> --token <inference-token>");
+      process.exit(1);
+    }
+    const decodedToken = deps.decodeSourceToken(inferenceToken);
+    if (!decodedToken) {
+      console.error("Invalid inference token");
+      process.exit(1);
+    }
+    const callbackToken = decodedToken.cbk;
+    const boardDir = decodedToken.rg;
+    const cbkDecoded = deps.decodeCallbackToken(callbackToken);
+    if (!cbkDecoded) {
+      console.error("Invalid callback token embedded in inference token");
+      process.exit(1);
+    }
+    function spawnInferenceDone(tmpFile) {
+      const { cmd, args: cliArgs } = deps.getCliInvocation("inference-done", ["--tmp", tmpFile, "--token", inferenceToken]);
+      deps.spawnDetachedCommand(cmd, cliArgs);
+    }
+    function spawnInferenceDoneError(reason) {
+      const tmpFile = path7.join(os3.tmpdir(), `card-inference-err-${Date.now()}.json`);
+      fs7.writeFileSync(tmpFile, JSON.stringify({ isTaskCompleted: false, reason }), "utf-8");
+      spawnInferenceDone(tmpFile);
+    }
+    if (!fs7.existsSync(inFile)) {
+      spawnInferenceDoneError(`inference input not found: ${inFile}`);
       return;
     }
-    const child2 = spawn("cmd", ["/c", "start", "/b", "", cmd, ...args], {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true
-    });
-    child2.unref();
-    return;
-  }
-  const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
-  child.unref();
-}
-function execCommandSync(cmd, args, options) {
-  const output = execFileSync(cmd, args, {
-    shell: shouldUseShellForCommand(cmd, options?.shell),
-    timeout: options?.timeout,
-    encoding: options?.encoding,
-    cwd: options?.cwd,
-    windowsHide: true,
-    env: options?.env
-  });
-  return typeof output === "string" ? output : output.toString("utf-8");
-}
-function execCommandAsync(cmd, args, callback) {
-  execFile(
-    cmd,
-    args,
-    { shell: shouldUseShellForCommand(cmd), encoding: "utf8", windowsHide: true },
-    (err, stdout, stderr) => callback(err ?? null, stdout, stderr)
-  );
-}
-function splitCommandLine(command) {
-  const tokens = [];
-  let current = "";
-  let quote = null;
-  for (const ch of command.trim()) {
-    if (quote) {
-      if (ch === quote) {
-        quote = null;
-      } else {
-        current += ch;
-      }
-      continue;
+    const adapterFile = path7.join(boardDir, deps.INFERENCE_ADAPTER_FILE);
+    const inferenceAdapter = fs7.existsSync(adapterFile) ? fs7.readFileSync(adapterFile, "utf-8").trim() : void 0;
+    if (!inferenceAdapter) {
+      spawnInferenceDoneError(`inference adapter is not configured (${deps.INFERENCE_ADAPTER_FILE})`);
+      return;
+    }
+    const outFile = path7.join(os3.tmpdir(), `card-inference-out-${Date.now()}.json`);
+    const errFile = path7.join(os3.tmpdir(), `card-inference-err-${Date.now()}.txt`);
+    const adapterParts = deps.splitCommandLine(inferenceAdapter);
+    if (adapterParts.length === 0) {
+      spawnInferenceDoneError("inference adapter command is empty");
+      return;
+    }
+    const adapterRawCmd = adapterParts[0];
+    const adapterRawArgs = adapterParts.slice(1);
+    const { cmd: adapterCmd, args: adapterArgsPrefix } = deps.resolveCommandInvocation(adapterRawCmd, adapterRawArgs);
+    const adapterArgs = [...adapterArgsPrefix, "run-inference", "--in", inFile, "--out", outFile, "--err", errFile];
+    try {
+      deps.execCommandSync(adapterCmd, adapterArgs, {
+        shell: false,
+        timeout: 12e4,
+        cwd: boardDir,
+        env: {
+          ...process.env,
+          BOARD_DIR: boardDir
+        }
+      });
+    } catch (err) {
+      const reason = err.message ?? String(err);
+      spawnInferenceDoneError(reason);
+      return;
     }
-    if (ch === '"' || ch === "'") {
-      quote = ch;
-      continue;
+    if (!fs7.existsSync(outFile)) {
+      const errMsg = fs7.existsSync(errFile) ? fs7.readFileSync(errFile, "utf-8").trim() : "inference adapter produced no output file";
+      spawnInferenceDoneError(errMsg);
+      return;
     }
-    if (/\s/.test(ch)) {
-      if (current) {
-        tokens.push(current);
-        current = "";
+    spawnInferenceDone(outFile);
+  }
+  function cmdInferenceDone(args) {
+    const tmpIdx = args.indexOf("--tmp");
+    const tokenIdx = args.indexOf("--token");
+    const tmpFile = tmpIdx !== -1 ? args[tmpIdx + 1] : void 0;
+    const inferenceToken = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
+    if (!tmpFile || !inferenceToken) {
+      console.error("Usage: board-live-cards inference-done --tmp <result.json> --token <inference-token>");
+      process.exit(1);
+    }
+    const decodedToken = deps.decodeSourceToken(inferenceToken);
+    if (!decodedToken) {
+      console.error("Invalid inference token");
+      process.exit(1);
+    }
+    const { cbk: callbackToken, rg: dir, cs: inputChecksum } = decodedToken;
+    const decoded = deps.decodeCallbackToken(callbackToken);
+    if (!decoded) {
+      console.error("Invalid callback token embedded in inference token");
+      process.exit(1);
+    }
+    const taskName = decoded.taskName;
+    const cardPath = deps.lookupCardPath(dir, taskName);
+    if (!cardPath) {
+      console.error(`Card file for task "${taskName}" not found in inventory`);
+      process.exit(1);
+    }
+    let result = {};
+    if (fs7.existsSync(tmpFile)) {
+      try {
+        result = JSON.parse(fs7.readFileSync(tmpFile, "utf-8").trim());
+      } catch (err) {
+        result = { isTaskCompleted: false, reason: `failed to parse inference result: ${err instanceof Error ? err.message : String(err)}` };
+      }
+      try {
+        fs7.unlinkSync(tmpFile);
+      } catch {
+      }
+    } else {
+      result = { isTaskCompleted: false, reason: `inference result file not found: ${tmpFile}` };
+    }
+    const isTaskCompletedFlag = result.isTaskCompleted === true;
+    const inferenceCompletedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const card = JSON.parse(fs7.readFileSync(cardPath, "utf-8"));
+    if (!card.card_data) card.card_data = {};
+    const cardData = card.card_data;
+    const existingInference = cardData.llm_task_completion_inference && typeof cardData.llm_task_completion_inference === "object" ? cardData.llm_task_completion_inference : {};
+    cardData.llm_task_completion_inference = {
+      ...existingInference,
+      isTaskCompleted: isTaskCompletedFlag,
+      reason: typeof result.reason === "string" ? result.reason : "",
+      evidence: typeof result.evidence === "string" ? result.evidence : "",
+      inferenceCompletedAt
+    };
+    fs7.writeFileSync(cardPath, JSON.stringify(card, null, 2), "utf-8");
+    const runtimePath = path7.join(dir, taskName, "runtime.json");
+    let runtime = { _sources: {} };
+    if (fs7.existsSync(runtimePath)) {
+      try {
+        runtime = JSON.parse(fs7.readFileSync(runtimePath, "utf-8"));
+      } catch {
       }
-      continue;
     }
-    current += ch;
-  }
-  if (quote) {
-    throw new Error(`Unterminated quote in command: ${command}`);
+    const inferenceEntry = runtime._inferenceEntry ?? {};
+    runtime._inferenceEntry = deps.nextEntryAfterFetchDelivery(inferenceEntry, inferenceCompletedAt);
+    fs7.mkdirSync(path7.dirname(runtimePath), { recursive: true });
+    fs7.writeFileSync(runtimePath, JSON.stringify(runtime, null, 2), "utf-8");
+    deps.appendEventToJournal(dir, {
+      type: "task-progress",
+      taskName,
+      update: {
+        kind: "inference-done",
+        isTaskCompleted: isTaskCompletedFlag,
+        inputChecksum
+      },
+      timestamp: inferenceCompletedAt
+    });
+    void deps.processAccumulatedEventsInfinitePass(dir);
+  }
+  async function cmdTryDrain(args) {
+    const rgIdx = args.indexOf("--rg");
+    const inlineLoop = args.includes("--inline-loop");
+    const boardDir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
+    if (!boardDir) {
+      console.error("Usage: board-live-cards process-accumulated-events --rg <dir>");
+      process.exit(1);
+    }
+    await deps.processAccumulatedEventsForced(boardDir, { inlineLoop });
   }
-  if (current) tokens.push(current);
-  return tokens;
+  return { cmdRunSources, cmdRunInference, cmdInferenceDone, cmdTryDrain };
 }
-function resolveCommandInvocation(rawCmd, rawArgs) {
-  if (/^(node|node\.exe)$/i.test(rawCmd)) {
-    return { cmd: process.execPath, args: rawArgs };
-  }
-  if (/\.m?js$/i.test(rawCmd)) {
-    return { cmd: process.execPath, args: [rawCmd, ...rawArgs] };
+function deepGet(obj, path8) {
+  if (!path8 || !obj) return void 0;
+  const parts = path8.split(".");
+  let cur = obj;
+  for (let i = 0; i < parts.length; i++) {
+    if (cur == null) return void 0;
+    cur = cur[parts[i]];
   }
-  return { cmd: rawCmd, args: rawArgs };
+  return cur;
 }
-function spawnDetachedProcessAccumulatedWorker(boardDir) {
-  const { cmd, args: cliArgs } = getCliInvocation("process-accumulated-events", ["--rg", boardDir, "--inline-loop"]);
-  try {
-    spawnDetachedCommand(cmd, cliArgs);
-    return true;
-  } catch {
-    return false;
+function deepSet(obj, path8, value) {
+  const parts = path8.split(".");
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (cur[parts[i]] == null || typeof cur[parts[i]] !== "object") cur[parts[i]] = {};
+    cur = cur[parts[i]];
   }
+  cur[parts[parts.length - 1]] = value;
 }
-async function processAccumulatedEventsInlineLoop(boardDir, settleDelayMs = 50) {
-  while (determineLatestPendingAccumulated(boardDir) > 0) {
-    const ran = await processAccumulatedEvents(boardDir);
-    if (!ran) return false;
-    await new Promise((resolve3) => setTimeout(resolve3, settleDelayMs));
+async function run(node, options) {
+  if (!node?.compute?.length) return node;
+  if (!node.card_data) node.card_data = {};
+  node.computed_values = {};
+  node._sourcesData = options?.sourcesData ?? {};
+  const ctx = {
+    card_data: node.card_data,
+    requires: node.requires ?? {},
+    fetched_sources: node._sourcesData,
+    computed_values: node.computed_values
+  };
+  for (const step of node.compute) {
+    try {
+      const val = await jsonata2(step.expr).evaluate(ctx);
+      deepSet(node.computed_values, step.bindTo, val);
+      ctx.computed_values = node.computed_values;
+    } catch (err) {
+      console.error(`CardCompute.run error on "${node.id ?? "?"}.${step.bindTo}":`, err);
+    }
   }
-  return true;
-}
-function shouldAvoidDetachedProcessSpawn() {
-  return process.env.BOARD_LIVE_CARDS_NO_SPAWN === "1";
+  return node;
 }
-async function processAccumulatedEvents(boardDir) {
-  const boardPath = path.join(boardDir, BOARD_FILE);
-  let release;
-  try {
-    release = lockSync(boardPath, { retries: 0 });
-  } catch {
-    return false;
-  }
-  try {
-    const { rg, journal } = createBoardReactiveGraph(boardDir);
-    const undrained = journal.drain();
-    rg.pushAll(undrained);
-    await rg.dispose({ wait: true });
-    saveBoard(boardDir, rg, journal);
-    return true;
-  } finally {
-    release();
-  }
+async function evalExpr(expr, node) {
+  const ctx = {
+    card_data: node.card_data ?? {},
+    requires: node.requires ?? {},
+    fetched_sources: node._sourcesData ?? {},
+    computed_values: node.computed_values ?? {}
+  };
+  return jsonata2(expr).evaluate(ctx);
 }
-async function processAccumulatedEventsInfinitePass(boardDir, settleDelayMs = 50, options) {
-  if (options?.inlineLoop || shouldAvoidDetachedProcessSpawn()) {
-    return processAccumulatedEventsInlineLoop(boardDir, settleDelayMs);
+function resolve4(node, path8) {
+  if (path8.startsWith("fetched_sources.")) {
+    return deepGet(node._sourcesData ?? {}, path8.slice("fetched_sources.".length));
   }
-  return spawnDetachedProcessAccumulatedWorker(boardDir);
-}
-async function processAccumulatedEventsForced(boardDir, options) {
-  await processAccumulatedEvents(boardDir);
-  await processAccumulatedEventsInfinitePass(boardDir, 50, options);
-}
-function liveCardToTaskConfig(card) {
-  const requires = card.requires;
-  const provides = card.provides?.map((p) => p.bindTo) ?? [];
-  return {
-    requires: requires && requires.length > 0 ? requires : void 0,
-    provides,
-    taskHandlers: ["card-handler"],
-    description: card.meta?.title ?? card.id
-  };
+  return deepGet(node, path8);
 }
-var __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
-var REPO_ROOT = path.resolve(__dirname$1, "..", "..");
-var LOCAL_TSX_CLI = path.join(REPO_ROOT, "node_modules", "tsx", "dist", "cli.mjs");
-function getCliInvocation(command, args) {
-  const jsPath = path.join(__dirname$1, "board-live-cards-cli.js");
-  if (fs.existsSync(jsPath)) {
-    return { cmd: process.execPath, args: [jsPath, command, ...args] };
+var VALID_ELEMENT_KINDS = /* @__PURE__ */ new Set([
+  "metric",
+  "table",
+  "editable-table",
+  "chart",
+  "form",
+  "filter",
+  "list",
+  "notes",
+  "todo",
+  "alert",
+  "narrative",
+  "badge",
+  "text",
+  "markdown",
+  "ref",
+  "custom",
+  "actions"
+]);
+var ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "meta", "requires", "provides", "view", "card_data", "compute", "source_defs"]);
+function validateNode(node) {
+  const errors = [];
+  if (!node || typeof node !== "object" || Array.isArray(node)) {
+    return { ok: false, errors: ["Node must be a non-null object"] };
   }
-  const tsPath = path.join(__dirname$1, "board-live-cards-cli.ts");
-  if (fs.existsSync(tsPath) && fs.existsSync(LOCAL_TSX_CLI)) {
-    return { cmd: process.execPath, args: [LOCAL_TSX_CLI, tsPath, command, ...args] };
+  const n = node;
+  if (typeof n.id !== "string" || !n.id) errors.push("id: required, must be a non-empty string");
+  for (const key of Object.keys(n)) {
+    if (!ALLOWED_KEYS.has(key)) errors.push(`Unknown top-level key: "${key}"`);
   }
-  const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
-  return { cmd: npxCmd, args: ["tsx", tsPath, command, ...args] };
-}
-function invokeRunSources(boardDir, cardPath, callbackToken, callback) {
-  const args = ["--card", cardPath, "--token", callbackToken, "--rg", boardDir];
-  const { cmd, args: cmdArgs } = getCliInvocation("run-sourcedefs-internal", args);
-  try {
-    spawnDetachedCommand(cmd, cmdArgs);
-    callback(null);
-  } catch (err) {
-    callback(err instanceof Error ? err : new Error(String(err)));
+  if (n.card_data == null || typeof n.card_data !== "object" || Array.isArray(n.card_data)) {
+    errors.push("card_data: required, must be an object");
   }
-}
-function invokeRunInference(boardDir, cardId, inputFile, callbackToken, checksum, callback) {
-  const inferenceToken = encodeSourceToken({ cbk: callbackToken, rg: boardDir, cid: cardId, b: "", d: "", cs: checksum });
-  const { cmd, args } = getCliInvocation("run-inference-internal", ["--in", inputFile, "--token", inferenceToken]);
-  try {
-    spawnDetachedCommand(cmd, args);
-    callback(null);
-  } catch (err) {
-    callback(err instanceof Error ? err : new Error(String(err)));
+  if (n.meta != null) {
+    if (typeof n.meta !== "object" || Array.isArray(n.meta)) {
+      errors.push("meta: must be an object");
+    } else {
+      const meta = n.meta;
+      if (meta.title != null && typeof meta.title !== "string") errors.push("meta.title: must be a string");
+      if (meta.tags != null && !Array.isArray(meta.tags)) errors.push("meta.tags: must be an array");
+    }
   }
-}
-function appendTaskExecutorLog(boardDir, hydratedSource, mode) {
-  try {
-    const entry = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      mode,
-      hydratedSource
-    };
-    fs.appendFileSync(path.join(boardDir, TASK_EXECUTOR_LOG_FILE), JSON.stringify(entry) + "\n", "utf-8");
-  } catch (logErr) {
-    console.error(`[task-executor-log] append failed: ${logErr instanceof Error ? logErr.message : String(logErr)}`);
+  if (n.requires != null && !Array.isArray(n.requires)) errors.push("requires: must be an array of strings");
+  if (n.provides != null) {
+    if (!Array.isArray(n.provides)) {
+      errors.push("provides: must be an array of { bindTo, ref } bindings");
+    } else {
+      n.provides.forEach((p, i) => {
+        if (!p || typeof p !== "object" || Array.isArray(p)) {
+          errors.push(`provides[${i}]: must be an object with bindTo and ref`);
+        } else {
+          const b = p;
+          if (typeof b.bindTo !== "string" || !b.bindTo) errors.push(`provides[${i}]: missing required "bindTo" string`);
+          if (typeof b.ref !== "string" || !b.ref) errors.push(`provides[${i}]: missing required "ref" string`);
+        }
+      });
+    }
   }
-}
-function appendInferenceAdapterLog(boardDir, cardId, payload) {
-  try {
-    const entry = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      cardId,
-      payload
-    };
-    fs.appendFileSync(path.join(boardDir, INFERENCE_ADAPTER_LOG_FILE), JSON.stringify(entry) + "\n", "utf-8");
-  } catch (logErr) {
-    console.error(`[inference-adapter-log] append failed: ${logErr instanceof Error ? logErr.message : String(logErr)}`);
+  if (n.compute != null) {
+    if (!Array.isArray(n.compute)) {
+      errors.push("compute: must be an array of compute steps");
+    } else {
+      n.compute.forEach((step, i) => {
+        if (!step || typeof step !== "object" || Array.isArray(step)) {
+          errors.push(`compute[${i}]: must be a compute step object`);
+        } else {
+          const s = step;
+          if (typeof s.bindTo !== "string" || !s.bindTo) errors.push(`compute[${i}]: missing required "bindTo" property`);
+          if (typeof s.expr !== "string" || !s.expr) errors.push(`compute[${i}]: missing required "expr" string (JSONata expression)`);
+        }
+      });
+    }
   }
-}
-function invokeSourceDataFetched(sourceToken, tmpFile, callback) {
-  const { cmd, args } = getCliInvocation("source-data-fetched", ["--tmp", tmpFile, "--token", sourceToken]);
-  execCommandAsync(cmd, args, (err, stdout, stderr) => {
-    if (err) console.error(`[source-data-fetched] call failed:`, err.message);
-    if (stdout) console.log(stdout.trim());
-    if (stderr) console.error(stderr.trim());
-  });
-}
-function invokeSourceDataFetchFailure(sourceToken, reason, callback) {
-  const { cmd, args } = getCliInvocation("source-data-fetch-failure", ["--token", sourceToken, "--reason", reason]);
-  execCommandAsync(cmd, args, (err) => callback(err));
-}
-function createBoardReactiveGraph(boardDir) {
-  const envelope = loadBoardEnvelope(boardDir);
-  const live = restore(envelope.graph);
-  const journalPath = path.join(boardDir, JOURNAL_FILE);
-  const journal = new BoardJournal(journalPath, envelope.lastDrainedJournalId);
-  const handlers = {
-    "card-handler": async (input) => {
-      const cardPath = lookupCardPath(boardDir, input.nodeId);
-      if (!cardPath) return "task-initiate-failure";
-      const card = JSON.parse(fs.readFileSync(cardPath, "utf-8"));
-      const cardId = card.id;
-      const cardState = card.card_data ?? {};
-      const allSources = card.source_defs ?? [];
-      const requiredSources = allSources.filter((s) => s.optionalForCompletionGating !== true);
-      const runtime = readRuntimeState(boardDir, cardId);
-      let runtimeDirty = false;
-      const currentExecutionCount = input.taskState?.executionCount ?? 0;
-      if (typeof runtime._lastExecutionCount === "number" && runtime._lastExecutionCount !== currentExecutionCount) {
-        runtime._sources = {};
-        runtime._inferenceEntry = void 0;
-      }
-      if (runtime._lastExecutionCount !== currentExecutionCount) {
-        runtime._lastExecutionCount = currentExecutionCount;
-        runtimeDirty = true;
-      }
-      if (input.update) {
-        const u = input.update;
-        const outputFile = u.outputFile;
-        if (outputFile) {
-          if (!runtime._sources[outputFile]) runtime._sources[outputFile] = {};
-          const entry = runtime._sources[outputFile];
-          if (u.failure) {
-            runtime._sources[outputFile] = nextEntryAfterFetchFailure(entry, u.reason ?? "unknown");
-            runtimeDirty = true;
+  if (n.source_defs != null) {
+    if (!Array.isArray(n.source_defs)) {
+      errors.push("source_defs: must be an array");
+    } else {
+      const bindTos = /* @__PURE__ */ new Set();
+      const outputFiles = /* @__PURE__ */ new Set();
+      n.source_defs.forEach((src, i) => {
+        if (!src || typeof src !== "object" || Array.isArray(src)) {
+          errors.push(`source_defs[${i}]: must be an object`);
+        } else {
+          const s = src;
+          if (typeof s.bindTo !== "string" || !s.bindTo) {
+            errors.push(`source_defs[${i}]: missing required "bindTo" property`);
+          } else {
+            if (bindTos.has(s.bindTo)) {
+              errors.push(`source_defs[${i}]: bindTo "${s.bindTo}" is not unique across source_defs`);
+            }
+            bindTos.add(s.bindTo);
+          }
+          if (typeof s.outputFile !== "string" || !s.outputFile) {
+            errors.push(`source_defs[${i}]: missing required "outputFile" property`);
           } else {
-            runtime._sources[outputFile] = nextEntryAfterFetchDelivery(
-              entry,
-              u.fetchedAt ?? (/* @__PURE__ */ new Date()).toISOString()
-            );
-            runtimeDirty = true;
+            if (outputFiles.has(s.outputFile)) {
+              errors.push(`source_defs[${i}]: outputFile "${s.outputFile}" is not unique across source_defs`);
+            }
+            outputFiles.add(s.outputFile);
+          }
+          if (s.optionalForCompletionGating != null && typeof s.optionalForCompletionGating !== "boolean") {
+            errors.push(`source_defs[${i}]: optionalForCompletionGating must be a boolean`);
           }
-          if (runtimeDirty) writeRuntimeState(boardDir, cardId, runtime);
         }
+      });
+    }
+  }
+  if (n.view != null) {
+    if (typeof n.view !== "object" || Array.isArray(n.view)) {
+      errors.push("view: must be an object");
+    } else {
+      const view = n.view;
+      if (!Array.isArray(view.elements) || view.elements.length === 0) {
+        errors.push("view.elements: required, must be a non-empty array");
+      } else {
+        view.elements.forEach((elem, i) => {
+          if (!elem || typeof elem !== "object") {
+            errors.push(`view.elements[${i}]: must be an object`);
+            return;
+          }
+          if (!elem.kind || typeof elem.kind !== "string") {
+            errors.push(`view.elements[${i}].kind: required, must be a string`);
+          } else if (!VALID_ELEMENT_KINDS.has(elem.kind)) {
+            errors.push(`view.elements[${i}].kind: unknown kind "${elem.kind}". Valid: ${[...VALID_ELEMENT_KINDS].join(", ")}`);
+          }
+          if (elem.data != null && (typeof elem.data !== "object" || Array.isArray(elem.data))) {
+            errors.push(`view.elements[${i}].data: must be an object`);
+          }
+        });
       }
-      const sourcesData = {};
-      for (const src of allSources) {
-        if (src.outputFile) {
-          const filePath = path.join(boardDir, cardId, src.outputFile);
-          if (fs.existsSync(filePath)) {
-            const raw = fs.readFileSync(filePath, "utf-8").trim();
+      if (view.layout != null && (typeof view.layout !== "object" || Array.isArray(view.layout))) errors.push("view.layout: must be an object");
+      if (view.features != null && (typeof view.features !== "object" || Array.isArray(view.features))) errors.push("view.features: must be an object");
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
+async function enrichSources(source_defs, context) {
+  if (!source_defs || source_defs.length === 0) return [];
+  const evalCtx = {
+    card_data: context.card_data ?? {},
+    requires: context.requires ?? {}
+  };
+  return Promise.all(
+    source_defs.map(async (src) => {
+      const _projections = {};
+      if (src.projections && typeof src.projections === "object" && !Array.isArray(src.projections)) {
+        for (const [key, expr] of Object.entries(src.projections)) {
+          if (typeof expr === "string" && expr.trim().length > 0) {
             try {
-              sourcesData[src.bindTo] = JSON.parse(raw);
+              _projections[key] = await jsonata2(expr).evaluate(evalCtx);
             } catch {
-              sourcesData[src.bindTo] = raw;
+              _projections[key] = void 0;
             }
           }
         }
       }
-      const requires = {};
-      for (const [token, taskData] of Object.entries(input.state ?? {})) {
-        if (taskData !== null && typeof taskData === "object" && !Array.isArray(taskData)) {
-          const unwrapped = taskData[token];
-          requires[token] = unwrapped !== void 0 ? unwrapped : taskData;
+      return { ...src, _projections };
+    })
+  );
+}
+var CardCompute = {
+  run,
+  eval: evalExpr,
+  resolve: resolve4,
+  validate: validateNode,
+  enrichSources
+};
+
+// src/cli/board-live-cards-lib-types.ts
+function isSourceInFlight(entry) {
+  if (!entry?.lastRequestedAt) return false;
+  return !entry.lastFetchedAt || entry.lastFetchedAt < entry.lastRequestedAt;
+}
+function decideSourceAction(entry, queueRequestedAt) {
+  if (!entry?.lastRequestedAt) return "dispatch";
+  const inFlight = isSourceInFlight(entry);
+  if (inFlight) return "in-flight";
+  if (!entry.lastFetchedAt) return "dispatch";
+  if (entry.lastFetchedAt < queueRequestedAt) return "dispatch";
+  return "idle";
+}
+function nextEntryAfterFetchDelivery(entry, fetchedAt) {
+  const next = { ...entry, lastFetchedAt: fetchedAt };
+  delete next.lastError;
+  return next;
+}
+function nextEntryAfterFetchFailure(entry, reason) {
+  const next = { ...entry, lastError: reason };
+  delete next.lastFetchedAt;
+  return next;
+}
+
+// src/cli/board-live-cards-lib-card-handler.ts
+var DEFAULT_TASK_COMPLETION_RULE = "all_required_sources_fetched";
+function createCardHandlerFn(boardDir, adapters) {
+  return async (input) => {
+    const cardPath = adapters.cardStore.lookupCardPath(boardDir, input.nodeId);
+    if (!cardPath) return "task-initiate-failure";
+    const card = adapters.cardStore.readCard(cardPath);
+    if (!card) return "task-initiate-failure";
+    const cardId = card.id;
+    const cardState = card.card_data ?? {};
+    const allSources = card.source_defs ?? [];
+    const requiredSources = allSources.filter((s) => s.optionalForCompletionGating !== true);
+    const session = adapters.runtimeStore.openSession(boardDir, cardId);
+    const currentExecutionCount = input.taskState?.executionCount ?? 0;
+    const lastExecCount = session.getLastExecutionCount();
+    if (typeof lastExecCount === "number" && lastExecCount !== currentExecutionCount) {
+      session.resetSources();
+      session.resetInferenceEntry();
+    }
+    if (lastExecCount !== currentExecutionCount) {
+      session.setLastExecutionCount(currentExecutionCount);
+    }
+    if (input.update) {
+      const u = input.update;
+      const outputFile = u.outputFile;
+      if (outputFile) {
+        const entry = session.getSourceEntry(outputFile);
+        if (u.failure) {
+          session.setSourceEntry(outputFile, nextEntryAfterFetchFailure(entry, u.reason ?? "unknown"));
         } else {
-          requires[token] = taskData;
+          session.setSourceEntry(outputFile, nextEntryAfterFetchDelivery(
+            entry,
+            u.fetchedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+          ));
         }
+        session.flush();
       }
-      const computeNode = {
-        id: cardId,
-        card_data: { ...cardState },
-        requires,
-        source_defs: allSources,
-        compute: card.compute
-      };
-      computeNode._sourcesData = sourcesData;
-      if (card.compute) {
-        await CardCompute.run(computeNode, { sourcesData });
-      }
-      const cvPath = resolveComputedValuesPath(boardDir, cardId);
-      writeJsonAtomic(cvPath, {
-        schema_version: "v1",
-        card_id: cardId,
-        computed_values: computeNode.computed_values ?? {}
-      });
-      const enrichedCard = { ...card };
-      const enrichedSources = await CardCompute.enrichSources(
-        Array.isArray(card.source_defs) ? card.source_defs : void 0,
-        {
-          card_data: card.card_data,
-          requires,
-          sourcesData,
-          computed_values: computeNode.computed_values
+    }
+    const sourcesData = {};
+    for (const src of allSources) {
+      if (src.outputFile) {
+        const content = adapters.cardStore.readSourceFileContent(boardDir, cardId, src.outputFile);
+        if (content !== null) {
+          sourcesData[src.bindTo] = content;
         }
-      );
-      const sourceCwd = path.dirname(cardPath);
-      enrichedCard.source_defs = Array.isArray(enrichedSources) ? enrichedSources.map((src) => ({
-        ...src,
-        cwd: typeof src.cwd === "string" && src.cwd ? src.cwd : sourceCwd,
-        boardDir: typeof src.boardDir === "string" && src.boardDir ? src.boardDir : boardDir
-      })) : enrichedSources;
-      const enrichedByOutput = /* @__PURE__ */ new Map();
-      for (const src of Array.isArray(enrichedCard.source_defs) ? enrichedCard.source_defs : []) {
+      }
+    }
+    const requires = {};
+    for (const [token, taskData] of Object.entries(input.state ?? {})) {
+      if (taskData !== null && typeof taskData === "object" && !Array.isArray(taskData)) {
+        const unwrapped = taskData[token];
+        requires[token] = unwrapped !== void 0 ? unwrapped : taskData;
+      } else {
+        requires[token] = taskData;
+      }
+    }
+    const computeNode = {
+      id: cardId,
+      card_data: { ...cardState },
+      requires,
+      source_defs: allSources,
+      compute: card.compute
+    };
+    computeNode._sourcesData = sourcesData;
+    if (card.compute) {
+      await CardCompute.run(computeNode, { sourcesData });
+    }
+    adapters.outputStore.writeComputedValues(boardDir, cardId, computeNode.computed_values ?? {});
+    const enrichedCard = { ...card };
+    const enrichedSources = await CardCompute.enrichSources(
+      Array.isArray(card.source_defs) ? card.source_defs : void 0,
+      {
+        card_data: card.card_data,
+        requires,
+        sourcesData,
+        computed_values: computeNode.computed_values
+      }
+    );
+    const sourceCwd = cardPath.replace(/[\\/][^\\/]*$/, "");
+    enrichedCard.source_defs = Array.isArray(enrichedSources) ? enrichedSources.map((src) => ({
+      ...src,
+      cwd: typeof src.cwd === "string" && src.cwd ? src.cwd : sourceCwd,
+      boardDir: typeof src.boardDir === "string" && src.boardDir ? src.boardDir : boardDir
+    })) : enrichedSources;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const runQueuedAt = input.update ? void 0 : now;
+    const undeliveredRequired = requiredSources.filter((s) => {
+      const outputFile = s.outputFile;
+      if (typeof outputFile !== "string" || !outputFile) return true;
+      let entry = session.getSourceEntry(outputFile);
+      if (runQueuedAt) {
+        entry = { ...entry, queueRequestedAt: runQueuedAt };
+        session.setSourceEntry(outputFile, entry);
+      }
+      const qrt = entry.queueRequestedAt ?? entry.lastRequestedAt ?? now;
+      const action = decideSourceAction(entry, qrt);
+      if (action === "in-flight") return false;
+      return action === "dispatch";
+    });
+    session.flush();
+    if (undeliveredRequired.length > 0) {
+      let stampedAny = false;
+      for (const src of undeliveredRequired) {
         const outputFile = src.outputFile;
-        if (typeof outputFile === "string" && outputFile) {
-          enrichedByOutput.set(outputFile, src);
-        }
+        if (typeof outputFile !== "string" || !outputFile) continue;
+        const entry = session.getSourceEntry(outputFile);
+        session.setSourceEntry(outputFile, { ...entry, lastRequestedAt: now });
+        stampedAny = true;
+      }
+      if (stampedAny) session.flush();
+      if (!stampedAny) return "task-initiated";
+      const result = await adapters.invocationAdapter.requestSourceFetch(
+        boardDir,
+        enrichedCard,
+        input.callbackToken
+      );
+      if (!result.dispatched && result.error) {
+        console.error(`[card-handler] ${input.nodeId}: source fetch dispatch failed: ${result.error}`);
       }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const runQueuedAt = input.update ? void 0 : now;
-      const undeliveredRequired = requiredSources.filter((s) => {
-        const outputFile = s.outputFile;
-        if (typeof outputFile !== "string" || !outputFile) return true;
-        if (!runtime._sources[outputFile]) runtime._sources[outputFile] = {};
-        const entry = runtime._sources[outputFile];
+      return "task-initiated";
+    }
+    const providesBindings = card.provides ?? [];
+    const data = {};
+    for (const { bindTo, ref } of providesBindings) {
+      data[bindTo] = CardCompute.resolve(computeNode, ref);
+    }
+    const completionRule = typeof card.when_is_task_completed === "string" && card.when_is_task_completed.trim() ? card.when_is_task_completed.trim() : DEFAULT_TASK_COMPLETION_RULE;
+    const cardData = card.card_data;
+    const llmCompletion = cardData?.llm_task_completion_inference ?? {};
+    const isLlmTaskCompleted = llmCompletion.isTaskCompleted === true;
+    const inferenceEntry = session.getInferenceEntry();
+    const inferenceRequestedAt = typeof inferenceEntry.lastRequestedAt === "string" ? inferenceEntry.lastRequestedAt : void 0;
+    const inferenceCompletedAt = typeof llmCompletion.inferenceCompletedAt === "string" ? llmCompletion.inferenceCompletedAt : void 0;
+    const inferencePending = !!inferenceRequestedAt && (!inferenceCompletedAt || inferenceCompletedAt < inferenceRequestedAt);
+    const latestRequiredSourceFetchedAt = requiredSources.reduce((latest, src) => {
+      const fetchedAt = session.getSourceEntry(src.outputFile).lastFetchedAt;
+      if (typeof fetchedAt !== "string") return latest;
+      if (!latest || fetchedAt > latest) return fetchedAt;
+      return latest;
+    }, void 0);
+    const shouldRequestInference = !inferenceRequestedAt || !inferenceCompletedAt || !!latestRequiredSourceFetchedAt && latestRequiredSourceFetchedAt > inferenceCompletedAt;
+    if (completionRule !== DEFAULT_TASK_COMPLETION_RULE) {
+      if (isLlmTaskCompleted) ; else if (inferencePending) {
+        return "task-initiated";
+      } else if (!shouldRequestInference) {
+        return "task-initiated";
+      } else {
+        const inferencePayload = {
+          cardId,
+          taskName: input.nodeId,
+          completionRule,
+          context: {
+            requires,
+            sourcesData,
+            computed_values: computeNode.computed_values ?? {},
+            provides: data,
+            card_data: computeNode.card_data ?? {}
+          }
+        };
+        let updatedInferenceEntry = { ...inferenceEntry };
         if (runQueuedAt) {
-          entry.queueRequestedAt = runQueuedAt;
-          runtimeDirty = true;
+          updatedInferenceEntry = { ...updatedInferenceEntry, queueRequestedAt: runQueuedAt };
+          session.setInferenceEntry(updatedInferenceEntry);
         }
-        const qrt = entry.queueRequestedAt ?? entry.lastRequestedAt ?? now;
-        const action = decideSourceAction(entry, qrt);
-        if (action === "in-flight") return false;
-        return action === "dispatch";
-      });
-      if (runtimeDirty) writeRuntimeState(boardDir, cardId, runtime);
-      if (undeliveredRequired.length > 0) {
-        let stampedAny = false;
-        for (const src of undeliveredRequired) {
-          const outputFile = src.outputFile;
-          if (typeof outputFile !== "string" || !outputFile) continue;
-          const entry = runtime._sources[outputFile] ?? {};
-          markRequested(entry, now);
-          runtime._sources[outputFile] = entry;
-          stampedAny = true;
-        }
-        if (stampedAny) writeRuntimeState(boardDir, cardId, runtime);
-        if (!stampedAny) return "task-initiated";
-        const enrichedCardPath = path.join(os.tmpdir(), `card-enriched-${cardId}-${Date.now()}.json`);
-        fs.writeFileSync(enrichedCardPath, JSON.stringify(enrichedCard, null, 2), "utf-8");
-        invokeRunSources(boardDir, enrichedCardPath, input.callbackToken, (err) => {
-          if (err) {
-            console.error(`[card-handler] ${input.nodeId}:`, err.message);
-            try {
-              fs.unlinkSync(enrichedCardPath);
-            } catch {
-            }
-          }
-        });
-        return "task-initiated";
-      }
-      const providesBindings = card.provides ?? [];
-      const data = {};
-      for (const { bindTo, ref } of providesBindings) {
-        data[bindTo] = CardCompute.resolve(computeNode, ref);
-      }
-      const completionRule = typeof card.when_is_task_completed === "string" && card.when_is_task_completed.trim() ? card.when_is_task_completed.trim() : DEFAULT_TASK_COMPLETION_RULE;
-      const cardData = card.card_data;
-      const llmCompletion = cardData?.llm_task_completion_inference ?? {};
-      const isLlmTaskCompleted = llmCompletion.isTaskCompleted === true;
-      const inferenceEntry = runtime._inferenceEntry ?? {};
-      const inferenceRequestedAt = typeof inferenceEntry.lastRequestedAt === "string" ? inferenceEntry.lastRequestedAt : void 0;
-      const inferenceCompletedAt = typeof llmCompletion.inferenceCompletedAt === "string" ? llmCompletion.inferenceCompletedAt : void 0;
-      const inferencePending = !!inferenceRequestedAt && (!inferenceCompletedAt || inferenceCompletedAt < inferenceRequestedAt);
-      const latestRequiredSourceFetchedAt = requiredSources.reduce((latest, src) => {
-        const fetchedAt = runtime._sources[src.outputFile]?.lastFetchedAt;
-        if (typeof fetchedAt !== "string") return latest;
-        if (!latest || fetchedAt > latest) return fetchedAt;
-        return latest;
-      }, void 0);
-      const shouldRequestInference = !inferenceRequestedAt || !inferenceCompletedAt || !!latestRequiredSourceFetchedAt && latestRequiredSourceFetchedAt > inferenceCompletedAt;
-      if (completionRule !== DEFAULT_TASK_COMPLETION_RULE) {
-        if (isLlmTaskCompleted) ; else if (inferencePending) {
+        const inferenceQrt = updatedInferenceEntry.queueRequestedAt ?? updatedInferenceEntry.lastRequestedAt ?? now;
+        const inferenceAction = decideSourceAction(updatedInferenceEntry, inferenceQrt);
+        if (inferenceAction === "in-flight") {
+          session.flush();
           return "task-initiated";
-        } else if (!shouldRequestInference) {
+        }
+        if (inferenceAction === "idle") {
           return "task-initiated";
-        } else {
-          const now2 = (/* @__PURE__ */ new Date()).toISOString();
-          const inferencePayload = {
-            cardId,
+        }
+        adapters.outputStore.appendInferenceLog(boardDir, cardId, inferencePayload);
+        session.setInferenceEntry({ ...updatedInferenceEntry, lastRequestedAt: now });
+        session.flush();
+        const inferenceResult = await adapters.invocationAdapter.requestInference(
+          boardDir,
+          cardId,
+          inferencePayload,
+          input.callbackToken
+        );
+        if (!inferenceResult.dispatched) {
+          const failedAt = (/* @__PURE__ */ new Date()).toISOString();
+          adapters.inputStore.appendEvent(boardDir, {
+            type: "task-failed",
             taskName: input.nodeId,
-            completionRule,
-            context: {
-              requires,
-              sourcesData,
-              computed_values: computeNode.computed_values ?? {},
-              provides: data,
-              card_data: computeNode.card_data ?? {}
-            }
-          };
-          if (runQueuedAt) {
-            inferenceEntry.queueRequestedAt = runQueuedAt;
-            runtimeDirty = true;
-          }
-          const inferenceQrt = inferenceEntry.queueRequestedAt ?? inferenceEntry.lastRequestedAt ?? now2;
-          const inferenceAction = decideSourceAction(inferenceEntry, inferenceQrt);
-          if (inferenceAction === "in-flight") {
-            runtime._inferenceEntry = inferenceEntry;
-            if (runtimeDirty) writeRuntimeState(boardDir, cardId, runtime);
-            return "task-initiated";
-          }
-          if (inferenceAction === "idle") {
-            return "task-initiated";
-          }
-          const inferenceInFile = path.join(os.tmpdir(), `card-inference-${cardId}-${Date.now()}.json`);
-          fs.writeFileSync(inferenceInFile, JSON.stringify(inferencePayload, null, 2), "utf-8");
-          appendInferenceAdapterLog(boardDir, cardId, inferencePayload);
-          markRequested(inferenceEntry, now2);
-          runtime._inferenceEntry = inferenceEntry;
-          runtimeDirty = true;
-          invokeRunInference(boardDir, cardId, inferenceInFile, input.callbackToken, void 0, (err) => {
-            if (err) {
-              console.error(`[card-handler] ${input.nodeId}:`, err.message);
-              const failedAt = (/* @__PURE__ */ new Date()).toISOString();
-              appendEventToJournal(boardDir, {
-                type: "task-failed",
-                taskName: input.nodeId,
-                error: err.message,
-                timestamp: failedAt
-              });
-            }
+            error: inferenceResult.error ?? "inference dispatch failed",
+            timestamp: failedAt
           });
-          return "task-initiated";
         }
+        return "task-initiated";
       }
-      writeRuntimeDataObjects(boardDir, data);
-      const undeliveredOptional = allSources.filter((s) => {
-        if (s.optionalForCompletionGating !== true) return false;
-        const entry = runtime._sources[s.outputFile];
-        if (!entry?.lastRequestedAt) return true;
-        if (!entry.lastFetchedAt) return true;
-        return entry.lastFetchedAt <= entry.lastRequestedAt;
-      });
-      if (undeliveredOptional.length > 0) {
-        invokeRunSources(boardDir, cardPath, input.callbackToken, (err) => {
-          if (err) console.error(`[card-handler] ${input.nodeId}:`, err.message);
-        });
-      }
-      appendEventToJournal(boardDir, {
-        type: "task-completed",
-        taskName: input.nodeId,
-        data,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return "task-initiated";
     }
-  };
-  const rg = createReactiveGraph(live, { handlers });
-  return { rg, journal };
-}
-function resolveCardGlobMatches(cardGlob) {
-  const patterns = cardGlob.split(",").map((s) => s.trim()).filter(Boolean).map((p) => p.replace(/\\/g, "/"));
-  const matches = fg.sync(patterns, {
-    absolute: true,
-    onlyFiles: true,
-    unique: true,
-    dot: false
-  });
-  return [...matches].map((m) => path.resolve(m)).sort((a, b) => a.localeCompare(b));
-}
-function cmdInit(args) {
-  const dir = args[0];
-  if (!dir) {
-    throw new Error("Usage: board-live-cards init <dir> [--task-executor <script>] [--chat-handler <script>] [--inference-adapter <script>] [--runtime-out <dir>]");
-  }
-  const teIdx = args.indexOf("--task-executor");
-  const taskExecutor = teIdx !== -1 ? args[teIdx + 1] : void 0;
-  const chIdx = args.indexOf("--chat-handler");
-  const chatHandler = chIdx !== -1 ? args[chIdx + 1] : void 0;
-  const iaIdx = args.indexOf("--inference-adapter");
-  const inferenceAdapter = iaIdx !== -1 ? args[iaIdx + 1] : void 0;
-  const roIdx = args.indexOf("--runtime-out");
-  const runtimeOut = roIdx !== -1 ? args[roIdx + 1] : void 0;
-  if (roIdx !== -1 && !runtimeOut) {
-    throw new Error("Usage: board-live-cards init <dir> [--task-executor <script>] [--chat-handler <script>] [--inference-adapter <script>] [--runtime-out <dir>]");
-  }
-  const result = initBoard(dir);
-  if (taskExecutor) {
-    const teExtraIdx = args.indexOf("--task-executor-extra");
-    let teExtra;
-    if (teExtraIdx !== -1 && args[teExtraIdx + 1]) {
-      try {
-        teExtra = JSON.parse(args[teExtraIdx + 1]);
-      } catch {
-      }
+    adapters.outputStore.writeDataObjects(boardDir, data);
+    const undeliveredOptional = allSources.filter((s) => {
+      if (s.optionalForCompletionGating !== true) return false;
+      const entry = session.getSourceEntry(s.outputFile);
+      if (!entry.lastRequestedAt) return true;
+      if (!entry.lastFetchedAt) return true;
+      return entry.lastFetchedAt <= entry.lastRequestedAt;
+    });
+    if (undeliveredOptional.length > 0) {
+      adapters.invocationAdapter.requestSourceFetch(boardDir, enrichedCard, input.callbackToken).catch((err) => console.error(`[card-handler] ${input.nodeId}: optional source fetch:`, err));
     }
-    const teConfig = { command: taskExecutor, ...teExtra ? { extra: teExtra } : {} };
-    fs.writeFileSync(path.join(dir, TASK_EXECUTOR_FILE), JSON.stringify(teConfig, null, 2), "utf-8");
-  }
-  if (chatHandler) {
-    fs.writeFileSync(path.join(dir, ".chat-handler"), chatHandler, "utf-8");
-  }
-  if (inferenceAdapter) {
-    fs.writeFileSync(path.join(dir, INFERENCE_ADAPTER_FILE), inferenceAdapter, "utf-8");
-  }
-  const runtimeOutDir = configureRuntimeOutDir(dir, runtimeOut);
-  const live = loadBoard(dir);
-  writeJsonAtomic(resolveStatusSnapshotPath(dir), buildBoardStatusObject(dir, live));
-  if (result === "exists") {
-    console.log(`Board already initialized at ${path.resolve(dir)}${taskExecutor ? ` (task-executor updated: ${taskExecutor})` : ""} (runtime-out: ${runtimeOutDir})`);
-  } else {
-    console.log(`Board initialized at ${path.resolve(dir)}${taskExecutor ? ` (task-executor: ${taskExecutor})` : ""} (runtime-out: ${runtimeOutDir})`);
-  }
+    adapters.inputStore.appendEvent(boardDir, {
+      type: "task-completed",
+      taskName: input.nodeId,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return "task-initiated";
+  };
 }
-function buildBoardStatusObject(dir, live) {
+
+// src/cli/board-live-cards-lib-board-status.ts
+function buildBoardStatusObject(boardPath, live) {
   const taskState = live.state.tasks;
   const taskConfig = live.config.tasks;
   const cardNames = Object.keys(taskState);
@@ -9062,15 +9660,15 @@ function buildBoardStatusObject(dir, live) {
   let orphanCards = 0;
   for (const [name, cfg] of Object.entries(taskConfig)) {
     const requiresNone = (cfg.requires ?? []).length === 0;
-    const provides = cfg.provides ?? [];
-    const feedsAny = provides.some((p) => (dependentsByToken.get(p) ?? []).some((d) => d !== name));
+    const providesList = cfg.provides ?? [];
+    const feedsAny = providesList.some((p) => (dependentsByToken.get(p) ?? []).some((d) => d !== name));
     if (requiresNone && !feedsAny) orphanCards += 1;
   }
   return {
     schema_version: "v1",
     meta: {
       board: {
-        path: path.resolve(dir)
+        path: boardPath
       }
     },
     summary: {
@@ -9092,1193 +9690,901 @@ function buildBoardStatusObject(dir, live) {
     cards
   };
 }
-function cmdStatus(args) {
-  const rgIdx = args.indexOf("--rg");
-  const asJson = args.includes("--json");
-  const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
-  if (!dir) {
-    console.error("Usage: board-live-cards status --rg <dir>");
-    process.exit(1);
+var NodeRuntimeStoreSession = class {
+  constructor(boardDir, cardId) {
+    this.boardDir = boardDir;
+    this.cardId = cardId;
+    this.state = NodeRuntimeInternalStore.readState(boardDir, cardId);
   }
-  const statusOutPath = resolveStatusSnapshotPath(dir);
-  let statusObject;
-  if (fs.existsSync(statusOutPath)) {
-    statusObject = JSON.parse(fs.readFileSync(statusOutPath, "utf-8"));
-  } else {
-    statusObject = buildBoardStatusObject(dir, loadBoard(dir));
-    writeJsonAtomic(statusOutPath, statusObject);
+  boardDir;
+  cardId;
+  state;
+  dirty = false;
+  getSourceEntry(outputFile) {
+    return { ...this.state._sources[outputFile] ?? {} };
   }
-  if (asJson) {
-    console.log(JSON.stringify(statusObject, null, 2));
-    return;
+  setSourceEntry(outputFile, entry) {
+    this.state._sources[outputFile] = entry;
+    this.dirty = true;
+  }
+  resetSources() {
+    this.state._sources = {};
+    this.dirty = true;
+  }
+  getInferenceEntry() {
+    return { ...this.state._inferenceEntry ?? {} };
+  }
+  setInferenceEntry(entry) {
+    this.state._inferenceEntry = entry;
+    this.dirty = true;
+  }
+  resetInferenceEntry() {
+    this.state._inferenceEntry = void 0;
+    this.dirty = true;
+  }
+  getLastExecutionCount() {
+    return this.state._lastExecutionCount;
   }
-  console.log(`Board: ${statusObject.meta.board.path}`);
-  console.log(`Tasks: ${statusObject.summary.card_count}`);
-  console.log("");
-  for (const card of statusObject.cards) {
-    const dataKeys = card.provides_runtime.join(", ");
-    console.log(`  ${card.status.padEnd(12)} ${card.name}${dataKeys ? ` \u2014 [${dataKeys}]` : ""}`);
+  setLastExecutionCount(count) {
+    this.state._lastExecutionCount = count;
+    this.dirty = true;
   }
-  console.log("");
-  console.log(`Schedule: ${statusObject.summary.eligible} eligible, ${statusObject.summary.pending} pending, ${statusObject.summary.blocked} blocked, ${statusObject.summary.unresolved} unresolved`);
+  flush() {
+    if (!this.dirty) return;
+    NodeRuntimeInternalStore.writeState(this.boardDir, this.cardId, this.state);
+    this.dirty = false;
+  }
+};
+var NodeRuntimeInternalStore = class {
+  openSession(boardDir, cardId) {
+    return new NodeRuntimeStoreSession(boardDir, cardId);
+  }
+  static readState(boardDir, cardId) {
+    const p = path7.join(boardDir, cardId, "runtime.json");
+    if (!fs7.existsSync(p)) return { _sources: {} };
+    try {
+      return JSON.parse(fs7.readFileSync(p, "utf-8"));
+    } catch {
+      return { _sources: {} };
+    }
+  }
+  static writeState(boardDir, cardId, state) {
+    const p = path7.join(boardDir, cardId, "runtime.json");
+    fs7.mkdirSync(path7.dirname(p), { recursive: true });
+    fs7.writeFileSync(p, JSON.stringify(state, null, 2));
+  }
+};
+function createNodeRuntimeStore() {
+  return new NodeRuntimeInternalStore();
 }
-function cmdTaskCompleted(args) {
-  const rgIdx = args.indexOf("--rg");
-  const tokenIdx = args.indexOf("--token");
-  const dataIdx = args.indexOf("--data");
-  const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
-  const token = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
-  if (!dir || !token) {
-    console.error("Usage: board-live-cards task-completed --rg <dir> --token <token> [--data <json>]");
-    process.exit(1);
+function writeJsonAtomic(filePath, payload) {
+  fs7.mkdirSync(path7.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  fs7.writeFileSync(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
+  fs7.renameSync(tmpPath, filePath);
+}
+var NodeOutputStore = class {
+  constructor(resolveComputedValuesPath2, resolveDataObjectsDirPath2, inferenceAdapterLogFile) {
+    this.resolveComputedValuesPath = resolveComputedValuesPath2;
+    this.resolveDataObjectsDirPath = resolveDataObjectsDirPath2;
+    this.inferenceAdapterLogFile = inferenceAdapterLogFile;
+  }
+  resolveComputedValuesPath;
+  resolveDataObjectsDirPath;
+  inferenceAdapterLogFile;
+  writeComputedValues(boardDir, cardId, values) {
+    writeJsonAtomic(this.resolveComputedValuesPath(boardDir, cardId), {
+      schema_version: "v1",
+      card_id: cardId,
+      computed_values: values
+    });
   }
-  const decoded = decodeCallbackToken2(token);
-  if (!decoded) {
-    console.error("Invalid callback token");
-    process.exit(1);
+  writeDataObjects(boardDir, data) {
+    for (const [token, payload] of Object.entries(data)) {
+      if (!token) continue;
+      const fileName = token.replace(/[\\/]/g, "__");
+      if (!fileName) continue;
+      writeJsonAtomic(path7.join(this.resolveDataObjectsDirPath(boardDir), fileName), payload);
+    }
   }
-  const data = dataIdx !== -1 ? JSON.parse(args[dataIdx + 1]) : {};
-  writeRuntimeDataObjects(dir, data);
-  appendEventToJournal(dir, {
-    type: "task-completed",
-    taskName: decoded.taskName,
-    data,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  void processAccumulatedEventsForced(dir);
-  console.log("Task completed.");
+  appendInferenceLog(boardDir, cardId, payload) {
+    try {
+      const entry = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), cardId, payload };
+      fs7.appendFileSync(
+        path7.join(boardDir, this.inferenceAdapterLogFile),
+        JSON.stringify(entry) + "\n",
+        "utf-8"
+      );
+    } catch (logErr) {
+      console.error(`[inference-adapter-log] append failed: ${logErr instanceof Error ? logErr.message : String(logErr)}`);
+    }
+  }
+};
+function createNodeOutputStore(resolveComputedValuesPath2, resolveDataObjectsDirPath2, inferenceAdapterLogFile) {
+  return new NodeOutputStore(resolveComputedValuesPath2, resolveDataObjectsDirPath2, inferenceAdapterLogFile);
 }
-function cmdTaskFailed(args) {
-  const rgIdx = args.indexOf("--rg");
-  const tokenIdx = args.indexOf("--token");
-  const errorIdx = args.indexOf("--error");
-  const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
-  const token = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
-  const errorMsg = errorIdx !== -1 ? args[errorIdx + 1] : "unknown error";
-  if (!dir || !token) {
-    console.error("Usage: board-live-cards task-failed --rg <dir> --token <token> [--error <message>]");
-    process.exit(1);
+var NodeInputStore = class {
+  constructor(journalFile) {
+    this.journalFile = journalFile;
   }
-  const decoded = decodeCallbackToken2(token);
-  if (!decoded) {
-    console.error("Invalid callback token");
-    process.exit(1);
+  journalFile;
+  appendEvent(boardDir, event) {
+    const journalPath = path7.join(boardDir, this.journalFile);
+    const entry = { id: randomUUID(), event };
+    fs7.appendFileSync(journalPath, JSON.stringify(entry) + "\n", "utf-8");
   }
-  appendEventToJournal(dir, {
-    type: "task-failed",
-    taskName: decoded.taskName,
-    error: errorMsg,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  void processAccumulatedEventsForced(dir);
-  console.log("Task failed.");
+};
+function createNodeInputStore(journalFile) {
+  return new NodeInputStore(journalFile);
 }
-function cmdValidateCard(args) {
-  const cardIdx = args.indexOf("--card");
-  const globIdx = args.indexOf("--card-glob");
-  const rgIdx = args.indexOf("--rg");
-  const cardFile = cardIdx !== -1 ? args[cardIdx + 1] : void 0;
-  const cardGlob = globIdx !== -1 ? args[globIdx + 1] : void 0;
-  const boardDir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
-  if (!cardFile && !cardGlob || cardFile && cardGlob) {
-    throw new Error("Usage: board-live-cards validate-card (--card <card.json> | --card-glob <glob>) [--rg <boardDir>]");
-  }
-  let teConfig;
-  if (boardDir) {
-    teConfig = readTaskExecutorConfig(boardDir);
-    if (!teConfig) {
-      throw new Error(`--rg specified but no .task-executor found in ${boardDir}`);
+function shouldSuppressSpawn() {
+  return process.env.BOARD_LIVE_CARDS_NO_SPAWN === "1";
+}
+function getCliInvocationPath(cliDir) {
+  const tsPath = path7.join(cliDir, "board-live-cards-cli.ts");
+  const localTsxBin = path7.join(cliDir, "..", "..", "node_modules", ".bin", "tsx");
+  const localTsxMjs = path7.join(cliDir, "..", "..", "node_modules", "tsx", "dist", "cli.mjs");
+  const localTsx = fs7.existsSync(localTsxMjs) ? localTsxMjs : localTsxBin;
+  if (fs7.existsSync(tsPath) && fs7.existsSync(localTsx)) {
+    return { cmd: process.execPath, args: [localTsx, tsPath] };
+  }
+  const distJsPath = path7.join(cliDir, "dist", "cli", "board-live-cards-cli.js");
+  if (fs7.existsSync(distJsPath)) {
+    return { cmd: process.execPath, args: [distJsPath] };
+  }
+  const jsPath = path7.join(cliDir, "board-live-cards-cli.js");
+  if (fs7.existsSync(jsPath)) {
+    return { cmd: process.execPath, args: [jsPath] };
+  }
+  return null;
+}
+function buildCliInvocation(cliDir, command, args) {
+  const found = getCliInvocationPath(cliDir);
+  if (found) {
+    return { cmd: found.cmd, args: [...found.args, command, ...args] };
+  }
+  const tsPath = path7.join(cliDir, "board-live-cards-cli.ts");
+  const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
+  return { cmd: npxCmd, args: ["tsx", tsPath, command, ...args] };
+}
+var _gitBashCache;
+var GIT_BASH_CACHE_FILE = path7.join(os3.tmpdir(), ".board-live-cards-git-bash-path.json");
+function findGitBash() {
+  if (_gitBashCache !== void 0) return _gitBashCache;
+  try {
+    const cached = JSON.parse(fs7.readFileSync(GIT_BASH_CACHE_FILE, "utf-8"));
+    if (typeof cached?.path === "string" || cached?.path === false) {
+      _gitBashCache = cached.path;
+      return _gitBashCache;
+    }
+  } catch {
+  }
+  const candidates = [
+    "C:\\Program Files\\Git\\bin\\bash.exe",
+    "C:\\Program Files (x86)\\Git\\bin\\bash.exe"
+  ];
+  for (const c of candidates) {
+    if (fs7.existsSync(c)) {
+      _gitBashCache = c;
+      try {
+        fs7.writeFileSync(GIT_BASH_CACHE_FILE, JSON.stringify({ path: c }));
+      } catch {
+      }
+      return c;
+    }
+  }
+  _gitBashCache = false;
+  try {
+    fs7.writeFileSync(GIT_BASH_CACHE_FILE, JSON.stringify({ path: false }));
+  } catch {
+  }
+  return false;
+}
+function shellQuote(s) {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+function spawnDetached(cmd, args) {
+  if (process.platform === "win32") {
+    const bash = findGitBash();
+    if (bash) {
+      const shellCmd = [cmd, ...args].map((a) => shellQuote(a.replace(/\\/g, "/"))).join(" ");
+      const child3 = spawn(bash, ["-c", shellCmd], { detached: true, stdio: "ignore", windowsHide: true });
+      child3.unref();
+      return;
+    }
+    const child2 = spawn("cmd", ["/c", "start", "/b", "", cmd, ...args], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child2.unref();
+    return;
+  }
+  const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
+  child.unref();
+}
+var NodeInvocationAdapter = class {
+  constructor(cliDir, encodeSourceToken2) {
+    this.cliDir = cliDir;
+    this.encodeSourceToken = encodeSourceToken2;
+  }
+  cliDir;
+  encodeSourceToken;
+  async requestSourceFetch(boardDir, enrichedCard, callbackToken) {
+    if (shouldSuppressSpawn()) {
+      return { dispatched: false, invocationId: void 0 };
+    }
+    try {
+      const cardId = enrichedCard.id ?? "unknown";
+      const enrichedCardPath = path7.join(os3.tmpdir(), `card-enriched-${cardId}-${Date.now()}.json`);
+      fs7.writeFileSync(enrichedCardPath, JSON.stringify(enrichedCard, null, 2), "utf-8");
+      const args = ["--card", enrichedCardPath, "--token", callbackToken, "--rg", boardDir];
+      const { cmd, args: cmdArgs } = buildCliInvocation(this.cliDir, "run-sourcedefs-internal", args);
+      const invocationId = randomUUID();
+      spawnDetached(cmd, cmdArgs);
+      return { dispatched: true, invocationId };
+    } catch (err) {
+      return { dispatched: false, error: err instanceof Error ? err.message : String(err) };
     }
   }
-  const files = cardFile ? [path.resolve(cardFile)] : resolveCardGlobMatches(cardGlob);
-  if (files.length === 0) {
-    throw new Error(`No card files matched glob: ${cardGlob}`);
-  }
-  let failures = 0;
-  for (const f of files) {
-    const label = path.relative(process.cwd(), f) || f;
-    if (!fs.existsSync(f)) {
-      console.error(`FAIL  ${label}: file not found`);
-      failures++;
-      continue;
+  async requestInference(boardDir, cardId, inferencePayload, callbackToken) {
+    if (shouldSuppressSpawn()) {
+      return { dispatched: false, invocationId: void 0 };
     }
-    let card;
     try {
-      card = JSON.parse(fs.readFileSync(f, "utf-8"));
+      const inferenceInFile = path7.join(os3.tmpdir(), `card-inference-${cardId}-${Date.now()}.json`);
+      fs7.writeFileSync(inferenceInFile, JSON.stringify(inferencePayload, null, 2), "utf-8");
+      const inferenceToken = this.encodeSourceToken({
+        cbk: callbackToken,
+        rg: boardDir,
+        cid: cardId,
+        b: "",
+        d: "",
+        cs: void 0
+      });
+      const { cmd, args } = buildCliInvocation(
+        this.cliDir,
+        "run-inference-internal",
+        ["--in", inferenceInFile, "--token", inferenceToken]
+      );
+      const invocationId = randomUUID();
+      spawnDetached(cmd, args);
+      return { dispatched: true, invocationId };
     } catch (err) {
-      console.error(`FAIL  ${label}: invalid JSON \u2014 ${err instanceof Error ? err.message : String(err)}`);
-      failures++;
-      continue;
+      return { dispatched: false, error: err instanceof Error ? err.message : String(err) };
     }
-    const result = validateLiveCardDefinition(card);
-    const sourceErrors = [];
-    if (teConfig && Array.isArray(card.source_defs)) {
-      for (const src of card.source_defs) {
-        const bindTo = typeof src.bindTo === "string" ? src.bindTo : "(unknown)";
-        const tmpFile = path.join(os.tmpdir(), `validate-src-${bindTo}-${Date.now()}.json`);
-        try {
-          fs.writeFileSync(tmpFile, JSON.stringify(src), "utf-8");
-          let stdout;
-          try {
-            stdout = execCommandSync(teConfig.command, ["validate-source-def", "--in", tmpFile], { shell: true, timeout: 1e4 });
-          } catch (execErr) {
-            stdout = typeof execErr?.stdout === "string" ? execErr.stdout : Buffer.isBuffer(execErr?.stdout) ? execErr.stdout.toString("utf-8") : "";
-            if (!stdout.trim()) {
-              sourceErrors.push(`source "${bindTo}": executor validate-source-def failed \u2014 ${execErr instanceof Error ? execErr.message : String(execErr)}`);
-              continue;
-            }
-          }
-          const parsed = JSON.parse(stdout.trim());
-          if (!parsed.ok && Array.isArray(parsed.errors)) {
-            for (const e of parsed.errors) {
-              sourceErrors.push(`source "${bindTo}": ${e}`);
-            }
-          }
-        } catch (err) {
-          sourceErrors.push(`source "${bindTo}": executor validate-source-def failed \u2014 ${err instanceof Error ? err.message : String(err)}`);
-        } finally {
-          try {
-            fs.unlinkSync(tmpFile);
-          } catch {
-          }
-        }
-      }
+  }
+};
+function createNodeInvocationAdapter(cliDir, encodeSourceToken2) {
+  return new NodeInvocationAdapter(cliDir, encodeSourceToken2);
+}
+var NodeCardStore = class {
+  constructor(lookupCardPathFn) {
+    this.lookupCardPathFn = lookupCardPathFn;
+  }
+  lookupCardPathFn;
+  readCard(cardPath) {
+    try {
+      return JSON.parse(fs7.readFileSync(cardPath, "utf-8"));
+    } catch {
+      return null;
     }
-    const allErrors = [...result.errors, ...sourceErrors];
-    if (allErrors.length === 0) {
-      console.log(`OK    ${label}`);
-    } else {
-      console.error(`FAIL  ${label}:`);
-      for (const e of allErrors) {
-        console.error(`        ${e}`);
+  }
+  readSourceFileContent(boardDir, cardId, outputFile) {
+    const filePath = path7.join(boardDir, cardId, outputFile);
+    if (!fs7.existsSync(filePath)) return null;
+    try {
+      const raw = fs7.readFileSync(filePath, "utf-8").trim();
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
       }
-      failures++;
+    } catch {
+      return null;
     }
   }
-  if (failures > 0) {
-    throw new Error(`${failures} of ${files.length} card(s) failed validation.`);
-  } else {
-    console.log(`
-${files.length} card(s) passed validation.`);
+  lookupCardPath(boardDir, nodeId) {
+    return this.lookupCardPathFn(boardDir, nodeId);
   }
+};
+function createNodeCardStore(lookupCardPath2) {
+  return new NodeCardStore(lookupCardPath2);
 }
-function cmdRemoveCard(args) {
-  const rgIdx = args.indexOf("--rg");
-  const idIdx = args.indexOf("--id");
-  const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
-  const cardId = idIdx !== -1 ? args[idIdx + 1] : void 0;
-  if (!dir || !cardId) {
-    console.error("Usage: board-live-cards remove-card --rg <dir> --id <card-id>");
-    process.exit(1);
+
+// src/cli/board-live-cards-cli.ts
+var BOARD_FILE = "board-graph.json";
+var JOURNAL_FILE = "board-journal.jsonl";
+var TASK_EXECUTOR_LOG_FILE = "task-executor.jsonl";
+var INFERENCE_ADAPTER_LOG_FILE = "inference-adapter.jsonl";
+var INVENTORY_FILE = "cards-inventory.jsonl";
+var RUNTIME_OUT_FILE = ".runtime-out";
+var DEFAULT_RUNTIME_OUT_DIR = "runtime-out";
+var RUNTIME_STATUS_FILE = "board-livegraph-status.json";
+var RUNTIME_CARDS_DIR = "cards";
+var RUNTIME_DATA_OBJECTS_DIR = "data-objects";
+var INFERENCE_ADAPTER_FILE = ".inference-adapter";
+var TASK_EXECUTOR_FILE = ".task-executor";
+function readTaskExecutorConfig(boardDir) {
+  const executorFile = path7.join(boardDir, TASK_EXECUTOR_FILE);
+  if (!fs7.existsSync(executorFile)) return void 0;
+  const raw = fs7.readFileSync(executorFile, "utf-8").trim();
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && typeof parsed.command === "string") {
+      return parsed;
+    }
+  } catch {
   }
-  appendEventToJournal(dir, {
-    type: "task-removal",
-    taskName: cardId,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  void processAccumulatedEventsInfinitePass(dir);
-  console.log(`Card "${cardId}" removed.`);
+  return { command: raw };
 }
-function cmdSourceDataFetched(args) {
-  const tmpIdx = args.indexOf("--tmp");
-  const tokenIdx = args.indexOf("--token");
-  const tmpFile = tmpIdx !== -1 ? args[tmpIdx + 1] : void 0;
-  const token = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
-  if (!tmpFile || !token) {
-    console.error("Usage: board-live-cards source-data-fetched --tmp <tmp-file> --token <sourceToken>");
-    process.exit(1);
+var EMPTY_CONFIG = { settings: { completion: "manual", refreshStrategy: "data-changed" }, tasks: {} };
+var BoardJournal = class {
+  journalPath;
+  lastDrainedId;
+  constructor(journalPath, lastDrainedJournalId) {
+    this.journalPath = journalPath;
+    this.lastDrainedId = lastDrainedJournalId;
   }
-  const payload = decodeSourceToken(token);
-  if (!payload) {
-    console.error("Invalid source token");
-    process.exit(1);
+  append(event) {
+    const entry = { id: randomUUID(), event };
+    fs7.appendFileSync(this.journalPath, JSON.stringify(entry) + "\n", "utf-8");
   }
-  const { cbk, rg, cid, b, d, cs } = payload;
-  const destPath = path.join(rg, cid, d);
-  fs.mkdirSync(path.dirname(destPath), { recursive: true });
-  fs.renameSync(tmpFile, destPath);
-  console.log(`[source-data-fetched] ${cid}.${b} \u2192 ${cid}/${d}`);
-  const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const cbkDecoded = decodeCallbackToken2(cbk);
-  if (!cbkDecoded) {
-    console.error("Invalid callback token embedded in source token");
-    process.exit(1);
+  drain() {
+    if (!fs7.existsSync(this.journalPath)) return [];
+    const content = fs7.readFileSync(this.journalPath, "utf-8").trim();
+    if (!content) return [];
+    const entries = content.split("\n").map((l) => JSON.parse(l));
+    let startIdx = 0;
+    if (this.lastDrainedId) {
+      const drainedIdx = entries.findIndex((e) => e.id === this.lastDrainedId);
+      if (drainedIdx !== -1) startIdx = drainedIdx + 1;
+    }
+    const undrained = entries.slice(startIdx);
+    if (undrained.length > 0) {
+      this.lastDrainedId = undrained[undrained.length - 1].id;
+    }
+    return undrained.map((e) => e.event);
   }
-  appendEventToJournal(rg, {
-    type: "task-progress",
-    taskName: cbkDecoded.taskName,
-    update: { bindTo: b, outputFile: d, fetchedAt, sourceChecksum: cs },
-    timestamp: fetchedAt
-  });
-  void processAccumulatedEventsInfinitePass(rg);
-}
-function cmdSourceDataFetchFailure(args) {
-  const tokenIdx = args.indexOf("--token");
-  const reasonIdx = args.indexOf("--reason");
-  const token = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
-  const reason = reasonIdx !== -1 ? args[reasonIdx + 1] : "unknown";
-  if (!token) {
-    console.error("Usage: board-live-cards source-data-fetch-failure --token <sourceToken> [--reason <msg>]");
-    process.exit(1);
+  get size() {
+    if (!fs7.existsSync(this.journalPath)) return 0;
+    const content = fs7.readFileSync(this.journalPath, "utf-8").trim();
+    if (!content) return 0;
+    const entries = content.split("\n").map((l) => JSON.parse(l));
+    if (!this.lastDrainedId) return entries.length;
+    const drainedIdx = entries.findIndex((e) => e.id === this.lastDrainedId);
+    return drainedIdx === -1 ? entries.length : entries.length - drainedIdx - 1;
   }
-  const payload = decodeSourceToken(token);
-  if (!payload) {
-    console.error("Invalid source token");
-    process.exit(1);
+  get lastDrainedJournalId() {
+    return this.lastDrainedId;
   }
-  const { cbk, rg, cid, b, d, cs } = payload;
-  console.log(`[source-data-fetch-failure] ${cid}.${b}: ${reason}`);
-  const cbkDecoded = decodeCallbackToken2(cbk);
-  if (!cbkDecoded) {
-    console.error("Invalid callback token embedded in source token");
-    process.exit(1);
+};
+function readCardInventory(boardDir) {
+  const inventoryPath = path7.join(boardDir, INVENTORY_FILE);
+  if (!fs7.existsSync(inventoryPath)) return [];
+  const lines = fs7.readFileSync(inventoryPath, "utf-8").split("\n").filter((l) => l.trim());
+  return lines.map((l) => JSON.parse(l));
+}
+function lookupCardPath(boardDir, cardId) {
+  const entries = readCardInventory(boardDir);
+  const entry = entries.find((e) => e.cardId === cardId);
+  return entry?.cardFilePath ?? null;
+}
+function appendCardInventory(boardDir, entry) {
+  const inventoryPath = path7.join(boardDir, INVENTORY_FILE);
+  const normalized = { ...entry, cardFilePath: path7.resolve(entry.cardFilePath) };
+  fs7.appendFileSync(inventoryPath, JSON.stringify(normalized) + "\n");
+}
+function buildCardInventoryIndex(boardDir) {
+  const byCardId = /* @__PURE__ */ new Map();
+  const byCardPath = /* @__PURE__ */ new Map();
+  for (const entry of readCardInventory(boardDir)) {
+    const normalizedPath = path7.resolve(entry.cardFilePath);
+    const normalizedEntry = {
+      ...entry,
+      cardFilePath: normalizedPath
+    };
+    const existingById = byCardId.get(entry.cardId);
+    if (existingById && existingById.cardFilePath !== normalizedPath) {
+      throw new Error(
+        `Inventory invariant violation: card id "${entry.cardId}" maps to multiple files: "${existingById.cardFilePath}" and "${normalizedPath}"`
+      );
+    }
+    const existingByPath = byCardPath.get(normalizedPath);
+    if (existingByPath && existingByPath.cardId !== entry.cardId) {
+      throw new Error(
+        `Inventory invariant violation: file "${normalizedPath}" maps to multiple ids: "${existingByPath.cardId}" and "${entry.cardId}"`
+      );
+    }
+    byCardId.set(entry.cardId, normalizedEntry);
+    byCardPath.set(normalizedPath, normalizedEntry);
   }
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  appendEventToJournal(rg, {
-    type: "task-progress",
-    taskName: cbkDecoded.taskName,
-    update: { bindTo: b, outputFile: d, failure: true, reason, sourceChecksum: cs },
-    timestamp
-  });
-  void processAccumulatedEventsInfinitePass(rg);
+  return { byCardId, byCardPath };
 }
-function cmdRunSources(args) {
-  const cardIdx = args.indexOf("--card");
-  const tokenIdx = args.indexOf("--token");
-  const rgIdx = args.indexOf("--rg");
-  const sourceChecksumsIdx = args.indexOf("--source-checksums");
-  const cardFilePath = cardIdx !== -1 ? args[cardIdx + 1] : void 0;
-  const callbackToken = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
-  const boardDir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
-  const sourceChecksumsJson = sourceChecksumsIdx !== -1 ? args[sourceChecksumsIdx + 1] : void 0;
-  const sourceChecksums = sourceChecksumsJson ? JSON.parse(sourceChecksumsJson) : void 0;
-  if (!cardFilePath || !callbackToken || !boardDir) {
-    console.error("Usage: board-live-cards run-sourcedefs-internal --card <path> --token <token> --rg <dir> [--source-checksums <json>]");
-    process.exit(1);
+function initBoard(dir) {
+  const boardPath = path7.join(dir, BOARD_FILE);
+  if (fs7.existsSync(boardPath)) {
+    const envelope2 = JSON.parse(fs7.readFileSync(boardPath, "utf-8"));
+    restore(envelope2.graph);
+    return "exists";
   }
-  const card = JSON.parse(fs.readFileSync(cardFilePath, "utf-8"));
-  if (path.basename(cardFilePath).startsWith("card-enriched-")) {
-    try {
-      fs.unlinkSync(cardFilePath);
-    } catch {
+  if (fs7.existsSync(dir)) {
+    const entries = fs7.readdirSync(dir);
+    if (entries.length > 0) {
+      throw new Error(`Directory "${dir}" is not empty and has no valid ${BOARD_FILE}`);
     }
   }
-  console.log(`[run-sourcedefs-internal] Processing card "${card.id}"`);
-  const teConfig = readTaskExecutorConfig(boardDir);
-  const taskExecutor = teConfig?.command;
-  const taskExecutorExtraB64 = teConfig?.extra ? Buffer.from(JSON.stringify(teConfig.extra)).toString("base64") : void 0;
-  function runSource(src) {
-    const sourceChecksumForInvoke = src.outputFile ? sourceChecksums?.[src.outputFile] : void 0;
-    const sourceToken = encodeSourceToken({
-      cbk: callbackToken,
-      rg: boardDir,
-      cid: card.id,
-      b: src.bindTo,
-      d: src.outputFile ?? "",
-      cs: sourceChecksumForInvoke
-    });
-    function reportFailure(reason) {
-      invokeSourceDataFetchFailure(sourceToken, reason, (err) => {
-        if (err) console.error(`[run-sourcedefs-internal] source-data-fetch-failure call failed:`, err.message);
-      });
-    }
-    function reportFetched(outFile2) {
-      invokeSourceDataFetched(sourceToken, outFile2);
-    }
-    if (taskExecutor) {
-      if (!src.outputFile) {
-        console.warn(`[run-sourcedefs-internal] source "${src.bindTo}" has no outputFile configured \u2014 cannot deliver`);
-        reportFailure("no outputFile configured");
-        return;
-      }
-      const inFile = path.join(os.tmpdir(), `card-source-in-${src.bindTo}-${Date.now()}.json`);
-      const outFile2 = path.join(os.tmpdir(), `card-source-out-${src.bindTo}-${Date.now()}.json`);
-      const errFile = path.join(os.tmpdir(), `card-source-err-${src.bindTo}-${Date.now()}.txt`);
-      const sourceForExecutor = {
-        ...src,
-        cwd: typeof src.cwd === "string" && src.cwd ? src.cwd : path.dirname(cardFilePath || ""),
-        boardDir: typeof src.boardDir === "string" && src.boardDir ? src.boardDir : boardDir
-      };
-      appendTaskExecutorLog(boardDir, sourceForExecutor, "external-task-executor");
-      fs.writeFileSync(inFile, JSON.stringify(sourceForExecutor, null, 2), "utf-8");
-      const executorArgs = ["run-source-fetch", "--in", inFile, "--out", outFile2, "--err", errFile];
-      if (taskExecutorExtraB64) executorArgs.push("--extra", taskExecutorExtraB64);
-      console.log(`[run-sourcedefs-internal] task-executor: ${taskExecutor} ${executorArgs.join(" ")}`);
-      try {
-        execCommandSync(taskExecutor, executorArgs, {
-          shell: true,
-          timeout: src.timeout ?? 12e4
-        });
-      } catch (err) {
-        const reason = err.message ?? String(err);
-        console.error(`[run-sourcedefs-internal] task-executor failed for source "${src.bindTo}":`, reason);
-        reportFailure(reason);
-        return;
-      }
-      if (fs.existsSync(outFile2)) {
-        reportFetched(outFile2);
-      } else {
-        const errMsg = fs.existsSync(errFile) ? fs.readFileSync(errFile, "utf-8").trim() : "executor produced no output file";
-        console.warn(`[run-sourcedefs-internal] source "${src.bindTo}": ${errMsg}`);
-        reportFailure(errMsg);
-      }
-      return;
-    }
-    if (!src.outputFile) {
-      console.warn(`[run-sourcedefs-internal] source "${src.bindTo}" has no outputFile configured \u2014 cannot deliver`);
-      reportFailure("no outputFile configured");
-      return;
-    }
-    const outFile = path.join(os.tmpdir(), `card-source-out-${src.bindTo}-${Date.now()}.json`);
-    if (!src.cli) {
-      const errMsg = "source.cli is required for built-in source execution";
-      console.warn(`[run-sourcedefs-internal] source "${src.bindTo}": ${errMsg}`);
-      reportFailure(errMsg);
-      return;
-    }
-    const timeout = src.timeout ?? 12e4;
-    const sourceCwd = typeof src.cwd === "string" ? src.cwd : path.dirname(cardFilePath || "");
-    const sourceBoardDir = typeof src.boardDir === "string" ? src.boardDir : boardDir;
-    const sourceForBuiltInExecutor = {
-      ...src,
-      cwd: sourceCwd,
-      boardDir: sourceBoardDir
-    };
-    appendTaskExecutorLog(boardDir, sourceForBuiltInExecutor, "built-in-run-source-fetch");
-    const cmdParts = splitCommandLine(src.cli);
-    if (cmdParts.length === 0) {
-      const errMsg = "source.cli command is empty";
-      console.warn(`[run-sourcedefs-internal] source "${src.bindTo}": ${errMsg}`);
-      reportFailure(errMsg);
-      return;
-    }
-    const rawCmd = cmdParts[0];
-    const { cmd, args: cliArgs } = resolveCommandInvocation(rawCmd, cmdParts.slice(1));
-    let stdout;
-    try {
-      stdout = execCommandSync(cmd, cliArgs, {
-        shell: false,
-        encoding: "utf-8",
-        timeout,
-        cwd: sourceCwd,
-        env: {
-          ...process.env,
-          ...sourceBoardDir ? { BOARD_DIR: sourceBoardDir } : {}
-        }
-      });
-    } catch (err) {
-      const reason = err.message ?? String(err);
-      console.error(`[run-sourcedefs-internal] source fetch failed for source "${src.bindTo}":`, reason);
-      reportFailure(reason);
-      return;
+  fs7.mkdirSync(dir, { recursive: true });
+  const live = createLiveGraph(EMPTY_CONFIG);
+  const snap = snapshot(live);
+  const envelope = { lastDrainedJournalId: "", graph: snap };
+  fs7.writeFileSync(boardPath, JSON.stringify(envelope, null, 2));
+  return "created";
+}
+function loadBoardEnvelope(dir) {
+  const raw = fs7.readFileSync(path7.join(dir, BOARD_FILE), "utf-8");
+  return JSON.parse(raw);
+}
+function loadBoard(dir) {
+  const envelope = loadBoardEnvelope(dir);
+  return restore(envelope.graph);
+}
+function saveBoard(dir, rg, journal) {
+  const snap = rg.snapshot();
+  const envelope = {
+    lastDrainedJournalId: journal.lastDrainedJournalId,
+    graph: snap
+  };
+  writeJsonAtomic2(path7.join(dir, BOARD_FILE), envelope);
+  const live = restore(snap);
+  const statusObject = buildBoardStatusObject(path7.resolve(dir), live);
+  writeJsonAtomic2(resolveStatusSnapshotPath(dir), statusObject);
+}
+function runtimeOutConfigPath(boardDir) {
+  return path7.join(boardDir, RUNTIME_OUT_FILE);
+}
+function resolveConfiguredRuntimeOutDir(boardDir) {
+  const cfgPath = runtimeOutConfigPath(boardDir);
+  if (fs7.existsSync(cfgPath)) {
+    const configured = fs7.readFileSync(cfgPath, "utf-8").trim();
+    if (configured) {
+      return path7.isAbsolute(configured) ? configured : path7.resolve(boardDir, configured);
     }
-    fs.writeFileSync(outFile, stdout.trim(), "utf-8");
-    reportFetched(outFile);
   }
-  const source_defs = card.source_defs ?? [];
-  for (const src of source_defs) {
-    runSource(src);
+  const defaultDir = path7.join(boardDir, DEFAULT_RUNTIME_OUT_DIR);
+  fs7.writeFileSync(cfgPath, defaultDir, "utf-8");
+  return defaultDir;
+}
+function configureRuntimeOutDir(boardDir, runtimeOut) {
+  let resolved;
+  if (runtimeOut) {
+    resolved = path7.isAbsolute(runtimeOut) ? runtimeOut : path7.resolve(boardDir, runtimeOut);
+  } else {
+    resolved = path7.join(boardDir, DEFAULT_RUNTIME_OUT_DIR);
+  }
+  fs7.mkdirSync(resolved, { recursive: true });
+  fs7.writeFileSync(runtimeOutConfigPath(boardDir), resolved, "utf-8");
+  return resolved;
+}
+function resolveStatusSnapshotPath(boardDir) {
+  return path7.join(resolveConfiguredRuntimeOutDir(boardDir), RUNTIME_STATUS_FILE);
+}
+function resolveComputedValuesPath(boardDir, cardId) {
+  return path7.join(resolveConfiguredRuntimeOutDir(boardDir), RUNTIME_CARDS_DIR, `${cardId}.computed.json`);
+}
+function resolveDataObjectsDirPath(boardDir) {
+  return path7.join(resolveConfiguredRuntimeOutDir(boardDir), RUNTIME_DATA_OBJECTS_DIR);
+}
+function toDataObjectFileName(token) {
+  return token.replace(/[\\/]/g, "__");
+}
+function writeRuntimeDataObjects(boardDir, data) {
+  for (const [token, payload] of Object.entries(data)) {
+    if (!token) continue;
+    const fileName = toDataObjectFileName(token);
+    if (!fileName) continue;
+    const filePath = path7.join(resolveDataObjectsDirPath(boardDir), fileName);
+    writeJsonAtomic2(filePath, payload);
+  }
+}
+function writeJsonAtomic2(filePath, payload) {
+  fs7.mkdirSync(path7.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  fs7.writeFileSync(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
+  fs7.renameSync(tmpPath, filePath);
+}
+function withBoardLock(boardDir, fn) {
+  const boardPath = path7.join(boardDir, BOARD_FILE);
+  const release = lockSync(boardPath, { retries: { retries: 5, minTimeout: 100 } });
+  try {
+    return fn();
+  } finally {
+    release();
+  }
+}
+function decodeCallbackToken2(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token, "base64url").toString());
+    if (typeof payload?.t === "string") return { taskName: payload.t };
+    return null;
+  } catch {
+    return null;
   }
 }
-function cmdTaskProgress(args) {
-  const rgIdx = args.indexOf("--rg");
-  const tokenIdx = args.indexOf("--token");
-  const updateIdx = args.indexOf("--update");
-  const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
-  const token = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
-  const updateJson = updateIdx !== -1 ? args[updateIdx + 1] : "{}";
-  if (!dir || !token) {
-    console.error("Usage: board-live-cards task-progress --rg <dir> --token <token> [--update <json>]");
-    process.exit(1);
-  }
-  const decoded = decodeCallbackToken2(token);
-  if (!decoded) {
-    console.error("Invalid callback token");
-    process.exit(1);
-  }
-  const update = updateJson ? JSON.parse(updateJson) : {};
-  appendEventToJournal(dir, {
-    type: "task-progress",
-    taskName: decoded.taskName,
-    update,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  void processAccumulatedEventsInfinitePass(dir);
+function encodeSourceToken(payload) {
+  return Buffer.from(JSON.stringify(payload)).toString("base64url");
 }
-function cmdRunInference(args) {
-  const inIdx = args.indexOf("--in");
-  const tokenIdx = args.indexOf("--token");
-  const inFile = inIdx !== -1 ? args[inIdx + 1] : void 0;
-  const inferenceToken = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
-  if (!inFile || !inferenceToken) {
-    console.error("Usage: board-live-cards run-inference-internal --in <input.json> --token <inference-token>");
-    process.exit(1);
-  }
-  const decodedToken = decodeSourceToken(inferenceToken);
-  if (!decodedToken) {
-    console.error("Invalid inference token");
-    process.exit(1);
-  }
-  const callbackToken = decodedToken.cbk;
-  const boardDir = decodedToken.rg;
-  const cbkDecoded = decodeCallbackToken2(callbackToken);
-  if (!cbkDecoded) {
-    console.error("Invalid callback token embedded in inference token");
-    process.exit(1);
-  }
-  function spawnInferenceDone(tmpFile) {
-    const { cmd, args: cliArgs } = getCliInvocation("inference-done", ["--tmp", tmpFile, "--token", inferenceToken]);
-    spawnDetachedCommand(cmd, cliArgs);
-  }
-  function spawnInferenceDoneError(reason) {
-    const tmpFile = path.join(os.tmpdir(), `card-inference-err-${Date.now()}.json`);
-    fs.writeFileSync(tmpFile, JSON.stringify({ isTaskCompleted: false, reason }), "utf-8");
-    spawnInferenceDone(tmpFile);
+function decodeSourceToken(token) {
+  try {
+    const p = JSON.parse(Buffer.from(token, "base64url").toString());
+    if (typeof p?.cbk === "string" && typeof p?.cid === "string" && typeof p?.b === "string" && typeof p?.d === "string") {
+      return p;
+    }
+    return null;
+  } catch {
+    return null;
   }
-  if (!fs.existsSync(inFile)) {
-    spawnInferenceDoneError(`inference input not found: ${inFile}`);
-    return;
+}
+function appendEventToJournal(boardDir, event) {
+  const journalPath = path7.join(boardDir, JOURNAL_FILE);
+  const entry = { id: randomUUID(), event };
+  fs7.appendFileSync(journalPath, JSON.stringify(entry) + "\n", "utf-8");
+}
+function getUndrainedEntries(boardDir, lastDrainedId) {
+  const journalPath = path7.join(boardDir, JOURNAL_FILE);
+  if (!fs7.existsSync(journalPath)) return [];
+  const content = fs7.readFileSync(journalPath, "utf-8").trim();
+  if (!content) return [];
+  const entries = content.split("\n").map((l) => JSON.parse(l));
+  if (!lastDrainedId) return entries;
+  const idx = entries.findIndex((e) => e.id === lastDrainedId);
+  return idx === -1 ? entries : entries.slice(idx + 1);
+}
+function determineLatestPendingAccumulated(boardDir) {
+  const boardPath = path7.join(boardDir, BOARD_FILE);
+  if (!fs7.existsSync(boardPath)) return 0;
+  try {
+    const envelope = loadBoardEnvelope(boardDir);
+    return getUndrainedEntries(boardDir, envelope.lastDrainedJournalId).length;
+  } catch {
+    return 0;
   }
-  const adapterFile = path.join(boardDir, INFERENCE_ADAPTER_FILE);
-  const inferenceAdapter = fs.existsSync(adapterFile) ? fs.readFileSync(adapterFile, "utf-8").trim() : void 0;
-  if (!inferenceAdapter) {
-    spawnInferenceDoneError(`inference adapter is not configured (${INFERENCE_ADAPTER_FILE})`);
-    return;
+}
+function shouldUseShellForCommand(cmd, forceShell) {
+  if (typeof forceShell === "boolean") return forceShell;
+  return process.platform === "win32" && /\.(cmd|bat)$/i.test(cmd);
+}
+var _gitBashPath;
+var GIT_BASH_CACHE_FILE2 = path7.join(os3.tmpdir(), ".board-live-cards-git-bash-cache.json");
+function findGitBash2() {
+  if (_gitBashPath !== void 0) return _gitBashPath;
+  if (process.platform !== "win32") return _gitBashPath = false;
+  try {
+    const cached = JSON.parse(fs7.readFileSync(GIT_BASH_CACHE_FILE2, "utf8"));
+    if (cached.path === false || typeof cached.path === "string" && fs7.existsSync(cached.path)) {
+      return _gitBashPath = cached.path;
+    }
+  } catch {
   }
-  const outFile = path.join(os.tmpdir(), `card-inference-out-${Date.now()}.json`);
-  const errFile = path.join(os.tmpdir(), `card-inference-err-${Date.now()}.txt`);
-  const adapterParts = splitCommandLine(inferenceAdapter);
-  if (adapterParts.length === 0) {
-    spawnInferenceDoneError("inference adapter command is empty");
-    return;
+  const candidates = [
+    process.env.SHELL,
+    process.env.PROGRAMFILES && path7.join(process.env.PROGRAMFILES, "Git", "usr", "bin", "bash.exe"),
+    process.env.PROGRAMFILES && path7.join(process.env.PROGRAMFILES, "Git", "bin", "bash.exe"),
+    process.env["PROGRAMFILES(X86)"] && path7.join(process.env["PROGRAMFILES(X86)"], "Git", "bin", "bash.exe"),
+    process.env.LOCALAPPDATA && path7.join(process.env.LOCALAPPDATA, "Programs", "Git", "bin", "bash.exe")
+  ];
+  for (const c of candidates) {
+    if (c && /bash(\.exe)?$/i.test(c) && fs7.existsSync(c)) {
+      _gitBashPath = c;
+      try {
+        fs7.writeFileSync(GIT_BASH_CACHE_FILE2, JSON.stringify({ path: c }));
+      } catch {
+      }
+      return _gitBashPath;
+    }
   }
-  const adapterRawCmd = adapterParts[0];
-  const adapterRawArgs = adapterParts.slice(1);
-  const { cmd: adapterCmd, args: adapterArgsPrefix } = resolveCommandInvocation(adapterRawCmd, adapterRawArgs);
-  const adapterArgs = [...adapterArgsPrefix, "run-inference", "--in", inFile, "--out", outFile, "--err", errFile];
+  _gitBashPath = false;
   try {
-    execCommandSync(adapterCmd, adapterArgs, {
-      shell: false,
-      timeout: 12e4,
-      cwd: boardDir,
-      env: {
-        ...process.env,
-        BOARD_DIR: boardDir
-      }
-    });
-  } catch (err) {
-    const reason = err.message ?? String(err);
-    spawnInferenceDoneError(reason);
-    return;
+    fs7.writeFileSync(GIT_BASH_CACHE_FILE2, JSON.stringify({ path: false }));
+  } catch {
   }
-  if (!fs.existsSync(outFile)) {
-    const errMsg = fs.existsSync(errFile) ? fs.readFileSync(errFile, "utf-8").trim() : "inference adapter produced no output file";
-    spawnInferenceDoneError(errMsg);
+  return _gitBashPath;
+}
+function shellQuote2(s) {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+function spawnDetachedCommand(cmd, args) {
+  if (process.platform === "win32") {
+    const bash = findGitBash2();
+    if (bash) {
+      const shellCmd = [cmd, ...args].map((a) => shellQuote2(a.replace(/\\/g, "/"))).join(" ");
+      const child3 = spawn(bash, ["-c", shellCmd], { detached: true, stdio: "ignore", windowsHide: true });
+      child3.unref();
+      return;
+    }
+    const child2 = spawn("cmd", ["/c", "start", "/b", "", cmd, ...args], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child2.unref();
     return;
   }
-  spawnInferenceDone(outFile);
+  const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
+  child.unref();
 }
-function cmdInferenceDone(args) {
-  const tmpIdx = args.indexOf("--tmp");
-  const tokenIdx = args.indexOf("--token");
-  const tmpFile = tmpIdx !== -1 ? args[tmpIdx + 1] : void 0;
-  const inferenceToken = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
-  if (!tmpFile || !inferenceToken) {
-    console.error("Usage: board-live-cards inference-done --tmp <result.json> --token <inference-token>");
-    process.exit(1);
-  }
-  const decodedToken = decodeSourceToken(inferenceToken);
-  if (!decodedToken) {
-    console.error("Invalid inference token");
-    process.exit(1);
-  }
-  const { cbk: callbackToken, rg: dir, cs: inputChecksum } = decodedToken;
-  const decoded = decodeCallbackToken2(callbackToken);
-  if (!decoded) {
-    console.error("Invalid callback token embedded in inference token");
-    process.exit(1);
-  }
-  const taskName = decoded.taskName;
-  const cardPath = lookupCardPath(dir, taskName);
-  if (!cardPath) {
-    console.error(`Card file for task "${taskName}" not found in inventory`);
-    process.exit(1);
-  }
-  let result = {};
-  if (fs.existsSync(tmpFile)) {
-    try {
-      result = JSON.parse(fs.readFileSync(tmpFile, "utf-8").trim());
-    } catch (err) {
-      result = { isTaskCompleted: false, reason: `failed to parse inference result: ${err instanceof Error ? err.message : String(err)}` };
+function execCommandSync(cmd, args, options) {
+  const output = execFileSync(cmd, args, {
+    shell: shouldUseShellForCommand(cmd, options?.shell),
+    timeout: options?.timeout,
+    encoding: options?.encoding,
+    cwd: options?.cwd,
+    windowsHide: true,
+    env: options?.env
+  });
+  return typeof output === "string" ? output : output.toString("utf-8");
+}
+function execCommandAsync(cmd, args, callback) {
+  execFile(
+    cmd,
+    args,
+    { shell: shouldUseShellForCommand(cmd), encoding: "utf8", windowsHide: true },
+    (err, stdout, stderr) => callback(err ?? null, stdout, stderr)
+  );
+}
+function splitCommandLine(command) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  for (const ch of command.trim()) {
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      continue;
     }
-    try {
-      fs.unlinkSync(tmpFile);
-    } catch {
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
     }
-  } else {
-    result = { isTaskCompleted: false, reason: `inference result file not found: ${tmpFile}` };
-  }
-  const isTaskCompletedFlag = result.isTaskCompleted === true;
-  const inferenceCompletedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const card = JSON.parse(fs.readFileSync(cardPath, "utf-8"));
-  if (!card.card_data) card.card_data = {};
-  const cardData = card.card_data;
-  const existingInference = cardData.llm_task_completion_inference && typeof cardData.llm_task_completion_inference === "object" ? cardData.llm_task_completion_inference : {};
-  cardData.llm_task_completion_inference = {
-    ...existingInference,
-    isTaskCompleted: isTaskCompletedFlag,
-    reason: typeof result.reason === "string" ? result.reason : "",
-    evidence: typeof result.evidence === "string" ? result.evidence : "",
-    inferenceCompletedAt
-  };
-  fs.writeFileSync(cardPath, JSON.stringify(card, null, 2), "utf-8");
-  const runtimePath2 = path.join(dir, taskName, "runtime.json");
-  let runtime = { _sources: {} };
-  if (fs.existsSync(runtimePath2)) {
-    try {
-      runtime = JSON.parse(fs.readFileSync(runtimePath2, "utf-8"));
-    } catch {
+    if (/\s/.test(ch)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
     }
+    current += ch;
   }
-  const inferenceEntry = runtime._inferenceEntry ?? {};
-  runtime._inferenceEntry = nextEntryAfterFetchDelivery(inferenceEntry, inferenceCompletedAt);
-  fs.mkdirSync(path.dirname(runtimePath2), { recursive: true });
-  fs.writeFileSync(runtimePath2, JSON.stringify(runtime, null, 2), "utf-8");
-  appendEventToJournal(dir, {
-    type: "task-progress",
-    taskName,
-    update: {
-      kind: "inference-done",
-      isTaskCompleted: isTaskCompletedFlag,
-      inputChecksum
-    },
-    timestamp: inferenceCompletedAt
-  });
-  void processAccumulatedEventsInfinitePass(dir);
+  if (quote) {
+    throw new Error(`Unterminated quote in command: ${command}`);
+  }
+  if (current) tokens.push(current);
+  return tokens;
 }
-function cmdRunSourceFetch(args) {
-  const inIdx = args.indexOf("--in");
-  const outIdx = args.indexOf("--out");
-  const errIdx = args.indexOf("--err");
-  const inFile = inIdx !== -1 ? args[inIdx + 1] : void 0;
-  const outFile = outIdx !== -1 ? args[outIdx + 1] : void 0;
-  const errFile = errIdx !== -1 ? args[errIdx + 1] : void 0;
-  if (!inFile || !outFile) {
-    console.error("Usage: board-live-cards run-source-fetch --in <source.json> --out <result.json> [--err <error.txt>]");
-    process.exit(1);
+function resolveCommandInvocation(rawCmd, rawArgs) {
+  if (/^(node|node\.exe)$/i.test(rawCmd)) {
+    return { cmd: process.execPath, args: rawArgs };
   }
-  if (!fs.existsSync(inFile)) {
-    const msg = `Input file not found: ${inFile}`;
-    if (errFile) fs.writeFileSync(errFile, msg);
-    console.error(`[run-source-fetch] ${msg}`);
-    process.exit(1);
+  if (/\.m?js$/i.test(rawCmd)) {
+    return { cmd: process.execPath, args: [rawCmd, ...rawArgs] };
   }
-  let source;
+  return { cmd: rawCmd, args: rawArgs };
+}
+function spawnDetachedProcessAccumulatedWorker(boardDir) {
+  const { cmd, args: cliArgs } = getCliInvocation("process-accumulated-events", ["--rg", boardDir, "--inline-loop"]);
   try {
-    const raw = fs.readFileSync(inFile, "utf-8");
-    source = JSON.parse(raw);
-  } catch (err) {
-    const msg = `Failed to parse input file: ${err.message}`;
-    if (errFile) fs.writeFileSync(errFile, msg);
-    console.error(`[run-source-fetch] ${msg}`);
-    process.exit(1);
-  }
-  if (!source.cli) {
-    const msg = "Source definition missing cli field (board-live-cards built-in executor only understands source.cli)";
-    if (errFile) fs.writeFileSync(errFile, msg);
-    console.error(`[run-source-fetch] ${msg}`);
-    process.exit(1);
+    spawnDetachedCommand(cmd, cliArgs);
+    return true;
+  } catch {
+    return false;
   }
-  console.log(`[run-source-fetch] executing: ${source.cli}`);
-  const timeout = source.timeout ?? 12e4;
-  const sourceCwd = typeof source.cwd === "string" ? source.cwd : process.cwd();
-  const sourceBoardDir = typeof source.boardDir === "string" ? source.boardDir : void 0;
-  const cmdParts = splitCommandLine(source.cli);
-  if (cmdParts.length === 0) {
-    const msg = "Source cli command is empty";
-    if (errFile) fs.writeFileSync(errFile, msg);
-    console.error(`[run-source-fetch] ${msg}`);
-    process.exit(1);
+}
+async function processAccumulatedEventsInlineLoop(boardDir, settleDelayMs = 50) {
+  while (determineLatestPendingAccumulated(boardDir) > 0) {
+    const ran = await processAccumulatedEvents(boardDir);
+    if (!ran) return false;
+    await new Promise((resolve6) => setTimeout(resolve6, settleDelayMs));
   }
-  const rawCmd = cmdParts[0];
-  const { cmd, args: cliArgs } = resolveCommandInvocation(rawCmd, cmdParts.slice(1));
-  let stdout;
+  return true;
+}
+function shouldAvoidDetachedProcessSpawn() {
+  return process.env.BOARD_LIVE_CARDS_NO_SPAWN === "1";
+}
+async function processAccumulatedEvents(boardDir) {
+  const boardPath = path7.join(boardDir, BOARD_FILE);
+  const cliDir = path7.resolve(__dirname$1, "..", "..");
+  let release;
   try {
-    stdout = execCommandSync(cmd, cliArgs, {
-      shell: false,
-      encoding: "utf-8",
-      timeout,
-      cwd: sourceCwd,
-      env: {
-        ...process.env,
-        ...sourceBoardDir ? { BOARD_DIR: sourceBoardDir } : {}
-      }
-    });
-  } catch (err) {
-    const msg = err.message ?? String(err);
-    console.error(`[run-source-fetch] cli failed: ${msg}`);
-    if (errFile) fs.writeFileSync(errFile, msg);
-    process.exit(1);
+    release = lockSync(boardPath, { retries: 0 });
+  } catch {
+    return false;
   }
-  const result = stdout.trim();
   try {
-    fs.writeFileSync(outFile, result);
-    console.log(`[run-source-fetch] result written to ${outFile}`);
-  } catch (err) {
-    const msg = `Failed to write output file: ${err.message}`;
-    console.error(`[run-source-fetch] ${msg}`);
-    if (errFile) fs.writeFileSync(errFile, msg);
-    process.exit(1);
+    const cardHandlerAdapters = {
+      cardStore: createNodeCardStore(lookupCardPath),
+      runtimeStore: createNodeRuntimeStore(),
+      outputStore: createNodeOutputStore(resolveComputedValuesPath, resolveDataObjectsDirPath, INFERENCE_ADAPTER_LOG_FILE),
+      inputStore: createNodeInputStore(JOURNAL_FILE),
+      invocationAdapter: createNodeInvocationAdapter(cliDir, encodeSourceToken)
+    };
+    const envelope = loadBoardEnvelope(boardDir);
+    const live = restore(envelope.graph);
+    const journal = new BoardJournal(path7.join(boardDir, JOURNAL_FILE), envelope.lastDrainedJournalId);
+    const rg = createReactiveGraph(live, { handlers: { "card-handler": createCardHandlerFn(boardDir, cardHandlerAdapters) } });
+    const undrained = journal.drain();
+    rg.pushAll(undrained);
+    await rg.dispose({ wait: true });
+    saveBoard(boardDir, rg, journal);
+    return true;
+  } finally {
+    release();
   }
 }
-function cmdUpsertCard(args) {
-  const rgIdx = args.indexOf("--rg");
-  const cardIdx = args.indexOf("--card");
-  const globIdx = args.indexOf("--card-glob");
-  const cardIdIdx = args.indexOf("--card-id");
-  const restart = args.includes("--restart");
-  const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
-  const cardFile = cardIdx !== -1 ? args[cardIdx + 1] : void 0;
-  const cardGlob = globIdx !== -1 ? args[globIdx + 1] : void 0;
-  const requestedCardId = cardIdIdx !== -1 ? args[cardIdIdx + 1] : void 0;
-  if (!dir || !cardFile && !cardGlob || cardFile && cardGlob) {
-    console.error("Usage: board-live-cards upsert-card --rg <dir> (--card <card.json> | --card-glob <glob>) [--card-id <card-id>] [--restart]");
-    process.exit(1);
-  }
-  if (cardGlob && requestedCardId) {
-    console.error("Usage: --card-id may be used only with --card (single file), not with --card-glob");
-    process.exit(1);
-  }
-  const cardFiles = cardFile ? [path.resolve(cardFile)] : resolveCardGlobMatches(cardGlob);
-  if (!cardFile && cardFiles.length === 0) {
-    console.error(`No card files matched glob: ${cardGlob}`);
-    process.exit(1);
-  }
-  const idx = buildCardInventoryIndex(dir);
-  const batchByCardId = /* @__PURE__ */ new Map();
-  const batchByCardPath = /* @__PURE__ */ new Map();
-  const plans = [];
-  const logs = [];
-  for (const absCardPath of cardFiles) {
-    if (!fs.existsSync(absCardPath)) {
-      console.error(`Card file not found: ${absCardPath}`);
-      process.exit(1);
-    }
-    const card = JSON.parse(fs.readFileSync(absCardPath, "utf-8"));
-    if (!card.id) {
-      console.error(`Card JSON must have an "id" field (${absCardPath})`);
-      process.exit(1);
-    }
-    if (requestedCardId && requestedCardId !== card.id) {
-      console.error(
-        `Card id mismatch: --card-id "${requestedCardId}" does not match file id "${card.id}" (${absCardPath})`
-      );
-      process.exit(1);
-    }
-    const seenPathCardId = batchByCardPath.get(absCardPath);
-    if (seenPathCardId && seenPathCardId !== card.id) {
-      console.error(
-        `Upsert rejected: file "${absCardPath}" appears multiple times in batch with conflicting ids ("${seenPathCardId}" vs "${card.id}")`
-      );
-      process.exit(1);
-    }
-    const seenCardPath = batchByCardId.get(card.id);
-    if (seenCardPath && seenCardPath !== absCardPath) {
-      console.error(
-        `Upsert rejected: card id "${card.id}" appears multiple times in batch with conflicting files ("${seenCardPath}" vs "${absCardPath}")`
-      );
-      process.exit(1);
-    }
-    const existingById = idx.byCardId.get(card.id);
-    const existingByPath = idx.byCardPath.get(absCardPath);
-    if (existingByPath && existingByPath.cardId !== card.id) {
-      console.error(
-        `Upsert rejected: file "${absCardPath}" is already mapped to card id "${existingByPath.cardId}", cannot remap to "${card.id}"`
-      );
-      process.exit(1);
-    }
-    if (existingById && existingById.cardFilePath !== absCardPath) {
-      console.error(
-        `Upsert rejected: card id "${card.id}" is already mapped to file "${existingById.cardFilePath}", cannot remap to "${absCardPath}"`
-      );
-      process.exit(1);
-    }
-    batchByCardPath.set(absCardPath, card.id);
-    batchByCardId.set(card.id, absCardPath);
-    plans.push({
-      card,
-      absCardPath,
-      isInsert: !existingById
-    });
+async function processAccumulatedEventsInfinitePass(boardDir, settleDelayMs = 50, options) {
+  if (options?.inlineLoop || shouldAvoidDetachedProcessSpawn()) {
+    return processAccumulatedEventsInlineLoop(boardDir, settleDelayMs);
   }
-  for (const plan of plans) {
-    const { card, absCardPath, isInsert } = plan;
-    if (isInsert) {
-      const newEntry = {
-        cardId: card.id,
-        cardFilePath: absCardPath,
-        addedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      appendCardInventory(dir, newEntry);
-      idx.byCardId.set(card.id, newEntry);
-      idx.byCardPath.set(absCardPath, newEntry);
-    }
-    const taskConfig = liveCardToTaskConfig(card);
-    appendEventToJournal(dir, {
-      type: "task-upsert",
-      taskName: card.id,
-      taskConfig,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    if (restart) {
-      appendEventToJournal(dir, {
-        type: "task-restart",
-        taskName: card.id,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-    logs.push(`Card "${card.id}" ${isInsert ? "upserted (inserted)" : "upserted (updated)"}${restart ? " (restarted)" : ""}.`);
+  return spawnDetachedProcessAccumulatedWorker(boardDir);
+}
+async function processAccumulatedEventsForced(boardDir, options) {
+  await processAccumulatedEvents(boardDir);
+  await processAccumulatedEventsInfinitePass(boardDir, 50, options);
+}
+function liveCardToTaskConfig(card) {
+  const requires = card.requires;
+  const provides = card.provides?.map((p) => p.bindTo) ?? [];
+  return {
+    requires: requires && requires.length > 0 ? requires : void 0,
+    provides,
+    taskHandlers: ["card-handler"],
+    description: card.meta?.title ?? card.id
+  };
+}
+var __dirname$1 = path7.dirname(fileURLToPath(import.meta.url));
+var REPO_ROOT = path7.resolve(__dirname$1, "..", "..");
+var LOCAL_TSX_CLI = path7.join(REPO_ROOT, "node_modules", "tsx", "dist", "cli.mjs");
+function getCliInvocation(command, args) {
+  const jsPath = path7.join(__dirname$1, "board-live-cards-cli.js");
+  if (fs7.existsSync(jsPath)) {
+    return { cmd: process.execPath, args: [jsPath, command, ...args] };
   }
-  void processAccumulatedEventsInfinitePass(dir);
-  if (cardGlob) {
-    console.log(`Upserted ${cardFiles.length} cards from glob: ${cardGlob}${restart ? " (restarted)" : ""}`);
-  } else {
-    console.log(logs[0]);
+  const tsPath = path7.join(__dirname$1, "board-live-cards-cli.ts");
+  if (fs7.existsSync(tsPath) && fs7.existsSync(LOCAL_TSX_CLI)) {
+    return { cmd: process.execPath, args: [LOCAL_TSX_CLI, tsPath, command, ...args] };
   }
+  const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
+  return { cmd: npxCmd, args: ["tsx", tsPath, command, ...args] };
 }
-async function cmdTryDrain(args) {
-  const rgIdx = args.indexOf("--rg");
-  const inlineLoop = args.includes("--inline-loop");
-  const boardDir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
-  if (!boardDir) {
-    console.error("Usage: board-live-cards process-accumulated-events --rg <dir>");
-    process.exit(1);
+function appendTaskExecutorLog(boardDir, hydratedSource, mode) {
+  try {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      mode,
+      hydratedSource
+    };
+    fs7.appendFileSync(path7.join(boardDir, TASK_EXECUTOR_LOG_FILE), JSON.stringify(entry) + "\n", "utf-8");
+  } catch (logErr) {
+    console.error(`[task-executor-log] append failed: ${logErr instanceof Error ? logErr.message : String(logErr)}`);
   }
-  await processAccumulatedEventsForced(boardDir, { inlineLoop });
 }
-function cmdRetrigger(args) {
-  const rgIdx = args.indexOf("--rg");
-  const taskIdx = args.indexOf("--task");
-  const dir = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
-  const taskName = taskIdx !== -1 ? args[taskIdx + 1] : void 0;
-  if (!dir || !taskName) {
-    console.error("Usage: board-live-cards retrigger --rg <dir> --task <task-name>");
-    process.exit(1);
-  }
-  appendEventToJournal(dir, {
-    type: "task-restart",
-    taskName,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+function resolveCardGlobMatches(cardGlob) {
+  const patterns = cardGlob.split(",").map((s) => s.trim()).filter(Boolean).map((p) => p.replace(/\\/g, "/"));
+  const matches = fg.sync(patterns, {
+    absolute: true,
+    onlyFiles: true,
+    unique: true,
+    dot: false
   });
-  void processAccumulatedEventsInfinitePass(dir);
-  console.log(`Task "${taskName}" retriggered.`);
+  return [...matches].map((m) => path7.resolve(m)).sort((a, b) => a.localeCompare(b));
 }
 async function cli(argv) {
+  const boardCommandHandlers = createBoardCommandHandlers({
+    initBoard,
+    configureRuntimeOutDir,
+    loadBoard,
+    writeJsonAtomic: writeJsonAtomic2,
+    resolveStatusSnapshotPath,
+    buildBoardStatusObject: (dir, live) => buildBoardStatusObject(path7.resolve(dir), live),
+    readTaskExecutorConfig,
+    resolveCardGlobMatches,
+    validateLiveCardDefinition,
+    execCommandSync,
+    appendEventToJournal,
+    processAccumulatedEventsInfinitePass
+  });
+  const callbackCommandHandlers = createCallbackCommandHandlers({
+    decodeCallbackToken: decodeCallbackToken2,
+    decodeSourceToken,
+    writeRuntimeDataObjects,
+    appendEventToJournal,
+    processAccumulatedEventsForced,
+    processAccumulatedEventsInfinitePass
+  });
+  const nonCoreCommandHandlers = createNonCoreCommandHandlers({
+    readTaskExecutorConfig,
+    execCommandSync,
+    splitCommandLine,
+    resolveCommandInvocation
+  });
+  const cardCommandHandlers = createCardCommandHandlers({
+    resolveCardGlobMatches,
+    buildCardInventoryIndex,
+    appendCardInventory,
+    liveCardToTaskConfig,
+    appendEventToJournal,
+    processAccumulatedEventsInfinitePass
+  });
+  const executionCommandHandlers = createExecutionCommandHandlers({
+    INFERENCE_ADAPTER_FILE,
+    readTaskExecutorConfig,
+    execCommandSync,
+    execCommandAsync,
+    splitCommandLine,
+    resolveCommandInvocation,
+    encodeSourceToken,
+    decodeSourceToken,
+    decodeCallbackToken: decodeCallbackToken2,
+    spawnDetachedCommand,
+    getCliInvocation,
+    appendTaskExecutorLog,
+    appendEventToJournal,
+    processAccumulatedEventsInfinitePass,
+    processAccumulatedEventsForced,
+    lookupCardPath,
+    nextEntryAfterFetchDelivery
+  });
   const cmd = argv[0];
   const rest = argv.slice(1);
   switch (cmd) {
     case "help":
     case "--help":
     case "-h":
-      return cmdHelp();
+      return nonCoreCommandHandlers.cmdHelp();
     case "init":
-      return cmdInit(rest);
+      return boardCommandHandlers.cmdInit(rest);
     case "status":
-      return cmdStatus(rest);
+      return boardCommandHandlers.cmdStatus(rest);
     case "upsert-card":
-      return cmdUpsertCard(rest);
+      return cardCommandHandlers.cmdUpsertCard(rest);
     case "validate-card":
-      return cmdValidateCard(rest);
+      return boardCommandHandlers.cmdValidateCard(rest);
     case "remove-card":
-      return cmdRemoveCard(rest);
+      return boardCommandHandlers.cmdRemoveCard(rest);
     case "retrigger":
-      return cmdRetrigger(rest);
+      return boardCommandHandlers.cmdRetrigger(rest);
     case "task-completed":
-      return cmdTaskCompleted(rest);
+      return callbackCommandHandlers.cmdTaskCompleted(rest);
     case "task-failed":
-      return cmdTaskFailed(rest);
+      return callbackCommandHandlers.cmdTaskFailed(rest);
     case "task-progress":
-      return cmdTaskProgress(rest);
+      return callbackCommandHandlers.cmdTaskProgress(rest);
     case "source-data-fetched":
-      return cmdSourceDataFetched(rest);
+      return callbackCommandHandlers.cmdSourceDataFetched(rest);
     case "source-data-fetch-failure":
-      return cmdSourceDataFetchFailure(rest);
+      return callbackCommandHandlers.cmdSourceDataFetchFailure(rest);
     case "run-sourcedefs-internal":
-      return cmdRunSources(rest);
+      return executionCommandHandlers.cmdRunSources(rest);
     case "run-inference-internal":
-      return cmdRunInference(rest);
+      return executionCommandHandlers.cmdRunInference(rest);
     case "inference-done":
-      return cmdInferenceDone(rest);
+      return executionCommandHandlers.cmdInferenceDone(rest);
     case "run-source-fetch":
-      return cmdRunSourceFetch(rest);
+      return nonCoreCommandHandlers.cmdRunSourceFetch(rest);
     case "probe-source":
-      return await cmdProbeSource(rest);
+      return await nonCoreCommandHandlers.cmdProbeSource(rest);
     case "describe-task-executor-capabilities":
-      return cmdDescribeTaskExecutorCapabilities(rest);
+      return nonCoreCommandHandlers.cmdDescribeTaskExecutorCapabilities(rest);
     case "process-accumulated-events":
-      return await cmdTryDrain(rest);
+      return await executionCommandHandlers.cmdTryDrain(rest);
     default:
       throw new Error(`Unknown command: ${cmd ?? "(none)"}`);
   }
 }
-async function cmdProbeSource(args) {
-  const cardIdx = args.indexOf("--card");
-  const sourceIdxArg = args.indexOf("--source-idx");
-  const sourceBindArg = args.indexOf("--source-bind");
-  const mockProjectionsIdx = args.indexOf("--mock-projections");
-  const rgIdx = args.indexOf("--rg");
-  const outIdx = args.indexOf("--out");
-  const cardFilePath = cardIdx !== -1 ? args[cardIdx + 1] : void 0;
-  const sourceIdxVal = sourceIdxArg !== -1 ? parseInt(args[sourceIdxArg + 1], 10) : 0;
-  const sourceBindVal = sourceBindArg !== -1 ? args[sourceBindArg + 1] : void 0;
-  const mockProjectionsRaw = mockProjectionsIdx !== -1 ? args[mockProjectionsIdx + 1] : void 0;
-  const boardDirArg = rgIdx !== -1 ? args[rgIdx + 1] : void 0;
-  const outFile = outIdx !== -1 ? args[outIdx + 1] : void 0;
-  if (!cardFilePath) {
-    console.error("Usage: board-live-cards probe-source --card <card.json> [--source-idx <n>] [--source-bind <name>] [--mock-projections <json>] [--rg <boardDir>] [--out <result.json>]");
-    process.exit(1);
-  }
-  let card;
-  try {
-    card = JSON.parse(fs.readFileSync(path.resolve(cardFilePath), "utf-8"));
-  } catch (e) {
-    console.error(`[probe-source] Cannot read card: ${e.message}`);
-    process.exit(1);
-  }
-  const source_defs = card.source_defs ?? [];
-  if (source_defs.length === 0) {
-    console.error(`[probe-source] Card "${card.id}" has no source_defs`);
-    process.exit(1);
-  }
-  let sourceIdx;
-  if (sourceBindVal) {
-    sourceIdx = source_defs.findIndex((s) => s.bindTo === sourceBindVal);
-    if (sourceIdx === -1) {
-      console.error(`[probe-source] No source with bindTo="${sourceBindVal}" in card "${card.id}"`);
-      process.exit(1);
-    }
-  } else {
-    sourceIdx = sourceIdxVal;
-    if (isNaN(sourceIdx) || sourceIdx < 0 || sourceIdx >= source_defs.length) {
-      console.error(`[probe-source] --source-idx ${sourceIdxVal} out of range (card has ${source_defs.length} source(s))`);
-      process.exit(1);
-    }
-  }
-  const sourceDef = source_defs[sourceIdx];
-  const cardDir = path.resolve(path.dirname(cardFilePath));
-  const boardDir = boardDirArg ? path.resolve(boardDirArg) : cardDir;
-  let mockProjections = {};
-  if (mockProjectionsRaw) {
-    const raw = mockProjectionsRaw.startsWith("@") ? fs.readFileSync(path.resolve(mockProjectionsRaw.slice(1)), "utf-8") : mockProjectionsRaw;
-    try {
-      mockProjections = JSON.parse(raw);
-    } catch (e) {
-      console.error(`[probe-source] --mock-projections is not valid JSON: ${e.message}`);
-      process.exit(1);
-    }
-  }
-  const teConfig = readTaskExecutorConfig(boardDir);
-  const taskExecutor = teConfig?.command;
-  const taskExecutorExtraB64 = teConfig?.extra ? Buffer.from(JSON.stringify(teConfig.extra)).toString("base64") : void 0;
-  const inPayload = {
-    ...sourceDef,
-    cwd: typeof sourceDef.cwd === "string" && sourceDef.cwd ? sourceDef.cwd : cardDir,
-    boardDir: typeof sourceDef.boardDir === "string" && sourceDef.boardDir ? sourceDef.boardDir : boardDir,
-    _projections: mockProjections
-  };
-  let sourceKind = "unknown";
-  if (taskExecutor) {
-    try {
-      const capRaw = execCommandSync(taskExecutor, ["describe-capabilities"], {
-        shell: true,
-        timeout: 8e3,
-        encoding: "utf-8"
-      });
-      const caps = JSON.parse(String(capRaw));
-      const knownKinds = caps?.sourceKinds ? Object.keys(caps.sourceKinds) : [];
-      const defKeys = new Set(Object.keys(sourceDef));
-      sourceKind = knownKinds.find((k) => defKeys.has(k)) ?? "unknown";
-    } catch {
-    }
-  }
-  console.log(`[probe-source] card:        ${card.id}`);
-  console.log(`[probe-source] source[${sourceIdx}]:  bindTo="${sourceDef.bindTo}" kind=${sourceKind}`);
-  console.log(`[probe-source] _projections:       ${JSON.stringify(mockProjections)}`);
-  console.log(`[probe-source] executor:    ${taskExecutor ?? "built-in (source.cli only)"}`);
-  console.log(`[probe-source] running fetch...`);
-  const ts = Date.now();
-  const inFile = path.join(os.tmpdir(), `probe-in-${sourceDef.bindTo}-${ts}.json`);
-  const tmpOut = path.join(os.tmpdir(), `probe-out-${sourceDef.bindTo}-${ts}.json`);
-  const errFile = path.join(os.tmpdir(), `probe-err-${sourceDef.bindTo}-${ts}.txt`);
-  fs.writeFileSync(inFile, JSON.stringify(inPayload, null, 2), "utf-8");
-  let passed = false;
-  let errorMsg;
-  let resultRaw;
-  try {
-    if (taskExecutor) {
-      const executorArgs = ["run-source-fetch", "--in", inFile, "--out", tmpOut, "--err", errFile];
-      if (taskExecutorExtraB64) executorArgs.push("--extra", taskExecutorExtraB64);
-      execCommandSync(taskExecutor, executorArgs, {
-        shell: true,
-        timeout: sourceDef.timeout ?? 3e4
-      });
-    } else {
-      if (!inPayload.cli) {
-        throw new Error("No task-executor registered and source has no cli field \u2014 cannot probe with built-in executor");
-      }
-      const cmdParts = splitCommandLine(inPayload.cli);
-      const rawCmd = cmdParts[0];
-      const { cmd, args: cliArgs } = resolveCommandInvocation(rawCmd, cmdParts.slice(1));
-      const stdout = execCommandSync(cmd, cliArgs, {
-        shell: false,
-        encoding: "utf-8",
-        timeout: sourceDef.timeout ?? 3e4,
-        cwd: inPayload.cwd
-      });
-      fs.writeFileSync(tmpOut, stdout.trim(), "utf-8");
-    }
-    passed = fs.existsSync(tmpOut);
-    if (passed) {
-      resultRaw = fs.readFileSync(tmpOut, "utf-8");
-    } else {
-      errorMsg = fs.existsSync(errFile) ? fs.readFileSync(errFile, "utf-8").trim() : "executor produced no output file";
-    }
-  } catch (e) {
-    errorMsg = e.message ?? String(e);
-    if (!errorMsg && fs.existsSync(errFile)) {
-      errorMsg = fs.readFileSync(errFile, "utf-8").trim();
-    }
-  }
-  for (const f of [inFile, errFile]) {
-    try {
-      fs.unlinkSync(f);
-    } catch {
-    }
-  }
-  if (passed && resultRaw !== void 0) {
-    const resultSize = resultRaw.length;
-    const sample = resultRaw.slice(0, 300);
-    console.log(`[probe-source] STATUS:      PROBE_PASS`);
-    console.log(`[probe-source] result size: ${resultSize} bytes`);
-    console.log(`[probe-source] sample:      ${sample}${resultSize > 300 ? "..." : ""}`);
-    if (outFile) {
-      fs.writeFileSync(path.resolve(outFile), resultRaw);
-      console.log(`[probe-source] result written to: ${outFile}`);
-    } else {
-      try {
-        fs.unlinkSync(tmpOut);
-      } catch {
-      }
-    }
-  } else {
-    console.log(`[probe-source] STATUS:      PROBE_FAIL`);
-    if (errorMsg) console.log(`[probe-source] error:       ${errorMsg}`);
-    try {
-      if (fs.existsSync(tmpOut)) fs.unlinkSync(tmpOut);
-    } catch {
-    }
-  }
-  const summary = {
-    status: passed ? "PROBE_PASS" : "PROBE_FAIL",
-    cardId: card.id,
-    sourceIdx,
-    bindTo: sourceDef.bindTo,
-    sourceKind,
-    mockProjectionsKeys: Object.keys(mockProjections),
-    resultSizeBytes: resultRaw !== void 0 ? resultRaw.length : 0,
-    error: errorMsg ?? void 0
-  };
-  console.log(`[probe-source:result] ${JSON.stringify(summary)}`);
-  process.exit(passed ? 0 : 1);
-}
-function cmdDescribeTaskExecutorCapabilities(args) {
-  const rgIdx = args.indexOf("--rg");
-  const boardDir = rgIdx !== -1 ? path.resolve(args[rgIdx + 1]) : void 0;
-  if (!boardDir) {
-    console.error("Usage: board-live-cards describe-task-executor-capabilities --rg <dir>");
-    process.exit(1);
-  }
-  const teConfig = readTaskExecutorConfig(boardDir);
-  if (!teConfig) {
-    console.error(`[describe-task-executor-capabilities] No .task-executor registered in ${boardDir}`);
-    process.exit(1);
-  }
-  try {
-    const stdout = execCommandSync(teConfig.command, ["describe-capabilities"], {
-      shell: true,
-      timeout: 1e4,
-      encoding: "utf-8"
-    });
-    process.stdout.write(String(stdout));
-    if (!String(stdout).endsWith("\n")) process.stdout.write("\n");
-  } catch (e) {
-    console.error(`[describe-task-executor-capabilities] Executor failed: ${e.message ?? e}`);
-    process.exit(1);
-  }
-}
-function cmdHelp() {
-  console.log(`
-board-live-cards-cli \u2014 LiveCards board CLI
-
-USAGE
-  board-live-cards-cli <command> [options]
-
-BOARD MANAGEMENT
-  init <dir> [--task-executor <script>] [--chat-handler <script>] [--inference-adapter <script>] [--runtime-out <dir>]
-    Create a new board in <dir>.
-    If --task-executor is given, writes <dir>/.task-executor with the script path.
-    If --chat-handler is given, writes <dir>/.chat-handler with the script path.
-    If --inference-adapter is given, writes <dir>/.inference-adapter with the script path.
-    Writes <dir>/.runtime-out (default: <dir>/runtime-out).
-    Published runtime files:
-      <runtime-out>/board-livegraph-status.json
-      <runtime-out>/cards/<card-id>.computed.json
-    Re-running init on an existing board is safe; handler registrations are updated.
-
-  status --rg <dir> [--json]
-    Read and print the published status snapshot from <runtime-out>/board-livegraph-status.json.
-    --json emits the stable machine-readable status object.
-
-CARD MANAGEMENT
-  upsert-card --rg <dir> (--card <card.json> | --card-glob <glob>) [--card-id <card-id>] [--restart]
-    Insert or update one or many cards.
-    Enforces strict one-to-one mapping between card id and file path:
-      - same id + same file path: update
-      - new id + new file path: insert
-      - id remap or file remap: rejected
-    If --card-id is provided, it must match the id inside the file.
-    --card-id is valid only with --card (single file), not with --card-glob.
-    --restart clears the task so it re-triggers from scratch.
-
-  validate-card (--card <card.json> | --card-glob <glob>) [--rg <boardDir>]
-    Validate one or many card JSON files without adding them to a board.
-    Checks JSON Schema structure, runtime expression syntax, and provides.ref namespaces.
-    When --rg is provided, also invokes the board's task executor validate-source-def
-    subcommand to structurally validate each source definition against supported kinds.
-    Exits with code 1 if any card fails validation.
-
-  remove-card --rg <dir> --id <card-id>
-    Remove a card and its task from the board.
-
-  retrigger --rg <dir> --task <task-name>
-    Mark a task not-started and drain to re-trigger it.
-
-TASK CALLBACKS  (called by task executor scripts)
-  task-completed --token <callbackToken> [--data <json>]
-    Signal successful task completion with optional JSON result data.
-
-  task-failed --token <callbackToken> [--error <message>]
-    Signal task failure with an optional error message.
-
-  task-progress --rg <dir> --token <callbackToken> [--update <json>]
-    Signal task progress with optional update payload (for waiting on more evidence, etc.).
-
-SOURCE CALLBACKS  (called internally by run-sourcedefs-internal)
-  source-data-fetched --tmp <file> --token <sourceToken>
-    Atomically rename <file> into the outputFile destination and record delivery
-    via journal events. Appends a task-progress event to re-invoke the card handler.
-
-  source-data-fetch-failure --token <sourceToken> [--reason <message>]
-    Record a source fetch failure via journal events and append a task-progress event.
-
-INTERNAL COMMANDS
-  process-accumulated-events --rg <dir>
-    Executes forced drain for this board.
-    This command is also used as the background relay worker.
-    By default it schedules a detached worker and returns quickly.
-    Internal workers run with --inline-loop to perform the settle loop.
-
-    Eventual-progress guarantee is relay-based (not per-call blocking guarantee):
-    1) at least one runner continues processing,
-    2) no crash/forced exit in relay window,
-    3) lock stays healthy,
-    4) event production eventually quiesces.
-
-  run-sourcedefs-internal --card <card.json> --token <callbackToken> --rg <dir>
-    Execute all source[] entries for a card, then report delivery or failure.
-    (Internal command \u2014 invoked by the card-handler. Not intended for direct use.)
-
-    If <dir>/.task-executor exists, invokes it with run-source-fetch subcommand:
-      <executor> run-source-fetch --in <source_json> --out <outfile> --err <errfile>
-    
-    If no .task-executor is registered, uses board-live-cards built-in run-source-fetch.
-
-  run-source-fetch --in <source.json> --out <result.json> [--err <error.txt>]
-    Execute a source definition. Board-live-cards reads source.cli and executes it.
-    Writes result to --out. Presence of --out after exit indicates success.
-
-  describe-task-executor-capabilities --rg <dir>
-    Invoke the registered task-executor's describe-capabilities subcommand and
-    print its capabilities JSON to stdout.  Requires a .task-executor file in <dir>.
-
-  probe-source --card <card.json> [--source-idx <n>] [--source-bind <name>]
-               [--mock-projections <json>] [--rg <boardDir>] [--out <result.json>]
-    Validate that a card source can be fetched successfully.
-    Reads the card file, extracts the chosen source (default: index 0), builds the
-    run-source-fetch --in payload with the supplied _projections data, invokes the
-    registered task-executor (or built-in executor for source.cli), and reports pass/fail.
-    --mock-projections:     JSON string (or @file.json) providing pre-resolved _projections values
-                     the source needs.  Craft the minimal payload that exercises the
-                     source \u2014 e.g. '{"holdings":[{"ticker":"AAPL","quantity":10}]}'.
-                     If omitted, _projections is passed as empty ({}).
-    --source-idx:    0-based index into card.source_defs[]. Default: 0.
-    --source-bind:   Select source by its bindTo name instead of index.
-    --rg:            Board directory used to find .task-executor. Defaults to the
-                     directory containing the card file.
-    --out:           Optional path to write the raw fetch result JSON.
-    Prints a structured report ending with a [probe-source:result] JSON line.
-    Exits 0 on PROBE_PASS, 1 on PROBE_FAIL.
-
-  run-inference-internal --in <input.json> --token <inferenceToken>
-    Execute inference via registered .inference-adapter and forward result to inference-done.
-    inferenceToken encodes boardDir (rg), cardId (cid), callbackToken (cbk), checksum (cs).
-    (Internal command \u2014 invoked by the card-handler when custom completion rule is used.)
-
-  inference-done --tmp <result.json> --token <inferenceToken>
-    Persist llm_task_completion_inference on the card and append a task-progress event.
-    Reads boardDir/callbackToken/checksum from decoded inferenceToken; deletes --tmp file after reading.
-    (Internal command \u2014 invoked by run-inference-internal.)
-
-RUN-SOURCE-FETCH PROTOCOL
-  External task-executors implement:
-    <executor> run-source-fetch --in <source.json> --out <result.json> [--err <error.txt>]
-
-  INPUT:   --in file contains the full source_defs[x] definition object
-  OUTPUT:  --out file is written with the result to signal success.
-           --err file may be written to explain failure.
-           
-  Exit code and --out presence determine success:
-    Exit 0 + --out file present \u2192 source delivery recorded, card re-evaluated.
-    Exit non-zero OR --out absent \u2192 source-data-fetch-failure recorded.
-
-BOARD-LIVE-CARDS BUILT-IN EXECUTOR
-  Understands source.cli field only:
-    "source_defs": [{ "cli": "node ../fetch-prices.js", "bindTo": "prices", "outputFile": "prices.json" }]
-    
-  The source.cli command is executed with:
-    - Direct command invocation (no shell; quote-aware argument parsing)
-    - Stdout is captured and delivered to the card as-is
-    - Timeout from source.timeout (default 120s)
-    
-  The source.cli command must:
-    - Execute successfully (exit 0)
-    - Write output to stdout
-    - Complete within the timeout
-    
-  The output format is the concern of the card's compute function to interpret.
-    
-  External task-executors can interpret source definitions however they want.
-
-EXAMPLES
-  board-live-cards-cli init ./my-board
-  board-live-cards-cli init ./my-board --task-executor ./executors/my-runner.py
-  board-live-cards-cli upsert-card --rg ./my-board --card cards/prices.json
-  board-live-cards-cli status --rg ./my-board
-  board-live-cards-cli retrigger --rg ./my-board --task price-fetch
-  board-live-cards-cli probe-source --card cards/card-market-prices.json --source-idx 0 --rg ./my-board --mock-projections '{"holdings":[{"ticker":"AAPL","quantity":10}]}'
-`.trimStart());
-}
-var isMain = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1"));
+var isMain = process.argv[1] && path7.resolve(process.argv[1]) === path7.resolve(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1"));
 if (isMain) {
   cli(process.argv.slice(2)).catch((err) => {
     const msg = err instanceof Error ? err.message : String(err);
@@ -10287,6 +10593,6 @@ if (isMain) {
   });
 }
 
-export { BoardJournal, appendCardInventory, appendEventToJournal, buildCardInventoryIndex, cli, createBoardReactiveGraph, decideSourceAction, decodeSourceToken, encodeSourceToken, getUndrainedEntries, initBoard, isSourceInFlight, liveCardToTaskConfig, loadBoard, loadBoardEnvelope, lookupCardPath, nextEntryAfterFetchDelivery, nextEntryAfterFetchFailure, processAccumulatedEvents, processAccumulatedEventsForced, processAccumulatedEventsInfinitePass, readCardInventory, saveBoard, withBoardLock };
+export { BoardJournal, appendCardInventory, appendEventToJournal, buildCardInventoryIndex, cli, decideSourceAction, decodeSourceToken, encodeSourceToken, getUndrainedEntries, initBoard, isSourceInFlight, liveCardToTaskConfig, loadBoard, loadBoardEnvelope, lookupCardPath, nextEntryAfterFetchDelivery, nextEntryAfterFetchFailure, processAccumulatedEvents, processAccumulatedEventsForced, processAccumulatedEventsInfinitePass, readCardInventory, saveBoard, withBoardLock };
 //# sourceMappingURL=board-live-cards-cli.js.map
 //# sourceMappingURL=board-live-cards-cli.js.map