@repogo/plugins 0.1.35 → 0.1.38

package/dist/testing.js

@@ -1,13 +1,19 @@
 // @bun
 import {
   MethodError,
-  toCallError
-} from "./index-83w1fk10.js";
+  attemptScope,
+  callFiles,
+  exports_src,
+  parseDuration,
+  toCallError,
+  workflowContext,
+  workflowScope
+} from "./index.js";
 
 // src/testing.ts
-import { mkdir as mkdir4, mkdtemp, rm as rm3 } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join4 } from "path";
+import { mkdir as mkdir6, mkdtemp as mkdtemp2, rm as rm5 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join8 } from "path";
 
 // src/logs.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -87,7 +93,7 @@ function carryable(value) {
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 import { mkdir as mkdir3, readdir as readdir3 } from "fs/promises";
 import { join as join3 } from "path";
-import { z as z2 } from "zod";
+import { z as z5 } from "zod";
 
 // src/buckets.ts
 import { watch } from "fs";
@@ -141,6 +147,9 @@ async function tracked(readOnly, announce, work) {
       access.done.value = true;
   }
 }
+function isolated(work) {
+  return current.run({ reads: new Set, writes: new Set, readOnly: true, done: { value: false }, announce: () => {} }, work);
+}
 function recordRead(tag) {
   current.getStore()?.reads.add(tag);
 }
@@ -501,6 +510,93 @@ function checkName(name) {
   }
 }
 
+// src/cache.ts
+var maxBytes = 1e6;
+var keepMs = 30 * 86400000;
+
+class AnswerCache {
+  database;
+  namespace;
+  announce;
+  inflight = new Map;
+  constructor(database, namespace, announce) {
+    this.database = database;
+    this.namespace = namespace;
+    this.announce = announce;
+  }
+  async setup() {
+    await this.database.sql.unsafe(`create table if not exists cached_answers (
+        key text primary key,
+        value text not null,
+        checked_at integer not null
+      )`);
+  }
+  async read(key, options, fetch) {
+    const tag = `${this.namespace}.cached.${Bun.hash(key).toString(36)}`;
+    recordRead(tag);
+    const [row] = await this.database.sql.unsafe(`select value, checked_at from cached_answers where key = $1`, [key]);
+    if (!row)
+      return this.refresh(key, tag, options, fetch);
+    if (Date.now() - row.checked_at >= options.fresh) {
+      this.refresh(key, tag, options, fetch).catch((error) => record("error", [error]));
+    }
+    return JSON.parse(row.value);
+  }
+  async idle() {
+    while (this.inflight.size)
+      await Promise.allSettled([...this.inflight.values()]);
+  }
+  refresh(key, tag, options, fetch) {
+    const running = this.inflight.get(key);
+    if (running)
+      return running;
+    const started = Date.now();
+    const work = isolated(async () => withTimeout(Promise.resolve(fetch()), options.timeout)).then(async (value) => {
+      await this.save(key, tag, value ?? null, started);
+      return value ?? null;
+    }, async (error) => {
+      await this.database.transaction(() => this.database.sql.unsafe(`update cached_answers set checked_at = $1 where key = $2`, [Date.now(), key]));
+      throw error;
+    }).finally(() => this.inflight.delete(key));
+    this.inflight.set(key, work);
+    return work;
+  }
+  async save(key, tag, value, started) {
+    const text = JSON.stringify(value);
+    if (text.length > maxBytes)
+      return;
+    const changed = await this.database.transaction(async () => {
+      const [before] = await this.database.sql.unsafe(`select value, checked_at from cached_answers where key = $1`, [key]);
+      if (before && before.checked_at > started)
+        return false;
+      const now = Date.now();
+      await this.database.sql.unsafe(`insert into cached_answers (key, value, checked_at) values ($1, $2, $3)
+         on conflict (key) do update set value = excluded.value, checked_at = excluded.checked_at`, [key, text, now]);
+      await this.database.sql.unsafe(`delete from cached_answers where checked_at < $1`, [now - keepMs]);
+      return before?.value !== text;
+    });
+    if (changed)
+      this.announce([tag]);
+  }
+}
+function cacheKey(method, root, input) {
+  return JSON.stringify([method, root, sorted(input)]);
+}
+function sorted(value) {
+  if (Array.isArray(value))
+    return value.map(sorted);
+  if (value === null || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sorted(value[key])]));
+}
+function withTimeout(work, ms) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new MethodError("INTERNAL", `The answer took longer than ${Math.round(ms / 1000)} s.`)), ms);
+  });
+  return Promise.race([work, timeout]).finally(() => clearTimeout(timer));
+}
+
 // src/collections.ts
 class Collection {
   database;
@@ -799,8 +895,8 @@ class Database {
   }
   static async open(path) {
     const sql = new SQL(`sqlite://${path}`);
-    await sql.unsafe("pragma journal_mode = wal");
     await sql.unsafe("pragma busy_timeout = 5000");
+    await sql.unsafe("pragma journal_mode = wal");
     return new Database(sql);
   }
   transaction(work) {
@@ -824,23 +920,6 @@ class Database {
   }
 }
 
-// src/duration.ts
-var unitMs = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
-function parseDuration(duration) {
-  if (typeof duration === "number") {
-    if (!Number.isFinite(duration) || duration <= 0)
-      throw new Error(`a duration is a positive number of ms: ${duration}`);
-    return duration;
-  }
-  const match = /^(\d+(?:\.\d+)?)([smhd])$/.exec(duration);
-  if (!match)
-    throw new Error(`a duration is like "30s", "5m", "1h" or "7d": ${duration}`);
-  const ms = Number(match[1]) * unitMs[match[2]];
-  if (ms <= 0)
-    throw new Error(`a duration is longer than zero: ${duration}`);
-  return ms;
-}
-
 // src/events.ts
 class EventBus {
   listeners = new Map;
@@ -1376,6 +1455,108 @@ function toKey(row) {
   };
 }
 
+// src/workflow/register.ts
+import { z as z4 } from "zod";
+
+// src/workflow/contracts.ts
+import { z as z3 } from "zod";
+import { isAbsolute as isAbsolute2 } from "path";
+
+// src/workflow/policy.ts
+import { z as z2 } from "zod";
+var duration = z2.custom((value) => typeof value === "number" || typeof value === "string");
+var StepOptionsSchema = z2.object({
+  kind: z2.enum(["query", "mutation"]).optional(),
+  attempts: z2.number().optional(),
+  timeout: duration.optional(),
+  backoff: z2.object({ initial: duration.optional(), factor: z2.number().optional(), max: duration.optional() }).strict().optional()
+}).strict();
+var maxDurationMs = 365 * 86400000;
+var DurationMsSchema = z2.number().int().positive().max(maxDurationMs);
+var StepPolicySchema = z2.object({
+  kind: z2.enum(["query", "mutation"]),
+  attempts: z2.number().int().min(1).max(100),
+  timeoutMs: DurationMsSchema,
+  backoff: z2.object({ initialMs: DurationMsSchema, factor: z2.number().min(1).max(1000), maxMs: DurationMsSchema }).strict()
+}).strict().refine((value) => value.kind === "query" || value.attempts === 1, "Only query steps may retry.").refine((value) => value.backoff.initialMs <= value.backoff.maxMs, "Initial backoff must not exceed its maximum.");
+function durationMs(value) {
+  return DurationMsSchema.parse(Math.ceil(parseDuration(value)));
+}
+
+// src/workflow/contracts.ts
+var RunSummarySchema = z3.object({
+  id: z3.string(),
+  workflow: z3.string(),
+  status: z3.enum(["pending", "running", "waiting", "attention", "completed", "failed", "cancelled", "expired", "unknown", "blocked"]),
+  currentStep: z3.string().nullable(),
+  attempt: z3.number().int(),
+  createdAt: z3.string(),
+  updatedAt: z3.string(),
+  nextAttemptAt: z3.string().nullable(),
+  deadlineAt: z3.string().nullable()
+});
+var RunMetadataSchema = z3.object({
+  id: z3.string().uuid(),
+  dir: z3.string().refine(isAbsolute2),
+  root: z3.string().refine(isAbsolute2),
+  namespace: z3.string().regex(/^[a-z0-9][a-z0-9.-]*$/),
+  plugin: z3.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  caller: z3.enum(["card", "agent", "cron", "code", "http"]),
+  workflow: z3.string().regex(/^[a-z][a-zA-Z0-9_-]*$/),
+  input: z3.json(),
+  key: z3.string().nullable(),
+  timeoutMs: DurationMsSchema,
+  maxOfflineMs: DurationMsSchema,
+  retentionMs: DurationMsSchema,
+  createdAt: z3.iso.datetime()
+}).strict();
+var RunLocationSchema = RunMetadataSchema.omit({ input: true, timeoutMs: true, workflow: true, createdAt: true });
+
+// src/workflow/register.ts
+function workflowTag(namespace) {
+  return `${namespace}.workflows`;
+}
+function workflowMethods(plugin, namespace, name, definition, ctx, bridge, directory) {
+  const invoke = (operation, input) => {
+    const dir = directory();
+    if (!bridge || !dir)
+      throw new MethodError("INTERNAL", "Durable workflows run through the plugins service with source files.");
+    return bridge({ operation, dir, plugin, namespace, workflow: name, root: ctx.root, caller: ctx.caller, input, settings: workflowSettings(definition) });
+  };
+  const id = z4.object({ id: z4.string().uuid() }).strict();
+  const spec = (method, kind, input, description, confirm, output) => ({
+    name: `${plugin}.${name}.${method}`,
+    plugin,
+    kind,
+    input,
+    description,
+    confirm,
+    output,
+    run: async (input2, raw) => {
+      if (kind === "query")
+        recordRead(workflowTag(namespace));
+      const request = method === "start" ? { ...input2, input: raw.input } : input2;
+      return invoke(method, request);
+    }
+  });
+  return [
+    spec("list", "query", z4.object({ limit: z4.number().int().min(1).max(100).default(20), status: z4.string().optional(), cursor: z4.string().optional() }).strict(), "List workflow runs", undefined, z4.object({ items: z4.array(RunSummarySchema), cursor: z4.string().nullable() })),
+    spec("get", "query", id, "Get one workflow run"),
+    spec("start", "mutation", z4.object({ input: definition.input, key: z4.string().min(1).max(200).optional() }).strict(), definition.description ?? "Start a durable workflow", definition.confirm, RunSummarySchema),
+    spec("retry", "mutation", id, "Retry a safely failed query step", undefined, RunSummarySchema),
+    spec("restart", "mutation", id, "Start a run that needs attention over from the beginning, on the current code", undefined, RunSummarySchema),
+    spec("cancel", "mutation", id, "Request cancellation of a workflow", undefined, RunSummarySchema),
+    spec("cancelAll", "mutation", z4.object({ status: z4.string().optional() }).strict(), "Cancel every unfinished run, or only those in one status", undefined, z4.object({ cancelled: z4.number().int() }))
+  ];
+}
+function workflowSettings(definition) {
+  return {
+    timeoutMs: durationMs(definition.timeout ?? "30d"),
+    maxOfflineMs: durationMs(definition.maxOffline ?? "14d"),
+    retentionMs: durationMs(definition.retention ?? "30d")
+  };
+}
+
 // src/runtime.ts
 var sampleMs = Number(process.env.REPOGO_PLUGINS_SAMPLE_MS ?? 5000);
 var sampleLimit = 200;
@@ -1390,19 +1571,23 @@ class Runtime {
   dataDir;
   root;
   host;
+  workflows;
   events = new EventBus;
   methods = new Map;
   plugins = new Map;
   crons = [];
+  contexts = new Map;
   databases = new Map;
+  answerCaches = new Map;
   stores = new Map;
   invalidationListeners = new Set;
   noticeListeners = new Set;
   pluginsDir = null;
-  constructor(dataDir, root, host) {
+  constructor(dataDir, root, host, workflows) {
     this.dataDir = dataDir;
     this.root = root;
     this.host = host;
+    this.workflows = workflows;
   }
   callRoot = new AsyncLocalStorage3;
   callSignal = new AsyncLocalStorage3;
@@ -1411,7 +1596,7 @@ class Runtime {
   cronsTag = `crons.${crypto.randomUUID()}`;
   static async open(options) {
     await mkdir3(options.dataDir, { recursive: true });
-    return new Runtime(options.dataDir, options.root ?? process.cwd(), options.host);
+    return new Runtime(options.dataDir, options.root ?? process.cwd(), options.host, options.workflows);
   }
   async loadDir(pluginsDir, only = null) {
     this.pluginsDir = pluginsDir;
@@ -1439,7 +1624,8 @@ class Runtime {
       if (!stores.includes(store))
         throw new Error(`plugin ${name} lists ${store} as private, but keeps no collection, kv, stream or bucket by that name`);
     }
-    const hasData = declared.length > 0 || [plugin.buckets, plugin.kv, plugin.streams].some((stores2) => Object.keys(stores2 ?? {}).length > 0);
+    const hasCache = Object.values(plugin.methods ?? {}).some((method) => method.cache);
+    const hasData = hasCache || Object.keys(plugin.workflows ?? {}).length > 0 || declared.length > 0 || [plugin.buckets, plugin.kv, plugin.streams].some((stores2) => Object.keys(stores2 ?? {}).length > 0);
     const namespace = plugin.namespace ?? "";
     if (hasData && !namespace)
       throw new Error(`plugin ${name} keeps data, so it needs a namespace: "<project>.${name}" for one project's, "${name}" to share it`);
@@ -1489,7 +1675,7 @@ class Runtime {
         return runtime.callRoot.getStore() ?? runtime.root;
       },
       get signal() {
-        return runtime.callSignal.getStore() ?? never;
+        return attemptScope.getStore()?.signal ?? runtime.callSignal.getStore() ?? never;
       },
       collections,
       buckets,
@@ -1498,6 +1684,8 @@ class Runtime {
       call: async (method, input) => (await this.call(method.includes(".") ? method : `${name}.${method}`, input)).result,
       emit: (event, payload) => this.events.emit(`${name}.${event}`, payload),
       host: async (method, params) => {
+        if (workflowScope.getStore())
+          assertWritable("host methods");
         if (!runtime.host)
           throw new MethodError("INTERNAL", "ctx.host runs only under the RepoGo host.");
         return runtime.host(name, method, params ?? {});
@@ -1522,31 +1710,67 @@ class Runtime {
         return this.manifest().plugins;
       },
       notify: (notice) => {
+        assertWritable("notifications");
         const sent = { ...notice, plugin: name, root: runtime.callRoot.getStore() ?? runtime.root };
         for (const listener of runtime.noticeListeners)
           listener(sent);
       },
+      activity: async (activity) => {
+        assertWritable("activities");
+        if (!runtime.host)
+          throw new MethodError("INTERNAL", "ctx.activity runs only under the RepoGo host.");
+        await runtime.host(name, "activities.set", activityParams(activity, ctx.root));
+      },
       agent: (prompt, options2) => this.agent(name, ctx, prompt, options2 ?? {}),
       log: (...args) => console.log(...args)
     };
+    const cache = hasCache ? await this.answerCache(namespace, file) : null;
     for (const [methodName, method] of Object.entries(plugin.methods ?? {})) {
+      const fullName = `${name}.${methodName}`;
+      const options2 = method.cache;
       this.register({
-        name: `${name}.${methodName}`,
+        name: fullName,
         plugin: name,
         kind: method.kind,
         description: method.description,
         confirm: method.confirm,
+        http: method.http,
         input: method.input,
         output: method.output,
-        run: async (input) => method.run(input, ctx)
+        run: options2 && cache ? async (input) => cache.read(cacheKey(fullName, options2.shared ? null : ctx.root, input), options2, () => method.run(input, ctx)) : async (input) => method.run(input, ctx)
       });
     }
+    this.contexts.set(name, ctx);
+    for (const [workflowName, definition] of Object.entries(plugin.workflows ?? {})) {
+      if (!/^[a-z][a-zA-Z0-9_-]*$/.test(workflowName))
+        throw new Error(`Invalid workflow name ${workflowName}.`);
+      workflowSettings(definition);
+      for (const method of workflowMethods(name, namespace, workflowName, definition, ctx, this.workflows, () => this.pluginsDir))
+        this.register(method);
+    }
     for (const [event, handler] of Object.entries(plugin.on ?? {})) {
       this.events.on(`${name}.${event}`, (e) => logContext.run(this.logContextFor(name), () => handler(e.payload, ctx)));
     }
     this.plugins.set(name, plugin);
   }
+  async executeWorkflow(plugin, name, input, context) {
+    const definition = this.plugins.get(plugin)?.workflows?.[name];
+    if (!definition)
+      throw new MethodError("NOT_FOUND", `No workflow ${plugin}.${name}.`);
+    const ctx = this.contexts.get(plugin);
+    return workflowScope.run(true, () => this.callCaller.run(context.caller, () => this.callRoot.run(context.root, () => this.callSignal.run(context.signal, () => runWith({ plugin, method: `${plugin}.${name}`, caller: context.caller, callId: context.runId }, async () => {
+      const result = await definition.run(definition.input.parse(input), workflowContext(ctx, context));
+      return definition.output ? definition.output.parse(result) : result;
+    })))));
+  }
   async call(name, input = {}, options = {}) {
+    if (options.files) {
+      const { files, ...rest } = options;
+      const fields = input ?? {};
+      if (Object.hasOwn(fields, "files"))
+        throw new MethodError("VALIDATION", "files comes from the upload; leave it out of the input.");
+      return callFiles.run(files, () => this.call(name, { ...fields, files }, rest));
+    }
     if (options.root && options.root !== this.callRoot.getStore()) {
       const { root, ...rest } = options;
       return this.callRoot.run(root, () => this.call(name, input, rest));
@@ -1568,7 +1792,7 @@ class Runtime {
     }
     const raw = input ?? {};
     const parsed = method.input.parse(raw);
-    if (method.confirm && options.confirmed === false)
+    if (method.confirm && (options.confirmed === false || workflowScope.getStore()))
       throw new MethodError("CONFIRM", fillConfirm(method.confirm, parsed));
     if (method.kind === "stream")
       return { result: await this.sample(name, input), reads: [], invalidates: [] };
@@ -1750,6 +1974,7 @@ class Runtime {
     };
   }
   async agent(plugin, ctx, prompt, options) {
+    assertWritable("agents");
     if (!this.host)
       throw new MethodError("INTERNAL", "ctx.agent runs only under the RepoGo host.");
     if (!options.agent)
@@ -1785,8 +2010,9 @@ class Runtime {
         kind: method.kind,
         description: method.description ?? null,
         confirm: method.confirm ?? null,
-        input: z2.toJSONSchema(method.input, { io: "input", unrepresentable: "any" }),
-        output: method.output ? z2.toJSONSchema(method.output, { io: "output", unrepresentable: "any" }) : null
+        http: method.http ?? null,
+        input: z5.toJSONSchema(method.input, { io: "input", unrepresentable: "any" }),
+        output: method.output ? z5.toJSONSchema(method.output, { io: "output", unrepresentable: "any" }) : null
       })),
       crons: this.crons.filter((job) => job.plugin === name).map(cronState),
       storage: {
@@ -1823,8 +2049,17 @@ class Runtime {
     this.databases.set(namespace, database);
     return database;
   }
+  async answerCache(namespace, database) {
+    let cache = this.answerCaches.get(namespace);
+    if (cache)
+      return cache;
+    cache = new AnswerCache(database, namespace, (tags) => this.notifyInvalidated(tags));
+    await cache.setup();
+    this.answerCaches.set(namespace, cache);
+    return cache;
+  }
   async store(plugin, kind, name, schema, make, extra) {
-    const signature = JSON.stringify([z2.toJSONSchema(schema, { unrepresentable: "any" }), extra ?? null]);
+    const signature = JSON.stringify([z5.toJSONSchema(schema, { unrepresentable: "any" }), extra ?? null]);
     const made = make();
     const found = this.stores.get(made.tag);
     if (found && found.schema !== signature) {
@@ -1862,8 +2097,8 @@ class Runtime {
   }
   registerCrud(plugin, name, collection, schema) {
     const prefix = `${plugin}.${name}`;
-    const id = z2.object({ id: z2.string() });
-    const record2 = schema.extend({ id: z2.string(), createdAt: z2.string(), updatedAt: z2.string() });
+    const id = z5.object({ id: z5.string() });
+    const record2 = schema.extend({ id: z5.string(), createdAt: z5.string(), updatedAt: z5.string() });
     const crud = (method, kind, input, output, description, run, confirm) => this.register({
       name: `${prefix}.${method}`,
       plugin,
@@ -1874,16 +2109,16 @@ class Runtime {
       output,
       run: async (value, raw) => run(value, raw)
     });
-    crud("list", "query", z2.object({
-      limit: z2.number().int().positive().max(500).optional(),
-      offset: z2.number().int().min(0).optional(),
-      orderBy: z2.string().optional(),
-      order: z2.enum(["asc", "desc"]).optional()
-    }), z2.array(record2), `List ${name} records, newest first unless orderBy says`, (input) => collection.list(input));
+    crud("list", "query", z5.object({
+      limit: z5.number().int().positive().max(500).optional(),
+      offset: z5.number().int().min(0).optional(),
+      orderBy: z5.string().optional(),
+      order: z5.enum(["asc", "desc"]).optional()
+    }), z5.array(record2), `List ${name} records, newest first unless orderBy says`, (input) => collection.list(input));
     crud("get", "query", id, record2.nullable(), `Get one ${name} record by id, or null`, (input) => collection.get(input.id));
     crud("create", "mutation", schema, record2, `Create a ${name} record`, (input) => collection.create(input));
     crud("update", "mutation", id.extend(schema.partial().shape), record2, `Update fields on a ${name} record`, ({ id: id2, ...fields }, raw) => collection.update(id2, Object.fromEntries(Object.entries(fields).filter(([key]) => Object.hasOwn(raw ?? {}, key)))));
-    crud("delete", "mutation", id, z2.null(), `Delete a ${name} record by id`, async (input) => {
+    crud("delete", "mutation", id, z5.null(), `Delete a ${name} record by id`, async (input) => {
       await collection.delete(input.id);
       return null;
     }, "Delete this record?");
@@ -1918,17 +2153,1294 @@ function mcpFailure(server, tool, error) {
   }
   return new MethodError("INTERNAL", error.message);
 }
+function activityParams(activity, project) {
+  const { compactLabel, timer, ...rest } = activity;
+  return {
+    ...rest,
+    compact_label: compactLabel,
+    timer: timer && {
+      kind: timer.kind,
+      started_at: timer.kind === "elapsed" ? timer.startedAt : undefined,
+      ends_at: timer.kind === "countdown" ? timer.endsAt : undefined
+    },
+    project
+  };
+}
 function isAsyncIterable(value) {
   return typeof value?.[Symbol.asyncIterator] === "function";
 }
 
+// src/self.ts
+Bun.plugin({
+  name: "@repogo/plugins",
+  setup(build) {
+    build.module("@repogo/plugins", () => ({ exports: exports_src, loader: "object" }));
+  }
+});
+
+// src/workflow/testing.ts
+import { mkdtemp, rm as rm4 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join7, resolve as resolve2 } from "path";
+
+// src/workflow/service.ts
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { readdir as readdir4, rm as rm3, stat as stat3 } from "fs/promises";
+import { join as join6 } from "path";
+import { fileURLToPath } from "url";
+import { z as z7 } from "zod";
+
+// src/workflow/catalog.ts
+var {SQL: SQL3 } = globalThis.Bun;
+import { mkdir as mkdir4 } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/workflow/lease.ts
+var {SQL: SQL2 } = globalThis.Bun;
+
+// src/workflow/events.ts
+import { z as z6 } from "zod";
+var ID = z6.string().min(1).max(200);
+var sleepId = (position) => `@sleep:${position}`;
+var SleepID = z6.string().regex(/^@sleep:[1-9]\d*$/);
+var StepID = ID.refine((value) => !value.startsWith("@sleep:"), "Sleep IDs are reserved for the workflow core.");
+var Attempt = z6.number().int().positive();
+var Failure = z6.object({ message: z6.string(), code: z6.string().optional() }).strict();
+var Step = { stepId: StepID, attempt: Attempt };
+var EventInputSchema = z6.discriminatedUnion("type", [
+  z6.object({ type: z6.literal("run.started"), workflow: ID, input: z6.json(), timeoutMs: DurationMsSchema, location: RunLocationSchema.optional() }).strict(),
+  z6.object({ type: z6.literal("sleep.scheduled"), sleepId: SleepID, durationMs: DurationMsSchema }).strict(),
+  z6.object({ type: z6.literal("sleep.completed"), sleepId: SleepID }).strict(),
+  z6.object({ type: z6.literal("step.started"), ...Step, policy: StepPolicySchema }).strict(),
+  z6.object({ type: z6.literal("step.completed"), ...Step, result: z6.json() }).strict(),
+  z6.object({ type: z6.literal("step.failed"), ...Step, error: Failure }).strict(),
+  z6.object({ type: z6.literal("step.unknown"), ...Step, error: Failure }).strict(),
+  z6.object({ type: z6.literal("step.retryScheduled"), ...Step, error: Failure, delayMs: z6.number().int().min(0).max(maxDurationMs) }).strict(),
+  z6.object({ type: z6.literal("run.retryRequested"), stepId: StepID }).strict(),
+  z6.object({ type: z6.literal("run.completed"), result: z6.json() }).strict(),
+  z6.object({ type: z6.literal("run.failed"), error: Failure }).strict(),
+  z6.object({ type: z6.literal("run.cancelRequested") }).strict(),
+  z6.object({ type: z6.literal("run.cancelled") }).strict(),
+  z6.object({ type: z6.literal("run.expired"), reason: z6.string().min(1) }).strict(),
+  z6.object({ type: z6.literal("run.unknown"), error: Failure }).strict(),
+  z6.object({ type: z6.literal("run.attention"), error: Failure }).strict(),
+  z6.object({ type: z6.literal("run.restarted") }).strict()
+]);
+var Envelope = z6.object({ version: z6.literal(1), seq: z6.number().int().positive(), at: z6.iso.datetime() }).strict();
+
+class JournalError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "JournalError";
+  }
+}
+function eventInput(value) {
+  const parsed = EventInputSchema.safeParse(value);
+  if (!parsed.success)
+    throw new JournalError("INVALID_EVENT", parsed.error.message);
+  return JSON.parse(JSON.stringify(parsed.data));
+}
+function storedEvent(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Expected an event object.");
+  const { version, seq, at, ...input } = value;
+  return { ...eventInput(input), ...Envelope.parse({ version, seq, at }) };
+}
+
+// src/workflow/lease.ts
+async function acquireOwner(path) {
+  const owner = new SQL2({ adapter: "sqlite", filename: path });
+  try {
+    await owner.unsafe("pragma busy_timeout = 0");
+    await owner.unsafe("begin exclusive");
+  } catch (error) {
+    await owner.close();
+    if (error instanceof SQL2.SQLiteError && [5, 6].includes(error.errno & 255))
+      throw new JournalError("LOCKED", "Another executor owns this storage.");
+    throw error;
+  }
+  let closed = false;
+  return async () => {
+    if (closed)
+      return;
+    closed = true;
+    try {
+      await owner.unsafe("rollback");
+    } finally {
+      await owner.close();
+    }
+  };
+}
+
+// src/workflow/catalog.ts
+class WorkflowCatalog {
+  sql;
+  release;
+  constructor(sql, release) {
+    this.sql = sql;
+    this.release = release;
+  }
+  static async open(directory) {
+    await mkdir4(directory, { recursive: true, mode: 448 });
+    const release = await acquireOwner(join4(directory, "owner.db"));
+    let sql = null;
+    try {
+      sql = new SQL3({ adapter: "sqlite", filename: join4(directory, "catalog.db") });
+      await sql.unsafe("pragma journal_mode = wal");
+      await sql.unsafe("pragma synchronous = full");
+      await sql.unsafe("create table if not exists runs (id text primary key, metadata text not null, summary text not null, seen real not null, terminal real, error text)");
+      await sql.unsafe("create table if not exists availability (id integer primary key check(id = 1), seen real not null, offline_since real)");
+      return new WorkflowCatalog(sql, release);
+    } catch (error) {
+      await sql?.close();
+      await release();
+      throw error;
+    }
+  }
+  async all() {
+    const rows = await this.sql.unsafe("select metadata, summary, seen, terminal, error from runs order by id");
+    return rows.map((row) => ({ run: JSON.parse(row.metadata), summary: JSON.parse(row.summary), seen: row.seen, terminal: row.terminal, error: row.error }));
+  }
+  async put(value) {
+    await this.sql.unsafe("insert into runs (id,metadata,summary,seen,terminal,error) values (?,?,?,?,?,?) on conflict(id) do update set metadata=excluded.metadata,summary=excluded.summary,seen=excluded.seen,terminal=excluded.terminal,error=excluded.error", [
+      value.run.id,
+      JSON.stringify(value.run),
+      JSON.stringify(value.summary),
+      value.seen,
+      value.terminal,
+      value.error
+    ]);
+  }
+  async availability() {
+    const [row] = await this.sql.unsafe("select seen, offline_since from availability where id = 1");
+    return row ? { seen: row.seen, offlineSince: row.offline_since } : null;
+  }
+  async heartbeat(value) {
+    await this.sql.unsafe("insert into availability (id,seen,offline_since) values (1,?,?) on conflict(id) do update set seen=excluded.seen,offline_since=excluded.offline_since", [value.seen, value.offlineSince]);
+  }
+  async remove(id) {
+    await this.sql.unsafe("delete from runs where id = ?", [id]);
+  }
+  async close() {
+    try {
+      await this.sql.close();
+    } finally {
+      await this.release();
+    }
+  }
+}
+
+// src/workflow/availability.ts
+import { networkInterfaces } from "os";
+var networkAvailable = () => {
+  try {
+    return Object.values(networkInterfaces()).flat().some((address) => address && !address.internal && (address.family === "IPv4" ? !address.address.startsWith("169.254.") : !address.address.startsWith("fe80:")));
+  } catch {
+    return null;
+  }
+};
+function nextAvailability(saved, now, online) {
+  const offlineSince = online === true ? null : online === false ? saved?.offlineSince ?? now : saved?.offlineSince ?? null;
+  return { seen: now, offlineSince };
+}
+
+// src/workflow/clock.ts
+var systemClock = {
+  now: () => Date.now(),
+  schedule(at, callback) {
+    let timer;
+    let cancelled = false;
+    const tick = () => {
+      if (cancelled)
+        return;
+      const remaining = at - Date.now();
+      if (remaining <= 0)
+        callback();
+      else
+        timer = setTimeout(tick, Math.min(remaining, 2147483647));
+    };
+    timer = setTimeout(tick, Math.min(Math.max(0, at - Date.now()), 2147483647));
+    return () => {
+      cancelled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+    };
+  }
+};
+function deadlineFrom(at, milliseconds) {
+  return new Date(Date.parse(at) + milliseconds).toISOString();
+}
+
+// src/workflow/interrupted.ts
+async function settleInterrupted(journal, code) {
+  for (const [stepId, step] of Object.entries(journal.state.steps)) {
+    if (step.status !== "running")
+      continue;
+    await journal.append({
+      type: step.policy.kind === "mutation" ? "step.unknown" : "step.failed",
+      stepId,
+      attempt: step.attempt,
+      error: { code, message: "The workflow stopped before this attempt's outcome was recorded." }
+    });
+  }
+}
+
+// src/workflow/state.ts
+import { isDeepStrictEqual } from "util";
+function initialState() {
+  return {
+    version: 2,
+    lastSeq: 0,
+    status: "pending",
+    workflow: null,
+    input: null,
+    currentStep: null,
+    operationOrder: [],
+    steps: {},
+    sleeps: {},
+    result: null,
+    error: null,
+    expiryReason: null,
+    deadlineAt: null,
+    timeoutMs: null,
+    cancelRequested: false,
+    updatedAt: null,
+    endedAt: null,
+    metadata: null
+  };
+}
+function applyEvent(state, event) {
+  if (event.seq !== state.lastSeq + 1)
+    refuse("Event sequence is not contiguous.");
+  const next = { ...state, lastSeq: event.seq, updatedAt: event.at };
+  if (event.type === "run.started") {
+    if (state.status !== "pending")
+      refuse("The run already started.");
+    return { ...next, metadata: event.location ? { ...event.location, workflow: event.workflow, input: event.input, timeoutMs: event.timeoutMs, createdAt: event.at } : null, status: "running", workflow: event.workflow, input: event.input, timeoutMs: event.timeoutMs, deadlineAt: deadlineFrom(event.at, event.timeoutMs) };
+  }
+  if (event.type === "run.retryRequested") {
+    const step2 = Object.hasOwn(state.steps, event.stepId) ? state.steps[event.stepId] : null;
+    if (state.status !== "failed" || state.cancelRequested || !step2 || step2.status !== "failed" || step2.policy.kind !== "query" || !["STEP", "TIMEOUT", "INTERRUPTED"].includes(step2.error?.code ?? "") || Object.values(state.sleeps).some((sleep) => sleep.status !== "completed") || Object.entries(state.steps).some(([id, value]) => id !== event.stepId && value.status !== "completed"))
+      refuse("Only a safely failed query step can be retried.");
+    if (state.deadlineAt && Date.parse(event.at) >= Date.parse(state.deadlineAt))
+      refuse("The workflow lifetime has ended.");
+    const limit2 = step2.attempt + step2.policy.attempts;
+    if (limit2 > 1e4)
+      refuse("The run's attempt limit is exhausted.");
+    return { ...next, endedAt: null, status: "waiting", error: null, currentStep: event.stepId, steps: {
+      ...state.steps,
+      [event.stepId]: { ...step2, status: "waiting", limit: limit2, nextAttemptAt: event.at }
+    } };
+  }
+  if (event.type === "run.restarted") {
+    if (state.status !== "attention")
+      refuse("Only a run that needs attention can restart.");
+    const deadlineAt = state.timeoutMs === null ? state.deadlineAt : deadlineFrom(event.at, state.timeoutMs);
+    return { ...next, status: "running", error: null, currentStep: null, operationOrder: [], steps: {}, sleeps: {}, deadlineAt };
+  }
+  if (state.status === "attention") {
+    if (event.type === "run.cancelRequested")
+      return { ...next, cancelRequested: true };
+    if (event.type === "run.cancelled")
+      return { ...next, endedAt: event.at, status: "cancelled" };
+    if (event.type === "run.expired")
+      return { ...next, endedAt: event.at, status: "expired", expiryReason: event.reason };
+    refuse("The run needs attention: restart or cancel it.");
+  }
+  if (state.status !== "running" && state.status !== "waiting")
+    refuse("The run is not active.");
+  if (event.type === "run.attention") {
+    if (Object.values(state.steps).some((step2) => step2.status === "running"))
+      refuse("A step is running.");
+    return { ...next, status: "attention", error: event.error };
+  }
+  if (event.type === "run.cancelRequested")
+    return { ...next, cancelRequested: true };
+  if (event.type === "run.completed") {
+    if (state.cancelRequested)
+      refuse("Cancellation prevents run completion.");
+    if (Object.values(state.sleeps).some((sleep) => sleep.status !== "completed") || Object.values(state.steps).some((step2) => step2.status !== "completed"))
+      refuse("An unfinished or failed step prevents run completion.");
+    return { ...next, endedAt: event.at, status: "completed", result: event.result };
+  }
+  if (event.type === "run.failed" || event.type === "run.unknown") {
+    return { ...next, endedAt: event.at, status: event.type === "run.failed" ? "failed" : "unknown", error: event.error };
+  }
+  if (event.type === "run.cancelled")
+    return { ...next, endedAt: event.at, status: "cancelled" };
+  if (event.type === "run.expired")
+    return { ...next, endedAt: event.at, status: "expired", expiryReason: event.reason };
+  if (event.type === "sleep.scheduled") {
+    if (state.cancelRequested)
+      refuse("Cancellation prevents starting sleeps.");
+    if (event.sleepId !== sleepId(state.operationOrder.length + 1) || Object.hasOwn(state.sleeps, event.sleepId))
+      refuse("Sleep identity must match its operation position.");
+    if (Object.values(state.steps).some((step2) => step2.status !== "completed") || Object.values(state.sleeps).some((sleep2) => sleep2.status !== "completed"))
+      refuse("Another operation is unfinished.");
+    const sleep = { status: "waiting", durationMs: event.durationMs, wakeAt: deadlineFrom(event.at, event.durationMs) };
+    return { ...next, status: "waiting", currentStep: event.sleepId, operationOrder: [...state.operationOrder, event.sleepId], sleeps: { ...state.sleeps, [event.sleepId]: sleep } };
+  }
+  if (event.type === "sleep.completed") {
+    const sleep = Object.hasOwn(state.sleeps, event.sleepId) ? state.sleeps[event.sleepId] : null;
+    if (!sleep || sleep.status !== "waiting")
+      refuse("Only a waiting sleep can complete.");
+    if (state.cancelRequested)
+      refuse("Cancellation prevents completing sleeps.");
+    if (Date.parse(event.at) < Date.parse(sleep.wakeAt))
+      throw new JournalError("NOT_DUE", "The sleep is not due.");
+    return { ...next, status: "running", currentStep: event.sleepId, sleeps: { ...state.sleeps, [event.sleepId]: { ...sleep, status: "completed" } } };
+  }
+  const previous = Object.hasOwn(state.steps, event.stepId) ? state.steps[event.stepId] : undefined;
+  let step;
+  if (event.type === "step.started") {
+    if (state.cancelRequested)
+      refuse("Cancellation prevents starting steps.");
+    if (Object.values(state.sleeps).some((sleep) => sleep.status !== "completed"))
+      refuse("A sleep is unfinished.");
+    if (Object.values(state.steps).some((step2) => step2.status === "failed"))
+      refuse("A failed step prevents starting steps.");
+    if (previous) {
+      if (!isDeepStrictEqual(previous.policy, event.policy))
+        refuse("Retry policy differs from its recorded policy.");
+      if (previous.status !== "waiting" || event.attempt !== previous.attempt + 1)
+        refuse("Only a scheduled retry can start the next attempt.");
+      if (Date.parse(event.at) < Date.parse(previous.nextAttemptAt))
+        throw new JournalError("NOT_DUE", "The retry is not due.");
+    } else if (event.attempt !== 1) {
+      refuse("A new step starts at attempt one.");
+    }
+    if (event.attempt > (previous?.limit ?? event.policy.attempts))
+      refuse("The attempt budget is exhausted.");
+    if (Object.entries(state.steps).some(([id, value]) => id !== event.stepId && active(value)))
+      refuse("Another step is unfinished.");
+    step = { status: "running", attempt: event.attempt, limit: previous?.limit ?? event.policy.attempts, result: null, error: null, nextAttemptAt: null, policy: event.policy };
+  } else {
+    if (!previous || previous.status !== "running" || previous.attempt !== event.attempt)
+      refuse("The event does not match a running attempt.");
+    if (event.type === "step.completed") {
+      step = { ...previous, status: "completed", result: event.result, error: null, nextAttemptAt: null };
+    } else if (event.type === "step.failed" || event.type === "step.unknown") {
+      step = { ...previous, status: event.type === "step.failed" ? "failed" : "unknown", error: event.error };
+    } else {
+      if (previous.policy.kind !== "query" || previous.attempt >= previous.limit)
+        refuse("The step cannot retry.");
+      if (state.cancelRequested)
+        refuse("Cancellation prevents retries.");
+      const nextAttemptAt = deadlineFrom(event.at, event.delayMs);
+      step = { ...previous, status: "waiting", error: event.error, nextAttemptAt };
+    }
+  }
+  return {
+    ...next,
+    status: step.status === "waiting" ? "waiting" : "running",
+    currentStep: event.stepId,
+    operationOrder: previous ? state.operationOrder : [...state.operationOrder, event.stepId],
+    steps: { ...state.steps, [event.stepId]: step }
+  };
+}
+function active(step) {
+  return step.status === "running" || step.status === "waiting" || step.status === "unknown";
+}
+function refuse(message) {
+  throw new JournalError("INVALID_EVENT", message);
+}
+
+// src/workflow/storage.ts
+import { constants } from "fs";
+import { mkdir as mkdir5, open, rename as rename2 } from "fs/promises";
+import { dirname, join as join5, resolve } from "path";
+var maxRecordBytes = 1024 * 1024;
+var maxJournalBytes = 64 * 1024 * 1024;
+
+class FileJournalStorage {
+  directory;
+  events;
+  release;
+  constructor(directory, events, release) {
+    this.directory = directory;
+    this.events = events;
+    this.release = release;
+  }
+  static async open(directory, create = true) {
+    directory = resolve(directory);
+    const created = create ? await mkdir5(directory, { recursive: true, mode: 448 }) : undefined;
+    const ancestor = created ? dirname(resolve(created)) : dirname(directory);
+    for (let parent = dirname(directory);; parent = dirname(parent)) {
+      await syncDirectory(parent);
+      if (parent === ancestor)
+        break;
+    }
+    const release = await acquireOwner(join5(directory, "owner.db"));
+    let events;
+    try {
+      events = await open(join5(directory, "events.jsonl"), constants.O_RDWR | constants.O_APPEND | (create ? constants.O_CREAT : 0), 384);
+      await events.sync();
+      await syncDirectory(directory);
+      return new FileJournalStorage(directory, events, release);
+    } catch (error) {
+      try {
+        await events?.close();
+      } finally {
+        await release();
+      }
+      throw error;
+    }
+  }
+  async readEvents() {
+    if ((await this.events.stat()).size > maxJournalBytes)
+      throw new JournalError("LIMIT", "The run journal exceeds its size limit.");
+    return this.events.readFile();
+  }
+  async append(record2) {
+    await this.events.writeFile(record2);
+    await this.events.sync();
+  }
+  async truncateEvents(bytes) {
+    await this.events.truncate(bytes);
+    await this.events.sync();
+  }
+  async replaceSnapshot(snapshot) {
+    const temporary = join5(this.directory, "state.json.tmp");
+    const file = await open(temporary, "w", 384);
+    try {
+      await file.writeFile(snapshot);
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+    await rename2(temporary, join5(this.directory, "state.json"));
+    await syncDirectory(this.directory);
+  }
+  async close() {
+    try {
+      await this.events.close();
+    } finally {
+      await this.release();
+    }
+  }
+}
+async function syncDirectory(path) {
+  const directory = await open(path, "r");
+  try {
+    await directory.sync();
+  } finally {
+    await directory.close();
+  }
+}
+
+// src/workflow/journal.ts
+class RunJournal {
+  storage;
+  clock;
+  value = initialState();
+  listeners = new Set;
+  bytes = 0;
+  queue = Promise.resolve();
+  closing = null;
+  poisoned = false;
+  snapshotFailure = null;
+  constructor(storage, clock) {
+    this.storage = storage;
+    this.clock = clock;
+  }
+  static async open(directory, clock = systemClock) {
+    return RunJournal.recover(await FileJournalStorage.open(directory), clock);
+  }
+  static async openExisting(directory, clock = systemClock) {
+    return RunJournal.recover(await FileJournalStorage.open(directory, false), clock);
+  }
+  static async recover(storage, clock) {
+    const journal = new RunJournal(storage, clock);
+    try {
+      const bytes = Buffer.from(await storage.readEvents());
+      if (bytes.length > maxJournalBytes)
+        throw new JournalError("LIMIT", "The run journal exceeds its size limit.");
+      const complete = bytes.lastIndexOf(10) + 1;
+      let offset = 0;
+      while (offset < complete) {
+        const end = bytes.indexOf(10, offset);
+        if (end - offset + 1 > maxRecordBytes)
+          throw new JournalError("CORRUPT_JOURNAL", "A committed record exceeds its size limit.");
+        try {
+          const line = new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(offset, end));
+          journal.value = applyEvent(journal.value, storedEvent(JSON.parse(line)));
+        } catch (error) {
+          throw new JournalError("CORRUPT_JOURNAL", `Invalid committed event at byte ${offset}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        offset = end + 1;
+      }
+      if (complete !== bytes.length)
+        await storage.truncateEvents(complete);
+      journal.bytes = complete;
+      await journal.checkpoint();
+      return journal;
+    } catch (error) {
+      await storage.close();
+      throw error;
+    }
+  }
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  get state() {
+    return structuredClone(this.value);
+  }
+  get snapshotError() {
+    return this.snapshotFailure;
+  }
+  append(input) {
+    if (this.closing)
+      return Promise.reject(new JournalError("CLOSED", "The journal is closing or closed."));
+    let captured;
+    try {
+      captured = structuredClone(eventInput(input));
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const writing = this.queue.then(async () => {
+      if (this.poisoned)
+        throw new JournalError("POISONED", "A journal write failed. Close and recover before continuing.");
+      const event = { ...captured, version: 1, seq: this.value.lastSeq + 1, at: new Date(this.clock.now()).toISOString() };
+      const next = applyEvent(this.value, event);
+      const record2 = Buffer.from(JSON.stringify(event) + `
+`);
+      const reserve = event.type === "step.started" || event.type === "sleep.scheduled" ? 3 * maxRecordBytes : 0;
+      if (record2.length > maxRecordBytes || this.bytes + record2.length + reserve > maxJournalBytes) {
+        throw new JournalError("LIMIT", "The event or run journal exceeds its size limit.");
+      }
+      try {
+        await this.storage.append(record2);
+      } catch (error) {
+        this.poisoned = true;
+        throw error;
+      }
+      this.value = next;
+      this.bytes += record2.length;
+      await this.checkpoint();
+      for (const listener of this.listeners) {
+        try {
+          listener();
+        } catch (error) {
+          console.error("Workflow observer failed:", error);
+        }
+      }
+      return structuredClone(event);
+    });
+    this.queue = writing.catch(() => {});
+    return writing;
+  }
+  close() {
+    this.closing ??= this.queue.then(async () => {
+      try {
+        if (!this.poisoned && this.snapshotFailure) {
+          await this.checkpoint();
+          if (this.snapshotFailure)
+            throw this.snapshotFailure;
+        }
+      } finally {
+        await this.storage.close();
+      }
+    });
+    return this.closing;
+  }
+  async checkpoint() {
+    try {
+      await this.storage.replaceSnapshot(JSON.stringify(this.value) + `
+`);
+      this.snapshotFailure = null;
+    } catch (error) {
+      this.snapshotFailure = error;
+    }
+  }
+}
+
+// src/workflow/summary.ts
+function summarize(run, state) {
+  const step = state.currentStep && Object.hasOwn(state.steps, state.currentStep) ? state.steps[state.currentStep] : null;
+  const sleep = state.currentStep && Object.hasOwn(state.sleeps, state.currentStep) ? state.sleeps[state.currentStep] : null;
+  return {
+    id: run.id,
+    workflow: run.workflow,
+    status: state.status,
+    currentStep: state.currentStep,
+    attempt: step?.attempt ?? 0,
+    createdAt: run.createdAt,
+    updatedAt: state.updatedAt ?? run.createdAt,
+    nextAttemptAt: !activeStatuses.has(state.status) ? null : sleep?.status === "waiting" ? sleep.wakeAt : step?.nextAttemptAt ?? null,
+    deadlineAt: state.deadlineAt
+  };
+}
+var terminalStatuses = new Set(["completed", "failed", "cancelled", "expired", "unknown"]);
+var activeStatuses = new Set(["pending", "running", "waiting"]);
+var openStatuses = new Set([...activeStatuses, "attention"]);
+function describe(state) {
+  const bounded = (value) => JSON.stringify(value).length <= 16 * 1024 ? value : null;
+  const result = bounded(state.result);
+  return {
+    error: briefError(state.error),
+    input: bounded(state.input),
+    result,
+    resultTruncated: result === null && state.result !== null,
+    inputTruncated: bounded(state.input) === null && state.input !== null,
+    expiryReason: state.expiryReason,
+    cancelRequested: state.cancelRequested,
+    steps: state.operationOrder.slice(-20).map((id) => {
+      const sleep = Object.hasOwn(state.sleeps, id) ? state.sleeps[id] : null;
+      if (sleep)
+        return { id, kind: "sleep", status: sleep.status, attempt: 0, attempts: 0, error: null, nextAttemptAt: activeStatuses.has(state.status) && sleep.status === "waiting" ? sleep.wakeAt : null, durationMs: sleep.durationMs };
+      const step = state.steps[id];
+      return { id, kind: "step", durationMs: null, status: step.status, attempt: step.attempt, attempts: step.limit, error: briefError(step.error), nextAttemptAt: activeStatuses.has(state.status) ? step.nextAttemptAt : null };
+    })
+  };
+}
+function briefError(error) {
+  return error ? { ...error, message: error.message.slice(0, 4000) } : null;
+}
+function unavailableDetail(input, error) {
+  return describe({ ...initialState(), input, error: error ? { message: error } : null });
+}
+
+// src/workflow/service.ts
+var scopeMatches = (run, request) => run.dir === request.dir && run.plugin === request.plugin && run.namespace === request.namespace && run.workflow === request.workflow && run.root === request.root;
+var runReserve = 130 * 1024 * 1024;
+var storageFull = "The workflow storage budget is fully reserved by unfinished runs and retained history. Finish or cancel runs, or wait for retention cleanup.";
+var executor = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./executor.ts" : "./workflow-executor.js", import.meta.url));
+
+class WorkflowService {
+  dataDir;
+  catalog;
+  callbacks;
+  clock;
+  storageLimit;
+  network;
+  queue = Promise.resolve();
+  details = new Map;
+  rows = new Map;
+  unrecovered = new Set;
+  maintenanceErrors = new Map;
+  cancelling = new Set;
+  active = new Map;
+  observers = new Set;
+  timer = null;
+  closing = false;
+  started = false;
+  constructor(dataDir, catalog, callbacks, clock, storageLimit, network) {
+    this.dataDir = dataDir;
+    this.catalog = catalog;
+    this.callbacks = callbacks;
+    this.clock = clock;
+    this.storageLimit = storageLimit;
+    this.network = network;
+  }
+  static async open(dataDir, callbacks, options = {}) {
+    const service = new WorkflowService(dataDir, await WorkflowCatalog.open(join6(dataDir, ".workflows")), callbacks, options.clock ?? systemClock, options.storageLimit ?? 512 * 1024 * 1024, options.network ?? networkAvailable);
+    try {
+      for (const row of await service.catalog.all()) {
+        row.run = RunMetadataSchema.parse(row.run);
+        service.rows.set(row.run.id, row);
+      }
+      await service.recoverCatalog();
+      return service;
+    } catch (error) {
+      await service.catalog.close();
+      throw error;
+    }
+  }
+  directory(run) {
+    return join6(this.dataDir, run.namespace, "workflows", run.id);
+  }
+  serial(work) {
+    const result = this.queue.then(work);
+    this.queue = result.catch(() => {});
+    return result;
+  }
+  observe(listener) {
+    this.observers.add(listener);
+    return () => {
+      this.observers.delete(listener);
+    };
+  }
+  start() {
+    if (!this.closing) {
+      this.started = true;
+      this.wake();
+    }
+  }
+  wake() {
+    this.timer?.();
+    this.timer = null;
+    if (!this.started || this.closing)
+      return;
+    let due = this.clock.now() + (this.rows.size ? 5000 : 60000);
+    for (const row of this.rows.values()) {
+      if (!activeStatuses.has(row.summary.status) && row.summary.status !== "blocked")
+        continue;
+      due = Math.min(due, this.clock.now() + row.run.maxOfflineMs / 2);
+      if (this.active.has(row.run.id) || this.active.size >= 4)
+        continue;
+      due = Math.min(due, row.summary.nextAttemptAt ? Date.parse(row.summary.nextAttemptAt) : this.clock.now());
+      if (row.summary.status !== "blocked" && row.summary.deadlineAt)
+        due = Math.min(due, Date.parse(row.summary.deadlineAt));
+    }
+    this.timer = this.clock.schedule(due, () => {
+      this.tick().finally(() => this.wake()).catch(() => {});
+    });
+  }
+  async save(row) {
+    this.rows.set(row.run.id, row);
+    await this.catalog.put(row);
+    this.callbacks.invalidate([workflowTag(row.run.namespace)]);
+    for (const observer of this.observers) {
+      try {
+        observer(row.summary);
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  }
+  async request(request) {
+    if (this.closing)
+      throw new MethodError("INTERNAL", "The workflow service is closing.");
+    if (request.operation === "list") {
+      const rows = [...this.rows.values()].filter((row2) => scopeMatches(row2.run, request) && (!request.input.status || row2.summary.status === request.input.status)).sort((a, b) => b.run.createdAt.localeCompare(a.run.createdAt) || b.run.id.localeCompare(a.run.id));
+      const cursor = request.input.cursor;
+      const start = cursor ? rows.findIndex((row2) => row2.run.id === cursor) + 1 : 0;
+      if (cursor && start === 0)
+        throw new MethodError("VALIDATION", "Invalid workflow cursor.");
+      const count = Math.min(100, Math.max(1, Number(request.input.limit ?? 20)));
+      const page = rows.slice(start, start + count);
+      return { items: page.map((row2) => row2.summary), cursor: start + count < rows.length ? page.at(-1).run.id : null };
+    }
+    if (request.operation === "start")
+      return this.serial(() => this.create(request));
+    if (request.operation === "cancelAll")
+      return this.cancelAll(request);
+    const row = this.rows.get(String(request.input.id));
+    if (!row || !scopeMatches(row.run, request))
+      throw new MethodError("NOT_FOUND", "No workflow run in this project.");
+    if (request.operation === "retry")
+      return this.serial(async () => {
+        if (await this.bytes(row.run.id) > this.storageLimit)
+          throw new MethodError("VALIDATION", storageFull);
+        const active2 = this.active.get(row.run.id);
+        if (active2) {
+          await active2.ended;
+          this.active.delete(row.run.id);
+        }
+        const journal = await this.openJournal(row.run);
+        try {
+          const stepId = journal.state.currentStep;
+          if (!stepId)
+            throw new MethodError("VALIDATION", "This run has no failed query to retry.");
+          try {
+            await journal.append({ type: "run.retryRequested", stepId });
+          } catch (error) {
+            throw new MethodError("VALIDATION", toCallError(error).message);
+          }
+          row.summary = summarize(row.run, journal.state);
+          row.terminal = null;
+          row.error = null;
+          row.seen = this.clock.now();
+          await this.save(row);
+          this.wake();
+          return row.summary;
+        } finally {
+          await journal.close();
+        }
+      });
+    if (request.operation === "restart")
+      return this.serial(async () => {
+        const journal = await this.openJournal(row.run);
+        try {
+          if (journal.state.status !== "attention")
+            throw new MethodError("VALIDATION", "Only a run that needs attention can restart.");
+          await journal.append({ type: "run.restarted" });
+          row.summary = summarize(row.run, journal.state);
+          row.error = null;
+          row.seen = this.clock.now();
+          await this.save(row);
+          this.wake();
+          return row.summary;
+        } finally {
+          await journal.close();
+        }
+      });
+    if (request.operation === "cancel")
+      return this.cancel(row);
+    return this.serial(async () => {
+      const fallback = unavailableDetail(row.run.input, row.error);
+      if (this.active.has(row.run.id))
+        return { ...row.summary, ...this.details.get(row.run.id) ?? fallback };
+      let journal;
+      try {
+        journal = await this.openJournal(row.run);
+      } catch (error) {
+        if (row.summary.status === "blocked" || row.error)
+          return { ...row.summary, ...fallback };
+        throw error;
+      }
+      try {
+        const state = journal.state;
+        const summary = row.summary.status === "blocked" ? row.summary : summarize(row.run, state);
+        return { ...summary, ...describe(state), error: briefError(state.error ?? (row.error ? { message: row.error } : null)) };
+      } finally {
+        await journal.close();
+      }
+    });
+  }
+  async cancelAll(request) {
+    const status = request.input.status;
+    const rows = [...this.rows.values()].filter((row) => scopeMatches(row.run, request) && (openStatuses.has(row.summary.status) || row.summary.status === "blocked") && (!status || row.summary.status === status));
+    for (const row of rows)
+      await this.cancel(row);
+    return { cancelled: rows.length };
+  }
+  cancel(row) {
+    const active2 = this.active.get(row.run.id);
+    if (active2 && active2.worker.exitCode === null)
+      return this.cancelActive(row, active2);
+    return this.serial(async () => {
+      if (active2) {
+        await active2.ended;
+        this.active.delete(row.run.id);
+      }
+      return this.cancelIdle(row);
+    });
+  }
+  async cancelIdle(row) {
+    const journal = await this.openJournal(row.run);
+    try {
+      if (openStatuses.has(journal.state.status)) {
+        await journal.append({ type: "run.cancelRequested" });
+        await settleInterrupted(journal, "CANCELLED");
+        await journal.append({ type: "run.cancelled" });
+      }
+      row.summary = summarize(row.run, journal.state);
+      if (terminalStatuses.has(row.summary.status))
+        row.terminal ??= Date.parse(row.summary.updatedAt);
+      await this.save(row);
+      return row.summary;
+    } finally {
+      await journal.close();
+    }
+  }
+  async cancelActive(row, active2) {
+    this.cancelling.add(row.run.id);
+    const ack = Promise.withResolvers();
+    active2.acknowledge = ack.resolve;
+    let timer;
+    try {
+      active2.worker.send({ type: "cancel" });
+      const accepted = await Promise.race([ack.promise, active2.worker.exited.then(() => null), new Promise((resolve2) => {
+        timer = setTimeout(() => {
+          active2.worker.kill("SIGKILL");
+          resolve2(null);
+        }, 1000);
+      })]);
+      if (accepted)
+        return accepted;
+      await active2.worker.exited;
+      return await this.serial(async () => {
+        this.active.delete(row.run.id);
+        return this.cancelIdle(row);
+      });
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+      delete active2.acknowledge;
+      this.cancelling.delete(row.run.id);
+      this.wake();
+    }
+  }
+  async create(request) {
+    const input = z7.json().parse(request.input.input);
+    const key = request.input.key ? String(request.input.key) : null;
+    const found = key ? [...this.rows.values()].find((row2) => scopeMatches(row2.run, request) && row2.run.key === key) : undefined;
+    if (found) {
+      if (!isDeepStrictEqual2(found.run.input, input))
+        throw new MethodError("VALIDATION", "This workflow key already has different input.");
+      return found.summary;
+    }
+    if (!request.settings)
+      throw new MethodError("VALIDATION", "Workflow settings are required.");
+    if (await this.bytes() + runReserve > this.storageLimit)
+      throw new MethodError("VALIDATION", storageFull);
+    let run = RunMetadataSchema.parse({ dir: request.dir, root: request.root, namespace: request.namespace, plugin: request.plugin, workflow: request.workflow, caller: request.caller ?? "code", input, key, id: crypto.randomUUID(), createdAt: new Date(this.clock.now()).toISOString(), ...request.settings });
+    const journal = await RunJournal.open(this.directory(run), this.clock);
+    let summary;
+    try {
+      const { workflow, input: savedInput, timeoutMs, createdAt, ...location } = run;
+      await journal.append({ type: "run.started", workflow, input: savedInput, timeoutMs, location });
+      run = journal.state.metadata;
+      summary = summarize(run, journal.state);
+    } finally {
+      await journal.close();
+    }
+    const row = { run, summary, seen: this.clock.now(), terminal: null, error: null };
+    await this.save(row);
+    if (!await this.catalog.availability())
+      await this.catalog.heartbeat(nextAvailability(null, this.clock.now(), this.network()));
+    this.wake();
+    return summary;
+  }
+  tick() {
+    return this.serial(async () => {
+      if (this.closing)
+        return;
+      const now = this.clock.now();
+      if (!this.rows.size) {
+        await this.recoverCatalog();
+        return;
+      }
+      const availability = await this.catalog.availability();
+      const next = nextAvailability(availability, now, this.network());
+      const offlineSince = availability?.offlineSince ?? next.offlineSince;
+      for (const row of [...this.rows.values()]) {
+        try {
+          const networkExpired = offlineSince !== null && now - Math.max(offlineSince, Date.parse(row.run.createdAt)) >= row.run.maxOfflineMs;
+          const unavailable = availability !== null && now - Math.max(availability.seen, Date.parse(row.run.createdAt)) >= row.run.maxOfflineMs;
+          const deadlineReached = row.summary.deadlineAt !== null && now >= Date.parse(row.summary.deadlineAt);
+          if (this.active.has(row.run.id)) {
+            if (!networkExpired && !unavailable && !deadlineReached) {
+              row.seen = now;
+              continue;
+            }
+            const active2 = this.active.get(row.run.id);
+            active2.worker.kill("SIGKILL");
+            await active2.worker.exited;
+            this.active.delete(row.run.id);
+          }
+          if (row.terminal !== null && now - row.terminal < row.run.retentionMs)
+            continue;
+          if (availability && !networkExpired && !unavailable && !deadlineReached && row.summary.nextAttemptAt && Date.parse(row.summary.nextAttemptAt) > now) {
+            row.seen = now;
+            continue;
+          }
+          const blockedUntil = row.summary.status === "blocked" ? row.summary.nextAttemptAt : null;
+          try {
+            const journal = await this.openJournal(row.run);
+            try {
+              const state = journal.state;
+              const offline = networkExpired || unavailable || !availability && now - row.seen >= row.run.maxOfflineMs;
+              const expired = state.deadlineAt !== null && now >= Date.parse(state.deadlineAt);
+              if (openStatuses.has(state.status) && (offline || expired)) {
+                await settleInterrupted(journal, "EXPIRED");
+                await journal.append({ type: "run.expired", reason: offline ? "Environment unavailable beyond the workflow offline limit." : "Workflow deadline reached." });
+              }
+              row.summary = summarize(row.run, journal.state);
+              if (activeStatuses.has(row.summary.status) && blockedUntil && Date.parse(blockedUntil) > now)
+                row.summary = { ...row.summary, status: "blocked", nextAttemptAt: blockedUntil };
+              row.seen = now;
+              if (journal.state.endedAt)
+                row.terminal ??= Date.parse(journal.state.endedAt);
+              await this.save(row);
+            } finally {
+              await journal.close();
+            }
+          } catch (error) {
+            row.error = toCallError(error).message;
+            if (!terminalStatuses.has(row.summary.status)) {
+              const expired = now - row.seen >= row.run.maxOfflineMs || row.summary.deadlineAt !== null && now >= Date.parse(row.summary.deadlineAt);
+              row.summary = { ...row.summary, status: expired ? "expired" : "blocked", nextAttemptAt: expired ? null : new Date(now + 60000).toISOString() };
+              if (expired)
+                row.terminal ??= now;
+            }
+            await this.save(row);
+          }
+          if (row.terminal !== null && now - row.terminal >= row.run.retentionMs) {
+            await rm3(this.directory(row.run), { recursive: true, force: true });
+            await this.catalog.remove(row.run.id);
+            this.rows.delete(row.run.id);
+            this.details.delete(row.run.id);
+            this.maintenanceErrors.delete(row.run.id);
+            this.callbacks.invalidate([workflowTag(row.run.namespace)]);
+            continue;
+          }
+          if (!this.cancelling.has(row.run.id) && activeStatuses.has(row.summary.status) && this.active.size < 4 && (!row.summary.nextAttemptAt || now >= Date.parse(row.summary.nextAttemptAt)))
+            await this.launch(row);
+          this.maintenanceErrors.delete(row.run.id);
+        } catch (error) {
+          row.error = toCallError(error).message;
+          if (this.maintenanceErrors.get(row.run.id) !== row.error)
+            console.error("Workflow maintenance failed:", row.run.id, row.error);
+          this.maintenanceErrors.set(row.run.id, row.error);
+        }
+      }
+      await this.catalog.heartbeat(next);
+      await this.recoverCatalog();
+    });
+  }
+  async launch(row) {
+    try {
+      const worker = Bun.spawn([process.execPath, "--no-env-file", executor], {
+        cwd: row.run.dir,
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "pipe",
+        ipc: (message) => onMessage(message),
+        serialization: "advanced"
+      });
+      const stderr = stderrTail(worker.stderr);
+      let finish;
+      const ended = new Promise((resolve2) => {
+        finish = resolve2;
+      });
+      const active2 = { worker, ended, finish, error: null };
+      this.active.set(row.run.id, active2);
+      let finished = false;
+      const complete = () => {
+        if (finished)
+          return;
+        finished = true;
+        active2.finish();
+        if (this.closing)
+          return;
+        this.serial(async () => {
+          if (this.active.get(row.run.id) !== active2)
+            return;
+          this.active.delete(row.run.id);
+          row.error = active2.error;
+          if (active2.error && !terminalStatuses.has(row.summary.status)) {
+            row.summary = { ...row.summary, status: "blocked", nextAttemptAt: new Date(this.clock.now() + 60000).toISOString() };
+            await this.save(row);
+          }
+        }).then(() => this.tick()).then(() => this.wake()).catch(() => {});
+      };
+      const onMessage = (message) => {
+        if (this.closing)
+          return;
+        if (message.type === "host") {
+          this.callbacks.host(message.plugin, message.method, message.params).then((result) => worker.send({ type: "hosted", id: message.id, result }), (error) => worker.send({ type: "hosted", id: message.id, error: toCallError(error) })).catch(() => {});
+        } else if (message.type === "state") {
+          const summary = RunSummarySchema.safeParse(message.summary);
+          if (!summary.success || summary.data.id !== row.run.id || summary.data.workflow !== row.run.workflow || summary.data.createdAt !== row.run.createdAt) {
+            active2.error = "The workflow executor reported an invalid run identity.";
+            return;
+          }
+          if (message.detail.cancelRequested)
+            active2.acknowledge?.(message.summary);
+          this.serial(async () => {
+            if (this.active.get(row.run.id) !== active2)
+              return;
+            row.summary = message.summary;
+            this.details.set(row.run.id, message.detail);
+            row.seen = this.clock.now();
+            await this.save(row);
+          });
+        } else if (message.type === "invalidated")
+          this.callbacks.invalidate(message.tags);
+        else if (message.type === "notice")
+          this.callbacks.notify(message.notice);
+        else if (message.type === "log")
+          this.callbacks.logs(row.run.dir, message.records);
+        else if (message.type === "error")
+          active2.error = message.message;
+        else if (message.type === "done") {}
+      };
+      worker.exited.then(async (code) => {
+        if (code !== 0 && !active2.error)
+          active2.error = (await stderr).slice(-4000) || `Workflow executor exited ${code}.`;
+        complete();
+      });
+      worker.send({ type: "start", run: row.run, directory: this.directory(row.run), dataDir: this.dataDir });
+    } catch (error) {
+      row.summary = { ...row.summary, status: "blocked", nextAttemptAt: new Date(this.clock.now() + 60000).toISOString() };
+      row.error = toCallError(error).message;
+      await this.save(row);
+    }
+  }
+  async openJournal(run) {
+    const path = this.directory(run);
+    if (!(await stat3(join6(path, "events.jsonl"))).size)
+      throw new Error("The workflow journal is missing or empty; execution is blocked.");
+    return RunJournal.openExisting(path, this.clock);
+  }
+  async recoverCatalog() {
+    let complete = true;
+    const namespaces = await readdir4(this.dataDir, { withFileTypes: true });
+    for (const namespace of namespaces) {
+      if (!namespace.isDirectory() || !/^[a-z0-9][a-z0-9.-]*$/.test(namespace.name))
+        continue;
+      const base = join6(this.dataDir, namespace.name, "workflows");
+      const entries = await readdir4(base, { withFileTypes: true }).catch((error) => {
+        if (error.code !== "ENOENT") {
+          complete = false;
+          if (!this.unrecovered.has(base))
+            console.error("Workflow discovery blocked:", base, toCallError(error).message);
+          this.unrecovered.add(base);
+        }
+        return [];
+      });
+      for (const entry of entries) {
+        if (!entry.isDirectory() || !z7.string().uuid().safeParse(entry.name).success || this.rows.has(entry.name))
+          continue;
+        const directory = join6(base, entry.name);
+        try {
+          const history = await stat3(join6(directory, "events.jsonl")).catch((error) => {
+            if (error.code !== "ENOENT")
+              throw error;
+            return null;
+          });
+          if (!history?.size)
+            continue;
+          const journal = await RunJournal.openExisting(directory, this.clock);
+          try {
+            const state = journal.state;
+            const run = state.metadata;
+            if (!run || run.id !== entry.name || run.namespace !== namespace.name)
+              throw new Error("Workflow journal location is invalid.");
+            const row = { run, summary: summarize(run, state), seen: Date.parse(state.updatedAt), terminal: state.endedAt ? Date.parse(state.endedAt) : null, error: null };
+            await this.catalog.put(row);
+            this.rows.set(run.id, row);
+            this.unrecovered.delete(directory);
+          } finally {
+            await journal.close();
+          }
+        } catch (error) {
+          complete = false;
+          if (!this.unrecovered.has(directory))
+            console.error("Workflow discovery blocked:", directory, toCallError(error).message);
+          this.unrecovered.add(directory);
+        }
+      }
+    }
+    return complete;
+  }
+  async bytes(reserveId) {
+    const tree = async (path) => {
+      const entries = await readdir4(path, { withFileTypes: true }).catch((error) => {
+        if (error.code !== "ENOENT")
+          throw error;
+        return [];
+      });
+      let size = 0;
+      for (const entry of entries) {
+        const name = join6(path, entry.name);
+        if (entry.isDirectory())
+          size += await tree(name);
+        else
+          size += await stat3(name).then((info) => info.size, (error) => {
+            if (error.code !== "ENOENT")
+              throw error;
+            return 0;
+          });
+      }
+      return size;
+    };
+    let bytes = 0;
+    for (const row of this.rows.values()) {
+      const size = await tree(this.directory(row.run));
+      const reserved = openStatuses.has(row.summary.status) || row.summary.status === "blocked" || row.run.id === reserveId;
+      bytes += reserved ? Math.max(size, runReserve) : size;
+    }
+    return bytes;
+  }
+  async close() {
+    if (this.closing)
+      return;
+    this.closing = true;
+    this.timer?.();
+    this.timer = null;
+    const active2 = [...this.active.values()];
+    for (const value of active2)
+      value.worker.send({ type: "suspend" });
+    let timer;
+    try {
+      await Promise.race([Promise.all(active2.map((value) => value.worker.exited)), new Promise((resolve2) => {
+        timer = setTimeout(resolve2, 1000);
+      })]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+    for (const value of active2)
+      if (value.worker.exitCode === null)
+        value.worker.kill("SIGKILL");
+    await Promise.all(active2.map((value) => value.worker.exited));
+    await this.queue;
+    await this.catalog.close();
+  }
+}
+async function stderrTail(stream) {
+  const decoder = new TextDecoder;
+  let tail = "";
+  for await (const chunk of stream)
+    tail = (tail + decoder.decode(chunk, { stream: true })).slice(-4000);
+  return (tail + decoder.decode()).slice(-4000);
+}
+
+// src/workflow/testing.ts
+async function testWorkflowRuntime(directory, options = {}) {
+  const dataDir = await mkdtemp(join7(tmpdir(), "repogo-workflow-test-"));
+  let runtime;
+  const host = async (_plugin, method, params) => {
+    if (!options.host)
+      throw new MethodError("FORBIDDEN", `This test does not serve ${method}.`);
+    return options.host(method, params);
+  };
+  const service = await WorkflowService.open(dataDir, {
+    host,
+    invalidate: () => {},
+    notify: () => {},
+    logs: () => {}
+  });
+  try {
+    runtime = await Runtime.open({ dataDir, root: resolve2(options.root ?? directory), host, workflows: (request) => service.request(request) });
+    await runtime.loadDir(resolve2(directory));
+    service.start();
+    return {
+      call: async (method, input = {}, call = {}) => (await runtime.call(method, input, call)).result,
+      manifest: () => runtime.manifest(),
+      wait: (method, id, timeout = 1e4) => new Promise((resolve3, reject) => {
+        const finish = () => {
+          clearTimeout(timer);
+          remove();
+          runtime.call(`${method}.get`, { id }).then((value) => resolve3(value.result), reject);
+        };
+        const remove = service.observe((summary) => {
+          if (summary.id === id && (terminalStatuses.has(summary.status) || summary.status === "blocked"))
+            finish();
+        });
+        const timer = setTimeout(() => {
+          remove();
+          reject(new Error(`Workflow ${id} did not finish within ${timeout}ms.`));
+        }, timeout);
+        runtime.call(`${method}.get`, { id }).then((value) => {
+          const summary = value.result;
+          if (terminalStatuses.has(summary.status) || summary.status === "blocked")
+            finish();
+        }, (error) => {
+          clearTimeout(timer);
+          remove();
+          reject(error);
+        });
+      }),
+      close: async () => {
+        await service.close();
+        runtime.close();
+        await rm4(dataDir, { recursive: true, force: true });
+      }
+    };
+  } catch (error) {
+    await service.close();
+    runtime?.close();
+    await rm4(dataDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+
 // src/testing.ts
 async function testRuntime(plugins, options = {}) {
-  const dataDir = await mkdtemp(join4(tmpdir(), "repogo-plugin-test-"));
-  const project = join4(dataDir, "project");
-  await mkdir4(project);
+  const dataDir = await mkdtemp2(join8(tmpdir2(), "repogo-plugin-test-"));
+  const project = join8(dataDir, "project");
+  await mkdir6(project);
   const host = options.mcp || options.host ? testHost(options.mcp, options.host) : undefined;
-  const runtime = await Runtime.open({ dataDir: join4(dataDir, "data"), root: options.root ?? project, host });
+  const runtime = await Runtime.open({ dataDir: join8(dataDir, "data"), root: options.root ?? project, host });
   const notices = [];
   runtime.onNotify((notice) => notices.push(notice));
   const logs = [];
@@ -1939,7 +3451,7 @@ async function testRuntime(plugins, options = {}) {
   } catch (error) {
     releaseConsole();
     runtime.close();
-    await rm3(dataDir, { recursive: true, force: true });
+    await rm5(dataDir, { recursive: true, force: true });
     throw error;
   }
   return {
@@ -1954,7 +3466,7 @@ async function testRuntime(plugins, options = {}) {
     close: async () => {
       releaseConsole();
       runtime.close();
-      await rm3(dataDir, { recursive: true, force: true });
+      await rm5(dataDir, { recursive: true, force: true });
     }
   };
 }
@@ -1975,5 +3487,6 @@ function testHost(mcp, host) {
   };
 }
 export {
+  testWorkflowRuntime,
   testRuntime
 };