@hasna/workflows 0.2.1 → 0.2.2

package/README.md

@@ -141,6 +141,31 @@ Use durable storage for the data directory and one deployed executor; ephemeral
 container storage is unsuitable. Model lanes require the selected harness's
 native subscription on the executor. They do not inherit paid model API keys.
 
+Set `HASNA_WORKFLOWS_ENABLED_LANES` to a comma-separated subset of
+`claude,codex,cursor,grok` to restrict model execution. An explicitly empty value
+permits command steps only; leaving the variable unset preserves all four lanes.
+Lane inspection reports disabled lanes as `wired: false` with a configuration
+reason. Trigger rejects a graph containing a disabled prompt lane before any
+step runs, and resume leaves such a stored run unchanged. Existing run history
+and event reads remain available. This admission setting does not grant model
+authentication or authorize API billing.
+
+For a deployment with a restored data directory, set
+`HASNA_WORKFLOWS_DATA_IDENTITY` to its non-secret storage identity. After verifying
+the restore, the operator provisions `.workflows-data-identity` containing that
+identity followed by a newline. The directory must already contain readable and
+writable `workflows.db` and `sessions/session.wal`. The server refuses missing,
+mismatched or inaccessible state without creating a replacement. Readiness and
+storage operations repeat the check. The server also holds a process-lifetime
+SQLite mutex in `.server-lease.sqlite`, containing no tables, so an overlapping
+replacement cannot open a second server over the same local journal. Keep this
+file in place; never delete it to take a live process's lease. This mode requires
+a local filesystem with reliable SQLite locking, not a network filesystem.
+
+Journal append acknowledgements follow file and parent-directory flushes. The
+journal and PostgreSQL are separate stores, not one atomic transaction; capture
+and restore them together while execution is quiescent.
+
 When the server sits behind an authenticated gateway, set
 `HASNA_WORKFLOWS_ORIGIN_AUTH` to the gateway's scoped origin identity. It must be
 32 to 256 ASCII letters, digits, underscores or hyphens. All API routes, including

package/dist/agent-tools.js

@@ -599,513 +599,8 @@ var init_graph = __esm(() => {
   NODE_ID_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
 });
 
-// src/lanes/types.ts
-import { statSync } from "fs";
-function binaryOnPath(binary) {
-  const pathEntries = (process.env.PATH ?? "").split(":").filter(Boolean);
-  for (const entry of pathEntries) {
-    try {
-      const stat = statSync(`${entry}/${binary}`);
-      if (stat.isFile())
-        return true;
-    } catch {}
-  }
-  return false;
-}
-function subscriptionEnvironment(overrides = {}) {
-  const paid = /^(OPENAI_API_KEY|ANTHROPIC_API_KEY|ANTHROPIC_AUTH_TOKEN|CODEX_API_KEY|CURSOR_API_KEY)$/;
-  const sensitive = /(?:API[_-]?KEY|SECRET|PASSWORD|TOKEN|DATABASE_URL|CREDENTIAL)/i;
-  const env = {};
-  for (const [name, value] of Object.entries(process.env)) {
-    if (value !== undefined && !paid.test(name) && (!sensitive.test(name) || name === "CLAUDE_CODE_OAUTH_TOKEN"))
-      env[name] = value;
-  }
-  for (const [name, value] of Object.entries(overrides)) {
-    if (paid.test(name) || sensitive.test(name))
-      throw new Error(`lane environment field ${name} requires a supported scoped credential consumer`);
-    env[name] = value;
-  }
-  return env;
-}
-function subscriptionSdkEnvironment(overrides = {}) {
-  const safe = subscriptionEnvironment(overrides);
-  return { ...Object.fromEntries(Object.keys(process.env).map((name) => [name, undefined])), ...safe };
-}
-function withTimeout(promise, timeoutMs, what, cancel) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      cancel?.();
-      reject(new LaneTimeoutError(what, timeoutMs));
-    }, timeoutMs);
-    promise.then((value) => {
-      clearTimeout(timer);
-      resolve(value);
-    }, (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-  });
-}
-async function spawnCli(cmd, opts) {
-  const started = Date.now();
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_LANE_TIMEOUT_MS;
-  let proc;
-  try {
-    proc = Bun.spawn({
-      cmd,
-      cwd: opts.cwd,
-      env: subscriptionEnvironment(opts.env),
-      stdin: "ignore",
-      stdout: "pipe",
-      stderr: "pipe",
-      timeout: timeoutMs
-    });
-  } catch (err) {
-    const message = String(err instanceof Error ? err.message : err);
-    if (message.includes("ENOENT") || /not found/i.test(message)) {
-      throw new LaneDependencyMissingError(`lane binary ${JSON.stringify(opts.binaryName)} not found on PATH; install it or provide ${opts.packageHint}`);
-    }
-    return { ok: false, exitCode: 1, output: "", durationMs: Date.now() - started, error: message };
-  }
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited
-  ]);
-  const output = opts.stdoutOnly ? stdout.trim() : stderr ? `${stdout}
-${stderr}`.trim() : stdout.trim();
-  return {
-    ok: exitCode === 0,
-    exitCode,
-    output,
-    durationMs: Date.now() - started,
-    ...opts.stdoutOnly && exitCode !== 0 && stderr.trim() ? { error: stderr.trim() } : {}
-  };
-}
-var LANE_KINDS2, LaneDependencyMissingError, LaneAdapterShapeError, DEFAULT_LANE_TIMEOUT_MS = 120000, LaneTimeoutError;
-var init_types = __esm(() => {
-  LANE_KINDS2 = ["claude", "codex", "cursor", "grok"];
-  LaneDependencyMissingError = class LaneDependencyMissingError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "LaneDependencyMissingError";
-    }
-  };
-  LaneAdapterShapeError = class LaneAdapterShapeError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "LaneAdapterShapeError";
-    }
-  };
-  LaneTimeoutError = class LaneTimeoutError extends Error {
-    constructor(what, timeoutMs) {
-      super(`${what} exceeded the ${timeoutMs}ms budget`);
-      this.name = "LaneTimeoutError";
-    }
-  };
-});
-
-// src/lanes/claude.ts
-function createClaudeAdapter(deps = {}) {
-  return {
-    kind: "claude",
-    async probe() {
-      const loader = deps.sdkLoader ?? (async () => await import("@anthropic-ai/claude-agent-sdk"));
-      try {
-        await loader();
-        return { kind: "claude", sdk: "@anthropic-ai/claude-agent-sdk", wired: true, via: "sdk" };
-      } catch {
-        if (binaryOnPath(deps.cliPath ?? "claude")) {
-          return { kind: "claude", sdk: "@anthropic-ai/claude-agent-sdk", wired: true, via: "cli" };
-        }
-        return {
-          kind: "claude",
-          sdk: "@anthropic-ai/claude-agent-sdk",
-          wired: false,
-          reason: "neither @anthropic-ai/claude-agent-sdk nor the claude CLI is available on this machine"
-        };
-      }
-    },
-    async run(job) {
-      if (!job.prompt) {
-        return { ok: false, exitCode: 2, output: "", durationMs: 0, error: "claude lane requires a prompt" };
-      }
-      const started = Date.now();
-      const timeoutMs = job.timeoutMs ?? DEFAULT_LANE_TIMEOUT_MS;
-      const loader = deps.sdkLoader ?? (async () => await import("@anthropic-ai/claude-agent-sdk"));
-      let sdk;
-      try {
-        sdk = await loader();
-      } catch (err) {
-        return runClaudeCli(job, deps.cliPath ?? "claude", started, timeoutMs);
-      }
-      const query = sdk.query;
-      if (typeof query !== "function") {
-        throw new LaneAdapterShapeError("@anthropic-ai/claude-agent-sdk exports no query() function");
-      }
-      const prompt = job.prompt;
-      const abortController = new AbortController;
-      try {
-        const { output, isError } = await withTimeout((async () => {
-          const generator = await query({
-            prompt,
-            options: { model: job.model, cwd: job.cwd, maxTurns: 32, abortController, env: subscriptionSdkEnvironment(job.env) }
-          });
-          let output2 = "";
-          let isError2 = false;
-          for await (const message of generator) {
-            if (message.type === "assistant") {
-              const content = message.message?.content;
-              if (Array.isArray(content)) {
-                for (const block of content) {
-                  if (block && typeof block === "object" && "text" in block && typeof block.text === "string") {
-                    output2 += block.text;
-                  }
-                }
-              }
-            }
-            if (message.type === "error")
-              isError2 = true;
-          }
-          return { output: output2, isError: isError2 };
-        })(), timeoutMs, "claude lane", () => abortController.abort());
-        const durationMs = Date.now() - started;
-        return { ok: !isError, exitCode: isError ? 1 : 0, output: output.trim(), durationMs };
-      } catch (err) {
-        const durationMs = Date.now() - started;
-        return { ok: false, exitCode: 1, output: "", durationMs, error: String(err instanceof Error ? err.message : err), retryable: !(err instanceof LaneTimeoutError) };
-      }
-    }
-  };
-}
-async function runClaudeCli(job, cliPath, started, timeoutMs) {
-  try {
-    const result = await spawnCli([cliPath, "-p", job.prompt], {
-      binaryName: cliPath,
-      packageHint: "@anthropic-ai/claude-agent-sdk or the claude CLI",
-      timeoutMs,
-      env: job.env,
-      cwd: job.cwd
-    });
-    return { ...result, durationMs: Date.now() - started };
-  } catch (err) {
-    if (err instanceof LaneDependencyMissingError) {
-      return { ok: false, exitCode: 127, output: "", durationMs: Date.now() - started, error: err.message };
-    }
-    throw err;
-  }
-}
-var init_claude = __esm(() => {
-  init_types();
-});
-
-// src/lanes/codex.ts
-function createCodexAdapter(deps = {}) {
-  return {
-    kind: "codex",
-    async probe() {
-      const loader = deps.sdkLoader ?? (async () => await import("@openai/codex-sdk"));
-      try {
-        await loader();
-        return { kind: "codex", sdk: "@openai/codex-sdk", wired: true, via: "sdk" };
-      } catch {
-        if (binaryOnPath(deps.cliPath ?? "codex")) {
-          return { kind: "codex", sdk: "@openai/codex-sdk", wired: true, via: "cli" };
-        }
-        return {
-          kind: "codex",
-          sdk: "@openai/codex-sdk",
-          wired: false,
-          reason: "neither @openai/codex-sdk nor the codex CLI is available on this machine"
-        };
-      }
-    },
-    async run(job) {
-      if (!job.prompt) {
-        return { ok: false, exitCode: 2, output: "", durationMs: 0, error: "codex lane requires a prompt" };
-      }
-      if (job.codexMode !== undefined && (!CODEX_EXECUTION_MODES.includes(job.codexMode) || job.lane !== "codex" || job.command !== undefined)) {
-        return { ok: false, exitCode: 2, output: "", durationMs: 0, error: "codexMode must be repository or read-only on a codex prompt without command", retryable: false };
-      }
-      const started = Date.now();
-      const timeoutMs = job.timeoutMs ?? DEFAULT_LANE_TIMEOUT_MS;
-      const loader = deps.sdkLoader ?? (async () => await import("@openai/codex-sdk"));
-      let sdk;
-      try {
-        sdk = await loader();
-      } catch {
-        return runCodexCli(job, deps.cliPath ?? "codex", started, timeoutMs);
-      }
-      const CodexClass = sdk.Codex;
-      if (typeof CodexClass !== "function") {
-        throw new LaneAdapterShapeError("@openai/codex-sdk exports no Codex class");
-      }
-      const abortController = new AbortController;
-      try {
-        const client = await withTimeout(Promise.resolve(new CodexClass({
-          config: { model: job.model },
-          env: subscriptionEnvironment(job.env)
-        })), timeoutMs, "codex lane");
-        const thread = client.startThread?.({
-          model: job.model,
-          workingDirectory: job.cwd,
-          ...job.codexMode === "read-only" ? { sandboxMode: "read-only", skipGitRepoCheck: true, approvalPolicy: "never" } : {}
-        });
-        if (!thread || typeof thread.run !== "function") {
-          throw new LaneAdapterShapeError("@openai/codex-sdk Codex.startThread() returned no run()");
-        }
-        const turn = await withTimeout(thread.run(job.prompt, { signal: abortController.signal }), timeoutMs, "codex lane", () => abortController.abort());
-        const durationMs = Date.now() - started;
-        const output = turn?.finalResponse;
-        if (typeof output !== "string" || !output.trim()) {
-          return missingResponse(durationMs);
-        }
-        return { ok: true, exitCode: 0, output, durationMs };
-      } catch (err) {
-        const durationMs = Date.now() - started;
-        return { ok: false, exitCode: 1, output: "", durationMs, error: String(err instanceof Error ? err.message : err), retryable: !(err instanceof LaneTimeoutError) };
-      }
-    }
-  };
-}
-async function runCodexCli(job, cliPath, started, timeoutMs) {
-  try {
-    const controls = job.codexMode === "read-only" ? ["--sandbox", "read-only", "--skip-git-repo-check", "--config", 'approval_policy="never"'] : [];
-    const result = await spawnCli([cliPath, "exec", ...controls, "--", job.prompt], {
-      binaryName: cliPath,
-      packageHint: "@openai/codex-sdk or the codex CLI",
-      timeoutMs,
-      env: job.env,
-      cwd: job.cwd,
-      stdoutOnly: true
-    });
-    const durationMs = Date.now() - started;
-    return result.ok && !result.output.trim() ? missingResponse(durationMs) : { ...result, durationMs };
-  } catch (err) {
-    if (err instanceof LaneDependencyMissingError) {
-      return { ok: false, exitCode: 127, output: "", durationMs: Date.now() - started, error: err.message };
-    }
-    throw err;
-  }
-}
-function missingResponse(durationMs) {
-  return { ok: false, exitCode: 1, output: "", durationMs, error: "Codex completed without an agent response; verify the native subscription and model route", retryable: false };
-}
-var init_codex = __esm(() => {
-  init_graph();
-  init_types();
-});
-
-// src/lanes/cursor.ts
-function createCursorAdapter(deps = {}) {
-  return {
-    kind: "cursor",
-    async probe() {
-      const loader = deps.sdkLoader ?? (async () => await import("@cursor/sdk"));
-      try {
-        await loader();
-        return { kind: "cursor", sdk: "@cursor/sdk", wired: true, via: "sdk (local mode)" };
-      } catch {
-        if (binaryOnPath(deps.cliPath ?? "cursor-agent")) {
-          return { kind: "cursor", sdk: "@cursor/sdk", wired: true, via: "cli" };
-        }
-        return {
-          kind: "cursor",
-          sdk: "@cursor/sdk",
-          wired: false,
-          reason: "neither @cursor/sdk nor the cursor-agent CLI is available on this machine"
-        };
-      }
-    },
-    async run(job) {
-      if (!job.prompt) {
-        return { ok: false, exitCode: 2, output: "", durationMs: 0, error: "cursor lane requires a prompt" };
-      }
-      if (!deps.sdkLoader && binaryOnPath(deps.cliPath ?? "cursor-agent"))
-        return runCursorCli(job, deps.cliPath ?? "cursor-agent", Date.now(), job.timeoutMs ?? DEFAULT_LANE_TIMEOUT_MS);
-      const started = Date.now();
-      const timeoutMs = job.timeoutMs ?? DEFAULT_LANE_TIMEOUT_MS;
-      const loader = deps.sdkLoader ?? (async () => await import("@cursor/sdk"));
-      let sdk;
-      try {
-        sdk = await loader();
-      } catch {
-        return runCursorCli(job, deps.cliPath ?? "cursor-agent", started, timeoutMs);
-      }
-      let cancel;
-      try {
-        subscriptionEnvironment(job.env);
-        if (!deps.sdkLoader && process.env.CURSOR_API_KEY)
-          throw new Error("cursor lane refuses ambient API billing; use the native subscription CLI");
-        const run = await withTimeout(runLocalAgent(sdk, job, (callback) => {
-          cancel = callback;
-        }), timeoutMs, "cursor lane", () => cancel?.());
-        const durationMs = Date.now() - started;
-        const status = run.status;
-        const ok = status === "finished";
-        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), retryable: !(err instanceof LaneTimeoutError) };
-      }
-    }
-  };
-}
-async function runLocalAgent(sdk, job, onCancel) {
-  const AgentClass = sdk.Agent;
-  const CursorClass = sdk.Cursor;
-  if (typeof AgentClass !== "function" && typeof CursorClass !== "function") {
-    throw new LaneAdapterShapeError("@cursor/sdk exports no Agent/Cursor class");
-  }
-  const create = AgentClass.create;
-  const agent = typeof create === "function" ? await create.call(AgentClass, { local: { cwd: job.cwd, enableAgentRetries: false } }) : typeof AgentClass === "function" ? new AgentClass : undefined;
-  if (!agent || typeof agent.send !== "function") {
-    throw new LaneAdapterShapeError("@cursor/sdk Agent has no send()");
-  }
-  let run = await agent.send(job.prompt, { model: job.model });
-  if (run && typeof run === "object") {
-    const handle = run;
-    if (typeof handle.cancel === "function")
-      onCancel(() => {
-        handle.cancel().catch(() => {});
-      });
-    if (typeof handle.wait === "function")
-      run = await handle.wait();
-  }
-  if (!run || typeof run !== "object") {
-    throw new LaneAdapterShapeError("@cursor/sdk Agent.send() returned no 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 };
-}
-async function runCursorCli(job, cliPath, started, timeoutMs) {
-  try {
-    const result = await spawnCli([cliPath, "--print", job.prompt, ...job.model ? ["--model", job.model] : []], {
-      binaryName: cliPath,
-      packageHint: "@cursor/sdk (local mode) or the cursor-agent CLI",
-      timeoutMs,
-      env: job.env,
-      cwd: job.cwd
-    });
-    return { ...result, durationMs: Date.now() - started };
-  } catch (err) {
-    if (err instanceof LaneDependencyMissingError) {
-      return { ok: false, exitCode: 127, output: "", durationMs: Date.now() - started, error: err.message };
-    }
-    throw err;
-  }
-}
-var init_cursor = __esm(() => {
-  init_types();
-});
-
-// src/lanes/grok.ts
-function createGrokAdapter(deps = {}) {
-  return {
-    kind: "grok",
-    async probe() {
-      const cliPath = deps.cliPath ?? "grok";
-      if (binaryOnPath(cliPath)) {
-        return { kind: "grok", sdk: "no npm SDK (measured 2026-08-25)", wired: true, via: "cli" };
-      }
-      return {
-        kind: "grok",
-        sdk: "no npm SDK (measured 2026-08-25)",
-        wired: false,
-        reason: `no xAI Grok SDK exists on npm (measured 2026-08-25) and the grok CLI is not on PATH`
-      };
-    },
-    async run(job) {
-      if (!job.prompt) {
-        return { ok: false, exitCode: 2, output: "", durationMs: 0, error: "grok lane requires a prompt" };
-      }
-      const started = Date.now();
-      const timeoutMs = job.timeoutMs ?? DEFAULT_LANE_TIMEOUT_MS;
-      const cliPath = deps.cliPath ?? "grok";
-      try {
-        const result = await spawnCli([cliPath, job.prompt], {
-          binaryName: cliPath,
-          packageHint: "the grok CLI (no xAI Grok SDK exists on npm \u2014 measured 2026-08-25)",
-          timeoutMs,
-          env: job.env,
-          cwd: job.cwd
-        });
-        return { ...result, durationMs: Date.now() - started };
-      } catch (err) {
-        if (err instanceof LaneDependencyMissingError) {
-          return { ok: false, exitCode: 127, output: "", durationMs: Date.now() - started, error: err.message };
-        }
-        throw err;
-      }
-    }
-  };
-}
-var init_grok = __esm(() => {
-  init_types();
-});
-
-// src/lanes/index.ts
-var exports_lanes = {};
-__export(exports_lanes, {
-  runLaneJob: () => runLaneJob,
-  resolveLane: () => resolveLane,
-  probeLane: () => probeLane,
-  laneInventory: () => laneInventory,
-  createGrokAdapter: () => createGrokAdapter,
-  createCursorAdapter: () => createCursorAdapter,
-  createCodexAdapter: () => createCodexAdapter,
-  createClaudeAdapter: () => createClaudeAdapter,
-  binaryOnPath: () => binaryOnPath,
-  LaneDependencyMissingError: () => LaneDependencyMissingError,
-  LaneAdapterShapeError: () => LaneAdapterShapeError,
-  LANE_KINDS: () => LANE_KINDS2
-});
-function resolveLane(kind) {
-  const adapter = adapters.get(kind);
-  if (!adapter)
-    throw new Error(`unknown lane ${kind} (expected one of ${LANE_KINDS2.join(", ")})`);
-  return adapter;
-}
-async function runLaneJob(job) {
-  return resolveLane(job.lane).run(job);
-}
-async function probeLane(kind) {
-  return resolveLane(kind).probe();
-}
-async function laneInventory() {
-  return Promise.all(LANE_KINDS2.map((kind) => probeLane(kind)));
-}
-var adapters;
-var init_lanes = __esm(() => {
-  init_claude();
-  init_codex();
-  init_cursor();
-  init_grok();
-  init_types();
-  init_types();
-  init_claude();
-  init_codex();
-  init_cursor();
-  init_grok();
-  adapters = new Map([
-    ["claude", createClaudeAdapter()],
-    ["codex", createCodexAdapter()],
-    ["cursor", createCursorAdapter()],
-    ["grok", createGrokAdapter()]
-  ]);
-});
-
 // src/agent-tools.ts
 init_graph();
-init_lanes();
 
 // src/tool-definitions.ts
 function textResult(payload) {
@@ -1199,7 +694,7 @@ async function callWorkflowTool(service, name, args) {
         limit: typeof args.limit === "number" ? args.limit : 100
       }));
     case "workflows_lanes_list":
-      return textResult(await laneInventory());
+      return textResult(await service.laneInventory());
     default:
       throw new Error("Unknown workflows tool");
   }

package/dist/cli/index.js

@@ -33,7 +33,7 @@ var __toESM = (mod, isNodeMode, target) => {
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = import.meta.require;
 
-// ../../../../workflows-codex-execution-repair-1/dependency-update-1/standalone/workflows/node_modules/commander/lib/error.js
+// ../../app-test-sandbox-1/source/node_modules/commander/lib/error.js
 var require_error = __commonJS((exports) => {
   class CommanderError extends Error {
     constructor(exitCode, code, message) {
@@ -57,7 +57,7 @@ var require_error = __commonJS((exports) => {
   exports.InvalidArgumentError = InvalidArgumentError;
 });
 
-// ../../../../workflows-codex-execution-repair-1/dependency-update-1/standalone/workflows/node_modules/commander/lib/argument.js
+// ../../app-test-sandbox-1/source/node_modules/commander/lib/argument.js
 var require_argument = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -136,7 +136,7 @@ var require_argument = __commonJS((exports) => {
   exports.humanReadableArgName = humanReadableArgName;
 });
 
-// ../../../../workflows-codex-execution-repair-1/dependency-update-1/standalone/workflows/node_modules/commander/lib/help.js
+// ../../app-test-sandbox-1/source/node_modules/commander/lib/help.js
 var require_help = __commonJS((exports) => {
   var { humanReadableArgName } = require_argument();
 
@@ -486,7 +486,7 @@ ${itemIndentStr}`);
   exports.stripColor = stripColor;
 });
 
-// ../../../../workflows-codex-execution-repair-1/dependency-update-1/standalone/workflows/node_modules/commander/lib/option.js
+// ../../app-test-sandbox-1/source/node_modules/commander/lib/option.js
 var require_option = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -664,7 +664,7 @@ var require_option = __commonJS((exports) => {
   exports.DualOptions = DualOptions;
 });
 
-// ../../../../workflows-codex-execution-repair-1/dependency-update-1/standalone/workflows/node_modules/commander/lib/suggestSimilar.js
+// ../../app-test-sandbox-1/source/node_modules/commander/lib/suggestSimilar.js
 var require_suggestSimilar = __commonJS((exports) => {
   var maxDistance = 3;
   function editDistance(a, b) {
@@ -737,7 +737,7 @@ var require_suggestSimilar = __commonJS((exports) => {
   exports.suggestSimilar = suggestSimilar;
 });
 
-// ../../../../workflows-codex-execution-repair-1/dependency-update-1/standalone/workflows/node_modules/commander/lib/command.js
+// ../../app-test-sandbox-1/source/node_modules/commander/lib/command.js
 var require_command = __commonJS((exports) => {
   var EventEmitter = __require("events").EventEmitter;
   var childProcess = __require("child_process");
@@ -2047,7 +2047,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   exports.useColor = useColor;
 });
 
-// ../../../../workflows-codex-execution-repair-1/dependency-update-1/standalone/workflows/node_modules/commander/index.js
+// ../../app-test-sandbox-1/source/node_modules/commander/index.js
 var require_commander = __commonJS((exports) => {
   var { Argument } = require_argument();
   var { Command } = require_command();
@@ -2067,7 +2067,7 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
-// ../../../../workflows-codex-execution-repair-1/dependency-update-1/standalone/workflows/node_modules/commander/esm.mjs
+// ../../app-test-sandbox-1/source/node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
   program,
@@ -2086,7 +2086,7 @@ var {
 // src/cli/index.ts
 import { readFileSync as readFileSync5, readSync, writeFileSync as writeFileSync2 } from "fs";
 
-// ../../../../workflows-codex-execution-repair-1/dependency-update-1/standalone/workflows/node_modules/@hasna/contracts/dist/client/transport.js
+// ../../app-test-sandbox-1/source/node_modules/@hasna/contracts/dist/client/transport.js
 import { isIP } from "net";
 import { spawnSync } from "child_process";
 import { closeSync as closeSync2, fstatSync as fstatSync2, openSync as openSync2, readFileSync as readFileSync2 } from "fs";
@@ -3575,7 +3575,7 @@ function workflowAgent(env = process.env, explicit) {
 // package.json
 var package_default = {
   name: "@hasna/workflows",
-  version: "0.2.1",
+  version: "0.2.2",
   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",
@@ -3651,7 +3651,7 @@ var package_default = {
   dependencies: {
     "@anthropic-ai/claude-agent-sdk": "0.3.234",
     "@cursor/sdk": "^1.0.28",
-    "@hasna/contracts": "1.3.3",
+    "@hasna/contracts": "1.3.5",
     "@openai/codex-sdk": "0.160.0",
     commander: "^13.1.0",
     pg: "^8.16.3"