@hasna/workflows 0.1.2 → 0.1.4

package/dist/cli/index.js

@@ -18,12 +18,12 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/lanes/types.ts
-import { statSync } from "fs";
+import { statSync as statSync2 } from "fs";
 function binaryOnPath(binary) {
   const pathEntries = (process.env.PATH ?? "").split(":").filter(Boolean);
   for (const entry of pathEntries) {
     try {
-      const stat = statSync(`${entry}/${binary}`);
+      const stat = statSync2(`${entry}/${binary}`);
       if (stat.isFile())
         return true;
     } catch {}
@@ -298,10 +298,12 @@ function createCursorAdapter(deps = {}) {
       try {
         const run = await withTimeout(runLocalAgent(sdk, job), timeoutMs, `cursor lane (${job.prompt.slice(0, 60)})`);
         const durationMs = Date.now() - started;
-        const status = run?.status ?? "finished";
+        const status = run.status;
         const ok = status === "finished";
-        return { ok, exitCode: ok ? 0 : 1, output: run?.result ?? "", durationMs };
+        return { ok, exitCode: ok ? 0 : 1, output: run.result, durationMs };
       } catch (err) {
+        if (err instanceof LaneAdapterShapeError)
+          throw err;
         const durationMs = Date.now() - started;
         return { ok: false, exitCode: 1, output: "", durationMs, error: String(err instanceof Error ? err.message : err) };
       }
@@ -322,7 +324,14 @@ async function runLocalAgent(sdk, job) {
   if (!run || typeof run !== "object") {
     throw new LaneAdapterShapeError("@cursor/sdk Agent.send() returned no Run");
   }
-  return run;
+  const candidate = run;
+  if (typeof candidate.status !== "string" || !["finished", "error", "cancelled"].includes(candidate.status)) {
+    throw new LaneAdapterShapeError(`@cursor/sdk Agent.send() returned a Run without a terminal status (got ${JSON.stringify(candidate.status)}; expected finished|error|cancelled)`);
+  }
+  if (typeof candidate.result !== "string") {
+    throw new LaneAdapterShapeError("@cursor/sdk Agent.send() returned a Run without a string result");
+  }
+  return { status: candidate.status, result: candidate.result };
 }
 function runCursorCli(job, cliPath, started, timeoutMs) {
   try {
@@ -443,16 +452,13 @@ var init_lanes = __esm(() => {
 
 // src/cli/index.ts
 import { Command } from "commander";
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, rmSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
 import { hostname } from "os";
-import { join as join4 } from "path";
-
-// src/service.ts
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 // package.json
 var package_default = {
   name: "@hasna/workflows",
-  version: "0.1.2",
+  version: "0.1.4",
   description: "Universal graph workflow app \u2014 graph language (start/step/decision/while/end), three-table store, session WAL, daemon with claims/leases, four lane adapters (claude/codex/cursor/grok), and a full CLI on four surfaces",
   type: "module",
   main: "./dist/index.js",
@@ -522,23 +528,21 @@ var package_default = {
   author: "Hasna",
   license: "Apache-2.0",
   dependencies: {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.234",
+    "@anthropic-ai/claude-agent-sdk": "0.3.234",
     "@cursor/sdk": "^1.0.28",
-    "@openai/codex-sdk": "^0.147.0",
+    "@hasna/paths": "0.1.0",
+    "@openai/codex-sdk": "0.147.0",
     commander: "^13.1.0"
   },
   devDependencies: {
-    "@hasna/contracts": "0.14.1",
-    "@types/bun": "latest",
+    "@hasna/contracts": "0.14.2",
+    "@types/bun": "1.3.14",
     "@types/pg": "^8.15.6",
     pg: "^8.16.3",
     typescript: "^5.7.3"
   }
 };
 
-// src/daemon.ts
-import { createHash as createHash2 } from "crypto";
-
 // src/expr.ts
 class ExprSyntaxError extends Error {
   constructor(message) {
@@ -912,6 +916,18 @@ function validateGraph(graph) {
   if (typeof graph.version !== "string" || graph.version.trim() === "") {
     issue(issues, "version", "graph requires a version string");
   }
+  if (graph.memoWatch !== undefined) {
+    if (!Array.isArray(graph.memoWatch) || graph.memoWatch.length === 0) {
+      issue(issues, "memoWatch", "memoWatch must be a non-empty array of file paths or globs");
+    } else {
+      for (const entry of graph.memoWatch) {
+        if (typeof entry !== "string" || entry.trim() === "") {
+          issue(issues, "memoWatch", "each memoWatch entry must be a non-empty path or glob string");
+          break;
+        }
+      }
+    }
+  }
   if (!Array.isArray(graph.nodes) || graph.nodes.length === 0) {
     issue(issues, "nodes", "graph requires at least one node");
     return { ok: false, issues };
@@ -1146,6 +1162,8 @@ function assertNoSecrets(value, what) {
 
 // src/session.ts
 import { createHash } from "crypto";
+import { readFileSync, statSync } from "fs";
+import { isAbsolute, join } from "path";
 var DEFAULT_MAX_ATTEMPTS = 3;
 function repairTornRuns(store, wal, opts = {}) {
   const maxAttempts = opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
@@ -1201,6 +1219,46 @@ function recordMemo(store, graphName, nodeId, input, output) {
   const key = memoKey(graphName, nodeId, input);
   store.memoPut(key, graphName, nodeId, inputHash(input), JSON.stringify(output));
 }
+function memoWatchFingerprint(graph, dataDir) {
+  if (!graph.memoWatch || graph.memoWatch.length === 0)
+    return;
+  const entries = [];
+  for (const pattern of graph.memoWatch) {
+    if (hasGlobMagic(pattern)) {
+      const matches = [...new Bun.Glob(pattern).scanSync({ cwd: dataDir, onlyFiles: true })].sort();
+      for (const match of matches) {
+        const path2 = isAbsolute(match) ? match : join(dataDir, match);
+        entries.push(fingerprintFile(pattern, path2));
+      }
+      continue;
+    }
+    const path = isAbsolute(pattern) ? pattern : join(dataDir, pattern);
+    entries.push(fingerprintFile(pattern, path));
+  }
+  return entries;
+}
+function hasGlobMagic(pattern) {
+  return /[*?[\]{}]/.test(pattern);
+}
+function fingerprintFile(pattern, path) {
+  try {
+    const stat = statSync(path);
+    if (!stat.isFile()) {
+      return { pattern, path, missing: true, mtimeMs: null, size: null, sha256: null };
+    }
+    const content = readFileSync(path);
+    return {
+      pattern,
+      path,
+      missing: false,
+      mtimeMs: stat.mtimeMs,
+      size: content.byteLength,
+      sha256: createHash("sha256").update(content).digest("hex")
+    };
+  } catch {
+    return { pattern, path, missing: true, mtimeMs: null, size: null, sha256: null };
+  }
+}
 function resetRunNodes(store, run) {
   for (const node of store.listRunNodes(run.id)) {
     if (node.status === "running") {
@@ -1503,10 +1561,13 @@ class WorkflowsDaemon {
   }
   async executeStep(run, graph, context, wf, node) {
     const nodeId = node.id;
-    const existing = this.store.listRunNodes(run.id).find((n) => n.nodeId === nodeId);
-    const nodeRow = existing ?? this.store.createRunNode({ runId: run.id, nodeId, lane: node.lane ?? "claude" });
-    if (node.memo) {
-      const memoInput = { command: node.command, prompt: node.prompt, context: stripRunState(context) };
+    const latest = this.store.getLatestRunNode(run.id, nodeId);
+    const isLoopBody = graph.nodes.some((candidate) => candidate.type === "while" && candidate.body.includes(nodeId));
+    const nodeRow = latest === undefined || isLoopBody && latest.status === "completed" ? this.store.createRunNode({ runId: run.id, nodeId, lane: node.lane ?? "claude" }) : latest;
+    const memoWatch = node.memo ? memoWatchFingerprint(graph, this.store.dataDir) : undefined;
+    const memoSource = { command: node.command, prompt: node.prompt, context: stripRunState(context) };
+    const memoInput = node.memo ? memoWatch !== undefined ? { ...memoSource, memoWatch } : memoSource : undefined;
+    if (memoInput !== undefined) {
       const hit = tryMemoHit(this.store, run.graphName, nodeId, memoInput);
       if (hit) {
         const cached = JSON.parse(hit.outputJson);
@@ -1535,9 +1596,9 @@ class WorkflowsDaemon {
     }
     const output = { ok: result.ok, exitCode: result.exitCode, output: result.output, durationMs: result.durationMs };
     if (!result.ok) {
-      const retriesLeft = (node.maxRetries ?? 0) + 1 - nodeRow.attempts;
-      if (retriesLeft > 0) {
-        this.store.bumpAttemptsNode(nodeRow.id);
+      const shouldRetry = nodeRow.attempts < (node.maxRetries ?? 0);
+      this.store.bumpAttemptsNode(nodeRow.id);
+      if (shouldRetry) {
         this.store.setRunNodeStatus(nodeRow.id, "pending", { error: result.error ?? `exit ${result.exitCode}` });
         return { kind: "advanced", nodeId };
       }
@@ -1558,9 +1619,13 @@ class WorkflowsDaemon {
     }
     this.store.setRunNodeStatus(nodeRow.id, "completed", { exitCode: result.exitCode, output });
     this.wal.append({ op: "node_finished", runId: run.id, nodeId, status: "completed", at: nowIso() });
-    if (node.memo) {
-      recordMemo(this.store, run.graphName, nodeId, { command: node.command, prompt: node.prompt, context: stripRunState(context) }, output);
-      this.wal.append({ op: "memo_set", key: `${run.graphName}:${nodeId}:${createHash2("sha256").update(JSON.stringify({ command: node.command, prompt: node.prompt, context: stripRunState(context) })).digest("hex")}`, at: nowIso() });
+    if (memoInput !== undefined) {
+      const memoInputAfter = node.memo ? memoWatchFingerprint(graph, this.store.dataDir) : undefined;
+      const stable = memoWatch === undefined && memoInputAfter === undefined || memoWatch !== undefined && memoInputAfter !== undefined && JSON.stringify(memoWatch) === JSON.stringify(memoInputAfter);
+      if (stable) {
+        recordMemo(this.store, run.graphName, nodeId, memoInput, output);
+        this.wal.append({ op: "memo_set", key: memoKey(run.graphName, nodeId, memoInput), at: nowIso() });
+      }
     }
     this.recordStepResult(context, nodeId, output);
     return this.afterNode(run, context, wf, node.next);
@@ -1655,6 +1720,7 @@ async function runGraphToCompletion(store, wal, graph, context, options = {}) {
     isolatedRunId: options.isolatedRunId
   });
   const run = daemon.startRun(graph, context);
+  options.onRunCreated?.(run);
   daemon.isolateRun(run.id);
   const maxCycles = options.maxCycles ?? 500;
   for (let cycle = 0;cycle < maxCycles; cycle++) {
@@ -1669,20 +1735,71 @@ async function runGraphToCompletion(store, wal, graph, context, options = {}) {
   return store.getRun(run.id);
 }
 
+// src/paths.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { dataDir } from "@hasna/paths";
+var APP = "workflows";
+var STORE_DB_FILE = "workflows.db";
+function getHomeDir(env = process.env) {
+  return env["HOME"] || env["USERPROFILE"] || homedir();
+}
+function getLegacyDataDir(env = process.env) {
+  return join2(getHomeDir(env), ".hasna", APP);
+}
+function getResolverDataDir(env = process.env) {
+  return dataDir({ app: APP, home: getHomeDir(env), env });
+}
+function adoptResolverDataDir(resolved, env = process.env) {
+  const dataOverride = env.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync(join2(resolved, STORE_DB_FILE));
+}
+function getEffectiveDataDir(env = process.env) {
+  const resolved = getResolverDataDir(env);
+  return adoptResolverDataDir(resolved, env) ? resolved : getLegacyDataDir(env);
+}
+
 // src/store.ts
 import { Database } from "bun:sqlite";
 import { mkdirSync } from "fs";
-import { join } from "path";
+import { join as join3 } from "path";
 import { randomUUID } from "crypto";
 function nowIso2() {
   return new Date().toISOString();
 }
-function openStore(dataDir) {
-  mkdirSync(dataDir, { recursive: true });
-  const db = new Database(join(dataDir, "workflows.db"));
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA foreign_keys = ON");
-  db.exec(`
+var BUSY_TIMEOUT_MS = 3000;
+var BUSY_RETRIES = 2;
+var BUSY_RETRY_SLEEP_MS = 50;
+function isBusyError(err) {
+  if (!(err instanceof Error))
+    return false;
+  const code = String(err.code ?? "");
+  return code.includes("BUSY") || /\bdatabase is locked\b/i.test(err.message);
+}
+function retryBusy(fn) {
+  let last;
+  for (let attempt = 0;attempt <= BUSY_RETRIES; attempt++) {
+    try {
+      return fn();
+    } catch (err) {
+      if (!isBusyError(err))
+        throw err;
+      last = err;
+      Bun.sleepSync(BUSY_RETRY_SLEEP_MS);
+    }
+  }
+  throw last;
+}
+function openStore(dataDir2) {
+  mkdirSync(dataDir2, { recursive: true });
+  const db = new Database(join3(dataDir2, "workflows.db"));
+  retryBusy(() => db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`));
+  retryBusy(() => db.exec("PRAGMA journal_mode = WAL"));
+  retryBusy(() => db.exec("PRAGMA foreign_keys = ON"));
+  retryBusy(() => db.exec(`
     CREATE TABLE IF NOT EXISTS runs (
       id            TEXT PRIMARY KEY,
       graph_name    TEXT NOT NULL,
@@ -1722,7 +1839,7 @@ function openStore(dataDir) {
     CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
     CREATE INDEX IF NOT EXISTS idx_runs_created ON runs(created_at);
     CREATE INDEX IF NOT EXISTS idx_run_nodes_run ON run_nodes(run_id);
-  `);
+  `));
   const rowToRun = (r) => ({
     id: String(r.id),
     graphName: String(r.graph_name),
@@ -1760,31 +1877,33 @@ function openStore(dataDir) {
     createdAt: String(r.created_at)
   });
   return {
+    dataDir: dataDir2,
     close() {
       db.close();
     },
     listTables() {
-      const rows = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").all();
+      const rows = retryBusy(() => db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").all());
       return rows.map((r) => r.name);
     },
     createRun(input) {
       const id = randomUUID();
       const now = nowIso2();
-      db.query(`INSERT INTO runs (id, graph_name, graph_version, status, attempts, context_json, created_at, updated_at)
-         VALUES (?, ?, ?, 'pending', 0, ?, ?, ?)`).run(id, input.graphName, input.graphVersion, JSON.stringify(input.context ?? {}), now, now);
+      retryBusy(() => db.query(`INSERT INTO runs (id, graph_name, graph_version, status, attempts, context_json, created_at, updated_at)
+             VALUES (?, ?, ?, 'pending', 0, ?, ?, ?)`).run(id, input.graphName, input.graphVersion, JSON.stringify(input.context ?? {}), now, now));
       return this.getRun(id);
     },
     getRun(id) {
-      const row = db.query(`SELECT * FROM runs WHERE id = ?`).get(id);
+      const row = retryBusy(() => db.query(`SELECT * FROM runs WHERE id = ?`).get(id));
       return row ? rowToRun(row) : undefined;
     },
     listRuns(opts = {}) {
       const limit = Math.min(opts.limit ?? 100, 1000);
       if (opts.status) {
-        const rows2 = db.query(`SELECT * FROM runs WHERE status = ? ORDER BY created_at DESC, id DESC LIMIT ?`).all(opts.status, limit);
+        const status = opts.status;
+        const rows2 = retryBusy(() => db.query(`SELECT * FROM runs WHERE status = ? ORDER BY created_at DESC, id DESC LIMIT ?`).all(status, limit));
         return rows2.map((r) => rowToRun(r));
       }
-      const rows = db.query(`SELECT * FROM runs ORDER BY created_at DESC, id DESC LIMIT ?`).all(limit);
+      const rows = retryBusy(() => db.query(`SELECT * FROM runs ORDER BY created_at DESC, id DESC LIMIT ?`).all(limit));
       return rows.map((r) => rowToRun(r));
     },
     setRunStatus(id, status, patch = {}) {
@@ -1795,28 +1914,32 @@ function openStore(dataDir) {
       const startedAt = patch.startedAt !== undefined ? patch.startedAt : status === "running" && existing?.startedAt === null ? now : existing?.startedAt ?? null;
       const terminal = status === "completed" || status === "failed" || status === "cancelled" || status === "interrupted";
       const finishedAt = patch.finishedAt !== undefined ? patch.finishedAt : terminal && existing?.finishedAt === null ? now : existing?.finishedAt ?? null;
-      db.query(`UPDATE runs SET status = ?, result_json = ?, error = ?, started_at = ?, finished_at = ?, updated_at = ? WHERE id = ?`).run(status, resultJson, error, startedAt, finishedAt, now, id);
+      retryBusy(() => db.query(`UPDATE runs SET status = ?, result_json = ?, error = ?, started_at = ?, finished_at = ?, updated_at = ? WHERE id = ?`).run(status, resultJson, error, startedAt, finishedAt, now, id));
     },
     bumpAttempts(id) {
-      db.query(`UPDATE runs SET attempts = attempts + 1, updated_at = ? WHERE id = ?`).run(nowIso2(), id);
+      retryBusy(() => db.query(`UPDATE runs SET attempts = attempts + 1, updated_at = ? WHERE id = ?`).run(nowIso2(), id));
     },
     setRunContext(id, context) {
-      db.query(`UPDATE runs SET context_json = ?, updated_at = ? WHERE id = ?`).run(JSON.stringify(context), nowIso2(), id);
+      retryBusy(() => db.query(`UPDATE runs SET context_json = ?, updated_at = ? WHERE id = ?`).run(JSON.stringify(context), nowIso2(), id));
     },
     createRunNode(input) {
       const id = randomUUID();
-      db.query(`INSERT INTO run_nodes (id, run_id, node_id, status, attempts, lane)
-         VALUES (?, ?, ?, 'pending', 0, ?)`).run(id, input.runId, input.nodeId, input.lane ?? null);
+      retryBusy(() => db.query(`INSERT INTO run_nodes (id, run_id, node_id, status, attempts, lane)
+             VALUES (?, ?, ?, 'pending', 0, ?)`).run(id, input.runId, input.nodeId, input.lane ?? null));
       return this.getRunNode(id);
     },
     getRunNode(id) {
-      const row = db.query(`SELECT * FROM run_nodes WHERE id = ?`).get(id);
+      const row = retryBusy(() => db.query(`SELECT * FROM run_nodes WHERE id = ?`).get(id));
       return row ? rowToNode(row) : undefined;
     },
     listRunNodes(runId) {
-      const rows = db.query(`SELECT * FROM run_nodes WHERE run_id = ? ORDER BY rowid ASC`).all(runId);
+      const rows = retryBusy(() => db.query(`SELECT * FROM run_nodes WHERE run_id = ? ORDER BY rowid ASC`).all(runId));
       return rows.map((r) => rowToNode(r));
     },
+    getLatestRunNode(runId, nodeId) {
+      const row = retryBusy(() => db.query(`SELECT * FROM run_nodes WHERE run_id = ? AND node_id = ? ORDER BY rowid DESC LIMIT 1`).get(runId, nodeId));
+      return row ? rowToNode(row) : undefined;
+    },
     setRunNodeStatus(id, status, patch = {}) {
       const now = nowIso2();
       const existing = this.getRunNode(id);
@@ -1828,44 +1951,44 @@ function openStore(dataDir) {
       const startedAt = patch.startedAt !== undefined ? patch.startedAt : status === "running" && existing.startedAt === null ? now : existing.startedAt;
       const terminal = status === "completed" || status === "failed" || status === "skipped";
       const finishedAt = patch.finishedAt !== undefined ? patch.finishedAt : terminal && existing.finishedAt === null ? now : existing.finishedAt;
-      db.query(`UPDATE run_nodes SET status = ?, exit_code = ?, output_json = ?, error = ?, started_at = ?, finished_at = ? WHERE id = ?`).run(status, exitCode, outputJson, error, startedAt, finishedAt, id);
+      retryBusy(() => db.query(`UPDATE run_nodes SET status = ?, exit_code = ?, output_json = ?, error = ?, started_at = ?, finished_at = ? WHERE id = ?`).run(status, exitCode, outputJson, error, startedAt, finishedAt, id));
     },
     bumpAttemptsNode(id) {
-      db.query(`UPDATE run_nodes SET attempts = attempts + 1 WHERE id = ?`).run(id);
+      retryBusy(() => db.query(`UPDATE run_nodes SET attempts = attempts + 1 WHERE id = ?`).run(id));
     },
     memoPut(key, graphName, nodeId, inputHash2, outputJson) {
-      db.query(`INSERT INTO memos (key, graph_name, node_id, input_hash, output_json, hit_count, created_at)
-         VALUES (?, ?, ?, ?, ?, 0, ?)
-         ON CONFLICT(key) DO UPDATE SET output_json = excluded.output_json`).run(key, graphName, nodeId, inputHash2, outputJson, nowIso2());
+      retryBusy(() => db.query(`INSERT INTO memos (key, graph_name, node_id, input_hash, output_json, hit_count, created_at)
+             VALUES (?, ?, ?, ?, ?, 0, ?)
+             ON CONFLICT(key) DO UPDATE SET output_json = excluded.output_json`).run(key, graphName, nodeId, inputHash2, outputJson, nowIso2()));
     },
     memoGet(key) {
-      const row = db.query(`SELECT * FROM memos WHERE key = ?`).get(key);
+      const row = retryBusy(() => db.query(`SELECT * FROM memos WHERE key = ?`).get(key));
       return row ? rowToMemo(row) : undefined;
     },
     memoHit(key) {
-      db.query(`UPDATE memos SET hit_count = hit_count + 1 WHERE key = ?`).run(key);
+      retryBusy(() => db.query(`UPDATE memos SET hit_count = hit_count + 1 WHERE key = ?`).run(key));
     },
     memoList() {
-      const rows = db.query(`SELECT * FROM memos ORDER BY created_at DESC LIMIT 1000`).all();
+      const rows = retryBusy(() => db.query(`SELECT * FROM memos ORDER BY created_at DESC LIMIT 1000`).all());
       return rows.map((r) => rowToMemo(r));
     },
     memoClear() {
-      db.exec(`DELETE FROM memos`);
+      retryBusy(() => db.exec(`DELETE FROM memos`));
     }
   };
 }
 
 // src/wal.ts
-import { createHash as createHash3 } from "crypto";
-import { appendFileSync, existsSync, mkdirSync as mkdirSync2, readFileSync, renameSync, truncateSync, writeFileSync } from "fs";
-import { join as join2 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, truncateSync, writeFileSync } from "fs";
+import { join as join4 } from "path";
 var WAL_FILE_NAME = "session.wal";
 var SESSIONS_DIR_NAME = "sessions";
 var MAX_WAL_BYTES = 256 * 1024 * 1024;
 function checksumOf(op) {
   if (op === undefined || op === null)
     return "";
-  return createHash3("sha256").update(JSON.stringify(op)).digest("hex");
+  return createHash2("sha256").update(JSON.stringify(op)).digest("hex");
 }
 
 class SessionWAL {
@@ -1873,11 +1996,11 @@ class SessionWAL {
   constructor(filePath) {
     this.filePath = filePath;
   }
-  static open(dataDir) {
-    mkdirSync2(join2(dataDir, SESSIONS_DIR_NAME), { recursive: true });
-    const canonical = join2(dataDir, SESSIONS_DIR_NAME, WAL_FILE_NAME);
-    const legacy = join2(dataDir, WAL_FILE_NAME);
-    if (existsSync(legacy) && !existsSync(canonical)) {
+  static open(dataDir2) {
+    mkdirSync2(join4(dataDir2, SESSIONS_DIR_NAME), { recursive: true });
+    const canonical = join4(dataDir2, SESSIONS_DIR_NAME, WAL_FILE_NAME);
+    const legacy = join4(dataDir2, WAL_FILE_NAME);
+    if (existsSync2(legacy) && !existsSync2(canonical)) {
       try {
         renameSync(legacy, canonical);
       } catch {
@@ -1908,7 +2031,7 @@ class SessionWAL {
     let repaired = false;
     let content;
     try {
-      content = readFileSync(this.filePath, "utf8");
+      content = readFileSync2(this.filePath, "utf8");
     } catch {
       return { entries, torn, repaired, liveClaims: () => new Map };
     }
@@ -2008,11 +2131,10 @@ function envInt(names, fallback) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 function resolveWorkflowsConfig(overrides = {}) {
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
   return {
     port: overrides.port ?? envInt(["HASNA_WORKFLOWS_PORT", "WORKFLOWS_PORT"], DEFAULT_PORT),
     host: overrides.host ?? envString(["HASNA_WORKFLOWS_HOST", "WORKFLOWS_HOST"]) ?? DEFAULT_HOST,
-    dataDir: overrides.dataDir ?? envString(["HASNA_WORKFLOWS_DATA_DIR", "WORKFLOWS_DATA_DIR"]) ?? join3(home, ".hasna", "workflows"),
+    dataDir: overrides.dataDir ?? envString(["HASNA_WORKFLOWS_DATA_DIR", "WORKFLOWS_DATA_DIR"]) ?? getEffectiveDataDir(),
     apiUrl: overrides.apiUrl ?? envString(["WORKFLOWS_API_URL"]),
     apiKey: overrides.apiKey ?? envString(["WORKFLOWS_API_KEY"])
   };
@@ -2172,7 +2294,7 @@ init_lanes();
 init_types();
 
 // src/handlers.ts
-import { createHash as createHash4, timingSafeEqual } from "crypto";
+import { createHash as createHash3, timingSafeEqual } from "crypto";
 function jsonResponse(body, status = 200) {
   return new Response(JSON.stringify(body), {
     status,
@@ -2228,8 +2350,8 @@ function bearerMatches(authHeader, expected) {
   const supplied = authHeader.slice("Bearer ".length);
   if (supplied.length === 0)
     return false;
-  const a = createHash4("sha256").update(supplied).digest();
-  const b = createHash4("sha256").update(expected).digest();
+  const a = createHash3("sha256").update(supplied).digest();
+  const b = createHash3("sha256").update(expected).digest();
   return timingSafeEqual(a, b);
 }
 async function handleTrigger(service, req) {
@@ -2330,7 +2452,7 @@ program.command("info").description("Show service configuration (never credentia
 function loadGraph(file) {
   let raw;
   try {
-    raw = readFileSync2(file, "utf8");
+    raw = readFileSync3(file, "utf8");
   } catch {
     throw new Error(`cannot read graph file ${file}`);
   }
@@ -2398,12 +2520,12 @@ function runSummary(row) {
 }
 program.command("init").description("Create the store layout (workflows/, sessions/, workflows.db) and scaffold a sample graph").argument("[file]", "sample graph output path (default <dataDir>/workflows/demo.json)").action((file) => {
   const config = resolveWorkflowsConfig();
-  mkdirSync3(join4(config.dataDir, "workflows"), { recursive: true });
-  mkdirSync3(join4(config.dataDir, SESSIONS_DIR_NAME), { recursive: true });
+  mkdirSync3(join5(config.dataDir, "workflows"), { recursive: true });
+  mkdirSync3(join5(config.dataDir, SESSIONS_DIR_NAME), { recursive: true });
   const store = openStore(config.dataDir);
   store.close();
-  const target = file ?? join4(config.dataDir, "workflows", "demo.json");
-  if (existsSync2(target)) {
+  const target = file ?? join5(config.dataDir, "workflows", "demo.json");
+  if (existsSync3(target)) {
     console.error(`refusing to overwrite existing file ${target}`);
     process.exit(1);
   }
@@ -2461,14 +2583,18 @@ program.command("graph").description("Render a workflow graph (text, DOT, or JSO
   }
 });
 program.command("run").description("Run a workflow graph to a terminal state (bounded)").argument("<file>", "graph JSON file").option("--context <json>", "JSON context object for the run").option("--input <k=v>", "run input key=value (repeatable; merged over --context)", collectInput, []).option("--idempotency-key <key>", "re-run with the same key returns the existing run").option("--max-cycles <n>", "bound on reap cycles", "500").option("-j, --json", "JSON output").action(async (file, opts) => {
-  const graph = loadGraph(file);
-  const validation = validateGraph(graph);
-  if (!validation.ok) {
-    throw new Error(`graph validation failed: ${validation.issues.map((i) => `${i.path}: ${i.message}`).join("; ")}`);
-  }
-  const context = mergeRunContext(opts.context, opts.input ?? []);
-  const { store, wal } = openLocal();
+  let store;
+  let createdRunId;
   try {
+    const graph = loadGraph(file);
+    const validation = validateGraph(graph);
+    if (!validation.ok) {
+      throw new Error(`graph validation failed: ${validation.issues.map((i) => `${i.path}: ${i.message}`).join("; ")}`);
+    }
+    const context = mergeRunContext(opts.context, opts.input ?? []);
+    const local = openLocal();
+    store = local.store;
+    const wal = local.wal;
     if (opts.idempotencyKey) {
       const existing = findRunByIdempotencyKey(store, opts.idempotencyKey);
       if (existing) {
@@ -2479,13 +2605,18 @@ program.command("run").description("Run a workflow graph to a terminal state (bo
           console.log(`reused run ${existing.id}: ${existing.status}`);
         }
         if (existing.status !== "completed")
-          process.exit(1);
+          process.exitCode = 1;
         return;
       }
     }
     const contextWithKey = opts.idempotencyKey ? withIdempotencyKey(context, opts.idempotencyKey) : context;
     const maxCycles = Number(opts.maxCycles ?? 500);
-    const final = await runGraphToCompletion(store, wal, graph, contextWithKey, { maxCycles });
+    const final = await runGraphToCompletion(store, wal, graph, contextWithKey, {
+      maxCycles,
+      onRunCreated: (run) => {
+        createdRunId = run.id;
+      }
+    });
     const summary = runSummary(final);
     if (opts.json) {
       console.log(JSON.stringify(summary, null, 2));
@@ -2495,9 +2626,17 @@ program.command("run").description("Run a workflow graph to a terminal state (bo
         console.log(final.resultJson);
     }
     if (final.status !== "completed")
-      process.exit(1);
+      process.exitCode = 1;
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    if (opts.json) {
+      console.log(JSON.stringify({ error, ...createdRunId ? { runId: createdRunId } : {} }, null, 2));
+    } else {
+      console.error(error);
+    }
+    process.exitCode = 1;
   } finally {
-    store.close();
+    store?.close();
   }
 });
 program.command("runs").description("Manage runs").argument("<action>", "list | show | cancel | resume | events").argument("[id]", "run id (show/cancel/resume/events)").option("--status <status>", "filter by status (list)").option("--limit <n>", "max rows (list)", "100").option("-j, --json", "JSON output").action((action, id, opts) => {
@@ -2591,7 +2730,7 @@ program.command("nodes").description("List or show a run's node executions").arg
     if (action === "show") {
       if (!node)
         throw new Error("nodes show requires a run id and a node id");
-      const row = store.listRunNodes(run).find((n) => n.nodeId === node);
+      const row = store.getLatestRunNode(run, node);
       if (!row)
         throw new Error(`run ${run} has no node ${node}`);
       console.log(JSON.stringify(row, null, 2));
@@ -2689,17 +2828,17 @@ program.command("machines").description("List observed machines or report this m
       }
       case "status": {
         const replay = wal.replay();
-        const pidFile = join4(config.dataDir, "daemon.pid");
-        const pid = existsSync2(pidFile) ? readFileSync2(pidFile, "utf8").trim() : null;
+        const pidFile = join5(config.dataDir, "daemon.pid");
+        const pid = existsSync3(pidFile) ? readFileSync3(pidFile, "utf8").trim() : null;
         const running = pid !== null && processAlive(Number(pid));
         const report = {
           hostname: hostname(),
           pid: process.pid,
           dataDir: config.dataDir,
           layout: {
-            workflows: existsSync2(join4(config.dataDir, "workflows")),
-            sessions: existsSync2(join4(config.dataDir, SESSIONS_DIR_NAME)),
-            db: existsSync2(join4(config.dataDir, "workflows.db"))
+            workflows: existsSync3(join5(config.dataDir, "workflows")),
+            sessions: existsSync3(join5(config.dataDir, SESSIONS_DIR_NAME)),
+            db: existsSync3(join5(config.dataDir, "workflows.db"))
           },
           store: {
             tables: store.listTables(),
@@ -2763,8 +2902,8 @@ program.command("lanes").description("List the four lane adapters (wired vs not-
 });
 program.command("daemon").description("Run or inspect the daemon").argument("<action>", "start | status | stop").option("--once", "run a single reap cycle and exit (start)").option("--interval-ms <n>", "reap interval (start)", "5000").option("--cycles <n>", "bound on consecutive cycles (start; default infinite until SIGINT)", "0").option("-j, --json", "JSON output").action(async (action, opts) => {
   const config = resolveWorkflowsConfig();
-  const pidFile = join4(config.dataDir, "daemon.pid");
-  const statusFile = join4(config.dataDir, "daemon.status.json");
+  const pidFile = join5(config.dataDir, "daemon.pid");
+  const statusFile = join5(config.dataDir, "daemon.status.json");
   switch (action) {
     case "start": {
       const { store, wal } = openLocal();
@@ -2812,30 +2951,30 @@ program.command("daemon").description("Run or inspect the daemon").argument("<ac
       }
     }
     case "status": {
-      if (!existsSync2(statusFile)) {
+      if (!existsSync3(statusFile)) {
         if (opts.json) {
-          console.log(JSON.stringify({ running: false, lastReap: null }));
+          console.log(JSON.stringify({ statusVersion: 1, running: false, pid: null, lastReap: null, cumulative: emptyReapReport() }));
         } else {
           console.log("daemon not running (no status record)");
         }
         return;
       }
-      const lastReap = JSON.parse(readFileSync2(statusFile, "utf8"));
-      const pid = existsSync2(pidFile) ? readFileSync2(pidFile, "utf8").trim() : null;
+      const envelope = readReport(statusFile);
+      const pid = existsSync3(pidFile) ? readFileSync3(pidFile, "utf8").trim() : null;
       const running = pid !== null && processAlive(Number(pid));
       if (opts.json) {
-        console.log(JSON.stringify({ running, pid, lastReap }, null, 2));
+        console.log(JSON.stringify({ statusVersion: 1, running, pid, lastReap: envelope.latestCycle, cumulative: envelope.cumulative }, null, 2));
       } else {
-        console.log(`daemon ${running ? `running (pid ${pid})` : "not running"} \u2014 last reap: ${JSON.stringify(lastReap)}`);
+        console.log(`daemon ${running ? `running (pid ${pid})` : "not running"} \u2014 latest reap: ${JSON.stringify(envelope.latestCycle)} cumulative: ${JSON.stringify(envelope.cumulative)}`);
       }
       return;
     }
     case "stop": {
-      if (!existsSync2(pidFile)) {
+      if (!existsSync3(pidFile)) {
         console.error("no daemon pid file \u2014 nothing to stop");
         process.exit(1);
       }
-      const pid = Number(readFileSync2(pidFile, "utf8").trim());
+      const pid = Number(readFileSync3(pidFile, "utf8").trim());
       try {
         process.kill(pid, "SIGTERM");
       } catch {
@@ -2857,9 +2996,60 @@ function processAlive(pid) {
     return false;
   }
 }
+var REAP_REPORT_KEYS = ["expired", "interrupted", "requeued", "failed", "dispatched", "advanced", "completed"];
+function emptyReapReport() {
+  return { expired: 0, interrupted: 0, requeued: 0, failed: 0, dispatched: 0, advanced: 0, completed: 0 };
+}
+function normalizeReapReport(value) {
+  const source = value !== null && typeof value === "object" ? value : {};
+  const report = emptyReapReport();
+  for (const key of REAP_REPORT_KEYS) {
+    const count = source[key];
+    report[key] = typeof count === "number" && Number.isFinite(count) ? count : 0;
+  }
+  return report;
+}
+function addReapReports(left, right) {
+  const total = emptyReapReport();
+  for (const key of REAP_REPORT_KEYS)
+    total[key] = left[key] + right[key];
+  return total;
+}
 function writeReport(statusFile, report) {
-  mkdirSync3(join4(statusFile, ".."), { recursive: true });
-  writeFileSync2(statusFile, JSON.stringify({ ...report, at: new Date().toISOString() }), "utf8");
+  mkdirSync3(join5(statusFile, ".."), { recursive: true });
+  let previous = emptyReapReport();
+  if (existsSync3(statusFile)) {
+    previous = readReport(statusFile).cumulative;
+  }
+  const tempFile = `${statusFile}.tmp-${process.pid}`;
+  const envelope = {
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    latestCycle: report,
+    cumulative: addReapReports(previous, report)
+  };
+  try {
+    writeFileSync2(tempFile, JSON.stringify(envelope), "utf8");
+    renameSync2(tempFile, statusFile);
+  } finally {
+    rmSync(tempFile, { force: true });
+  }
+}
+function readReport(statusFile) {
+  const parsed = JSON.parse(readFileSync3(statusFile, "utf8"));
+  if (parsed !== null && typeof parsed === "object") {
+    const record = parsed;
+    if (record.version === 1 && record.latestCycle !== undefined && record.cumulative !== undefined) {
+      return {
+        version: 1,
+        updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : new Date().toISOString(),
+        latestCycle: normalizeReapReport(record.latestCycle),
+        cumulative: normalizeReapReport(record.cumulative)
+      };
+    }
+  }
+  const legacy = normalizeReapReport(parsed);
+  return { version: 1, updatedAt: new Date().toISOString(), latestCycle: legacy, cumulative: legacy };
 }
 program.command("memos").description("Inspect or clear the memoization cache").argument("<action>", "list | clear").option("--yes", "confirm clear").option("-j, --json", "JSON output").action((action, opts) => {
   const { store } = openLocal();