@nestos/kanban 0.0.0-stage → 0.5.2

package/dist/chunk-FEE2YBZ7.js

@@ -0,0 +1,1972 @@
+import {
+  createKanbanActivityModule
+} from "./chunk-FNO5K3A7.js";
+import {
+  SeqKanbanStore
+} from "./chunk-AHHEGTUA.js";
+import {
+  createKanbanExecutionBridge
+} from "./chunk-IHHDXZPZ.js";
+import {
+  requireValue
+} from "./chunk-3LEIHB7Y.js";
+import {
+  DEFAULT_KANBAN_WORK_TYPES,
+  executableWorkItem
+} from "./chunk-X4UHZX6F.js";
+import {
+  KanbanError,
+  randomUUID,
+  sha256HexSync
+} from "./chunk-M35X5PHO.js";
+import {
+  boardAllowsStart,
+  taskDue
+} from "./chunk-3JYLJPE5.js";
+
+// src/runtime/diagnostics.ts
+function safeCode(error, fallback) {
+  const code = error?.code;
+  return typeof code === "string" && /^[A-Z][A-Z0-9_]{0,79}$/.test(code) ? code : fallback;
+}
+
+// src/runtime/automation-journal.ts
+import { normalizeVirtualPath } from "@nestos/vfs-core";
+
+// src/runtime/automation-board-index.ts
+var boardIndexPath = "/kanban/runtime/automation-board-index.seq";
+var families = ["review-operation:", "record-runs:", "fix:", "task-reply:"];
+function boardIndexPrefix(boardId, family) {
+  return JSON.stringify([boardId, family]).slice(0, -1) + ",";
+}
+function boardIndexKeys(key, value) {
+  const family = families.find((prefix2) => key.startsWith(prefix2));
+  if (!family) return [];
+  const boards = /* @__PURE__ */ new Set();
+  for (const row of Array.isArray(value) ? value : [value]) {
+    if (!row || typeof row !== "object") continue;
+    for (const id of [row.boardId, row.sourceBoardId]) if (typeof id === "string" && id) boards.add(id);
+  }
+  return [...boards].sort().map((board) => JSON.stringify([board, family, key]));
+}
+async function updateBoardIndex(tx, key, previous, value, indexPath = boardIndexPath) {
+  const next = new Set(boardIndexKeys(key, value)), oldKeys = new Set(previous);
+  for (const old of previous) if (!next.has(old)) await tx.deleteEntry(indexPath, old);
+  for (const index of next) if (!oldKeys.has(index)) await tx.setEntry(indexPath, index, key);
+}
+async function migrateBoardIndex(tx, source, indexPath = boardIndexPath, diagnostic = () => {
+}) {
+  if (await tx.getEntry(indexPath, "version") === "1") return;
+  const started = Date.now(), operationId = randomUUID();
+  let count = 0;
+  try {
+    for (const keyPrefix of families) await tx.walkEntries(source, async (entry) => {
+      await updateBoardIndex(tx, entry.key, [], JSON.parse(entry.value), indexPath);
+      count++;
+      return true;
+    }, { keyPrefix });
+    await tx.setEntry(indexPath, "version", "1");
+    diagnostic({ operation: "kanban.board.index", operationId, stage: "migrate", result: "success", count, durationMs: Date.now() - started });
+  } catch (error) {
+    diagnostic({ operation: "kanban.board.index", operationId, stage: "migrate", result: "failure", code: safeCode(error, "BOARD_INDEX_MIGRATION_FAILED"), durationMs: Date.now() - started });
+    throw error;
+  }
+}
+
+// src/runtime/automation-journal.ts
+var KanbanAutomationJournal = class {
+  constructor(fs, options = {}) {
+    this.fs = fs;
+    this.options = options;
+    this.directory = normalizeVirtualPath(options.directory ?? "/kanban/runtime");
+    this.path = this.directory + "/automation.seq";
+    this.indexPath = this.directory + "/automation-board-index.seq";
+    this.artifactScheme = options.artifactScheme ?? "kanban-artifact:";
+  }
+  writes = /* @__PURE__ */ new Set();
+  directory;
+  indexPath;
+  path;
+  artifactScheme;
+  diagnostic(event) {
+    this.options.diagnostic?.(event);
+  }
+  async open() {
+    requireValue(this.fs.meta.seq?.transaction, "TRANSACTION_REQUIRED");
+    for (const name of ["automation.seq", "automation-board-index.seq"]) {
+      try {
+        await this.fs.driver.createFile({ parentPath: this.directory, name, type: "seqfile", recursive: true });
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+    }
+    if (await this.fs.meta.seq.getEntry(this.indexPath, "version") !== "1")
+      await this.fs.meta.seq.transaction((tx) => migrateBoardIndex(tx, this.path, this.indexPath, (event) => this.diagnostic(event)));
+  }
+  async get(key) {
+    const raw = await this.fs.meta.seq.getEntry(this.path, key);
+    return raw ? JSON.parse(raw) : void 0;
+  }
+  async getMany(keys) {
+    if (!keys.length) return [];
+    const rows = await this.fs.meta.seq.getEntries(this.path, keys);
+    return keys.map((key) => rows[key] === void 0 ? void 0 : JSON.parse(rows[key]));
+  }
+  async findForBoard(family, boardId, matches) {
+    const keys = [];
+    await this.fs.meta.seq.walkEntries(this.indexPath, (entry) => {
+      keys.push(entry.value);
+      requireValue(keys.length <= 1e3, "SESSION_RELATION_LIMIT");
+      return true;
+    }, { keyPrefix: boardIndexPrefix(boardId, family) });
+    const values = await this.getMany(keys);
+    return values.flatMap((value, index) => value !== void 0 && matches(value) ? [{ key: keys[index], value }] : []);
+  }
+  async find(keyPrefix, matches) {
+    const rows = [];
+    await this.fs.meta.seq.walkEntries(this.path, (entry) => {
+      const value = JSON.parse(entry.value);
+      if (matches(value, entry.key)) rows.push({ key: entry.key, value });
+      requireValue(rows.length <= 1e3, "SESSION_RELATION_LIMIT");
+      return true;
+    }, { keyPrefix });
+    return rows;
+  }
+  update(key, change) {
+    const pending2 = this.commit(key, change).finally(() => {
+      this.writes.delete(pending2);
+    });
+    this.writes.add(pending2);
+    return pending2;
+  }
+  async drain() {
+    await Promise.allSettled([...this.writes]);
+  }
+  claim(key) {
+    const pending2 = this.fs.meta.seq.transaction(async (tx) => {
+      const raw = await tx.getEntry(this.path, key);
+      requireValue(raw, "AUTOMATION_JOURNAL_MISSING");
+      const record = JSON.parse(raw);
+      if (record.phase !== "prepared") return false;
+      await tx.setEntry(this.path, key, JSON.stringify({ ...record, phase: "submitting" }));
+      return true;
+    }).finally(() => {
+      this.writes.delete(pending2);
+    });
+    this.writes.add(pending2);
+    return pending2;
+  }
+  async commit(key, change) {
+    return this.fs.meta.seq.transaction(async (tx) => {
+      const raw = await tx.getEntry(this.path, key), previous = raw ? JSON.parse(raw) : void 0;
+      const previousIndex = boardIndexKeys(key, previous), value = change(previous);
+      const encoded = JSON.stringify(value);
+      if (encoded === raw) return structuredClone(value);
+      await updateBoardIndex(tx, key, previousIndex, value, this.indexPath);
+      await tx.setEntry(this.path, key, encoded);
+      return structuredClone(value);
+    });
+  }
+  async artifact(dispatchId, value) {
+    const text = JSON.stringify(value ?? null), bytes = new TextEncoder().encode(text).byteLength;
+    requireValue(bytes <= 1024 * 1024, "AUTOMATION_OUTPUT_TOO_LARGE");
+    const sha256 = sha256HexSync(text);
+    await this.update("artifact:" + sha256, (previous) => {
+      requireValue(previous === void 0 || previous === text, "ARTIFACT_CONFLICT");
+      return text;
+    });
+    const outputs = [{ name: "result", ref: this.artifactScheme + sha256, sha256, bytes }];
+    await this.update("artifact-owner:" + dispatchId, (previous) => {
+      requireValue(!previous || JSON.stringify(previous) === JSON.stringify(outputs), "ARTIFACT_CONFLICT");
+      return outputs;
+    });
+    return outputs;
+  }
+  async verify(outputs, dispatchId) {
+    if (dispatchId && JSON.stringify(await this.get("artifact-owner:" + dispatchId)) !== JSON.stringify(outputs)) return false;
+    for (const output of outputs) {
+      if (output.ref !== this.artifactScheme + output.sha256) return false;
+      const text = await this.get("artifact:" + output.sha256);
+      if (text === void 0 || sha256HexSync(text) !== output.sha256 || new TextEncoder().encode(text).byteLength !== output.bytes) return false;
+    }
+    return true;
+  }
+};
+
+// src/runtime/ports.ts
+var defaultReferences = {
+  resource: "kanban-resource",
+  decision: "kanban-decision",
+  execution: "kanban-execution",
+  workspace: "kanban-workspace"
+};
+
+// src/runtime/work-log-snapshots.ts
+async function workLogSnapshots(boardId, source, items, seen, projection) {
+  const { activityRecord, ancestorIds, lifecycleReferences } = projection;
+  const workflow = await source.workflow(boardId), records = bindingSnapshots(boardId, items, seen, projection);
+  for (const dispatch of Object.values(workflow.dispatches)) {
+    const item = items.find((item2) => item2.id === dispatch.itemId);
+    if (dispatch.outcome !== "accepted" || item?.status !== "completed") continue;
+    records.push(activityRecord(
+      { id: boardId },
+      item,
+      `${dispatch.id}:task.completed:`,
+      item.closedAt ?? Date.now(),
+      { stage: "task.completed", result: "success", dispatchId: dispatch.id, fields: { evidence: "accepted-dispatch" } },
+      lifecycleReferences(item.externalRefs),
+      void 0,
+      ancestorIds(item, items)
+    ));
+  }
+  return records;
+}
+function bindingSnapshots(board, items, seen, projection) {
+  const { activityRecord, ancestorIds, lifecycleReferences } = projection;
+  const at = Date.now();
+  return items.flatMap((item) => {
+    const refs = lifecycleReferences(item.externalRefs).filter((ref) => !seen.has(JSON.stringify([item.id, ref.system, ref.id])));
+    if (!refs.length) return [];
+    return [activityRecord(
+      { id: board },
+      item,
+      "snapshot:" + item.id,
+      at,
+      { stage: "association.observed", result: "success", fields: { evidence: "existing-reference" } },
+      refs,
+      void 0,
+      ancestorIds(item, items)
+    )];
+  });
+}
+
+// src/runtime/work-log-store.ts
+import { FSError } from "@nestos/vfs-core";
+var snapshotVersion = "2";
+var prefix = (board) => encodeURIComponent(board) + "/";
+var rowKey = (board, id) => "row/" + prefix(board) + encodeURIComponent(id);
+var KanbanWorkLogStore = class {
+  constructor(fs, directory = "/kanban/runtime", executionSystem = "kanban-execution") {
+    this.fs = fs;
+    this.directory = directory;
+    this.executionSystem = executionSystem;
+    this.path = directory + "/work-log.seq";
+  }
+  path;
+  async open() {
+    try {
+      await this.fs.driver.createFile({ parentPath: this.directory, name: "work-log.seq", type: "seqfile", recursive: true });
+    } catch (error) {
+      if (!(error instanceof FSError) || error.code !== "EEXIST") throw error;
+    }
+  }
+  async record(board, id) {
+    const raw = await this.fs.meta.seq.getEntry(this.path, rowKey(board, id));
+    return raw ? JSON.parse(raw) : void 0;
+  }
+  async append(board, record) {
+    await this.fs.meta.seq.transaction((tx) => this.appendTx(tx, board, record));
+  }
+  async checkpoint(board) {
+    return Number(await this.fs.meta.seq.getEntry(this.path, "checkpoint/" + prefix(board)) ?? 0);
+  }
+  async commit(board, after, through, rows) {
+    await this.fs.meta.seq.transaction(async (tx) => {
+      if (Number(await tx.getEntry(this.path, "checkpoint/" + prefix(board)) ?? 0) !== after) return;
+      for (const row of rows) await this.appendTx(tx, board, row);
+      await tx.setEntry(this.path, "checkpoint/" + prefix(board), String(through));
+    });
+  }
+  async needsSnapshot(board) {
+    return await this.fs.meta.seq.getEntry(this.path, "snapshot/" + prefix(board)) !== snapshotVersion;
+  }
+  async snapshot(board, records) {
+    await this.fs.meta.seq.transaction(async (tx) => {
+      const key = "snapshot/" + prefix(board);
+      if (await tx.getEntry(this.path, key) === snapshotVersion) return;
+      for (const record of records) await this.appendTx(tx, board, record);
+      await tx.setEntry(this.path, key, snapshotVersion);
+    });
+  }
+  async page(board, itemId, offset, limit) {
+    return this.fs.meta.seq.transaction(async (tx) => {
+      const rows = [];
+      const keyPrefix = itemId ? "item/" + prefix(board) + encodeURIComponent(itemId) + "/" : "summary/" + prefix(board);
+      const page = await tx.walkEntries(this.path, (entry) => {
+        rows.push(JSON.parse(entry.value));
+        return true;
+      }, { keyPrefix, offset, limit });
+      return { items: rows, total: page.total, revision: Number(await tx.getEntry(this.path, "revision/" + prefix(board)) ?? 0) };
+    });
+  }
+  async appendTx(tx, board, row) {
+    if (await tx.getEntry(this.path, rowKey(board, row.id))) return;
+    const { content: _content, rationale: _rationale, sources: _sources, ...metadata } = row;
+    const summary = { ...metadata, sessionIds: row.externalRefs?.filter((ref) => ref.system === this.executionSystem).map((ref) => ref.id) ?? [] };
+    const order2 = String(Number.MAX_SAFE_INTEGER - row.createdAt).padStart(16, "0") + "/" + row.id;
+    await tx.setEntry(this.path, rowKey(board, row.id), JSON.stringify(row));
+    await tx.setEntry(this.path, "summary/" + prefix(board) + order2, JSON.stringify(summary));
+    for (const id of row.itemIds) await tx.setEntry(this.path, "item/" + prefix(board) + encodeURIComponent(id) + "/" + order2, JSON.stringify(summary));
+    await tx.increment(this.path, "revision/" + prefix(board));
+  }
+};
+
+// src/runtime/work-log-events.ts
+function createWorkLogProjection(options = {}) {
+  const references = options.references ?? defaultReferences;
+  function eventActivity(event) {
+    const base = { actor: { kind: event.actor.kind ?? "agent", id: event.actor.id ?? event.actor.agentId ?? "unknown" }, result: "success", ...event.data.dispatchId ? { dispatchId: event.data.dispatchId } : {} };
+    if (event.kind === "report-analysis") return { ...base, stage: "analysis." + (event.data.reason?.slice("analysis-".length) ?? "unknown"), result: event.data.code ? "failure" : "success", code: event.data.code };
+    if (event.kind === "control-receipt") return { ...base, stage: "execution." + (event.data.reason ?? "control-unknown"), result: event.data.code ? "failure" : "success", code: event.data.code };
+    if (event.kind === "create-item") return { ...base, stage: "task.created" };
+    if (event.kind === "prepare-dispatch") return { ...base, stage: "execution.prepared" };
+    if (event.kind === "continue-execution") return { ...base, stage: "execution.continued" };
+    if (event.kind === "submit") return { ...base, stage: "execution.review" };
+    if (event.kind === "close-plan" || event.kind === "review" && event.data.reason === "accepted" || event.kind === "accept-execution" && event.data.reason === "accepted") return { ...base, stage: "task.completed" };
+    if (event.kind === "cancel-item" || event.kind === "release-item" && event.data.reason === "cancelled") return { ...base, stage: "task.cancelled", result: "cancelled" };
+    if (event.kind === "observe-execution") {
+      const result = event.data.reason?.slice("execution-".length);
+      if (result && ["running", "succeeded", "failed", "cancelled", "unknown"].includes(result)) return {
+        ...base,
+        stage: result === "succeeded" && event.data.status === "completed" ? "task.completed" : "execution." + result,
+        result: result === "failed" || result === "unknown" ? "failure" : result === "cancelled" ? "cancelled" : "success",
+        code: event.data.code
+      };
+    }
+    if (event.kind === "link-reference" && event.data.reference) {
+      const system = event.data.reference.system;
+      const stage = system === references.execution ? "session.bound" : system === references.nativeExecution ? "session.native" : system === references.workspace ? "worktree.prepared" : void 0;
+      if (stage) return { ...base, stage };
+    }
+    if (event.kind === "message") return { ...base, stage: "task.message" };
+    if (event.kind === "block-item") return { ...base, stage: "task.blocked", result: "failure", code: event.data.reason };
+    return void 0;
+  }
+  function activityRecord(board, item, id, at, activity, refs = [], content, ancestors = []) {
+    const label = options.label?.(activity.stage) ?? activity.stage;
+    return {
+      id: "activity-" + sha256HexSync(JSON.stringify([board.id, id])),
+      kind: "log",
+      title: [item?.title, label].filter(Boolean).join(" \xB7 "),
+      content: content ?? [label, activity.code, ...Object.entries(activity.fields ?? {}).map(([key, value]) => `${key}: ${value}`)].filter(Boolean).join("\n"),
+      activity,
+      externalRefs: refs,
+      itemIds: [.../* @__PURE__ */ new Set([...item ? [item.id] : [], ...ancestors])],
+      sources: [],
+      author: activity.actor ?? { kind: "service", id: "kanban-activity" },
+      origin: "flow",
+      status: "confirmed",
+      revision: 1,
+      createdAt: at,
+      updatedAt: at
+    };
+  }
+  function ancestorIds(item, items) {
+    const result = [], seen = new Set(item ? [item.id] : []);
+    let parent = item?.planning.parentId;
+    while (parent && !seen.has(parent)) {
+      seen.add(parent);
+      result.push(parent);
+      parent = items.find((row) => row.id === parent)?.planning.parentId;
+    }
+    return result;
+  }
+  function lifecycleReferences(refs = []) {
+    return [references.execution, references.nativeExecution, references.workspace].flatMap((system) => {
+      const ref = refs.filter((ref2) => ref2.system === system).at(-1);
+      return ref ? [ref] : [];
+    });
+  }
+  return { eventActivity, activityRecord, ancestorIds, lifecycleReferences };
+}
+
+// src/runtime/work-log.ts
+var order = (a, b) => b.createdAt - a.createdAt || a.id.localeCompare(b.id);
+var KanbanWorkLog = class {
+  constructor(fs, options = {}) {
+    this.options = options;
+    this.projection = createWorkLogProjection(options);
+    this.log = (event) => options.diagnostic?.(event);
+    this.store = new KanbanWorkLogStore(fs, options.directory, (options.references ?? defaultReferences).execution);
+  }
+  store;
+  projection;
+  log;
+  open() {
+    return this.store.open();
+  }
+  async synchronize(boardId, source) {
+    const started = Date.now(), operationId = randomUUID();
+    try {
+      let after = await this.store.checkpoint(boardId);
+      const [page, snapshot] = await Promise.all([source.events(boardId, after, 500), this.store.needsSnapshot(boardId)]);
+      if (!page.length && !snapshot) return;
+      const board = { id: boardId }, items = await allItems(source, boardId);
+      let events = page;
+      const seenReferences = /* @__PURE__ */ new Set();
+      while (events.length) {
+        const records = events.flatMap((event) => {
+          if (event.data.reference && event.itemId) seenReferences.add(JSON.stringify([event.itemId, event.data.reference.system, event.data.reference.id]));
+          const activity = this.projection.eventActivity(event);
+          if (!activity || !event.itemId) return [];
+          const item = items.find((item2) => item2.id === event.itemId), reference = event.data.reference;
+          const snapshot2 = item && event.data.itemTitle ? { ...item, title: event.data.itemTitle } : item;
+          const key = factKey(activity, reference ? [reference] : [], event.itemId, "event:" + event.sequence, this.options.references ?? defaultReferences);
+          return [this.projection.activityRecord(board, snapshot2, key, event.at, activity, reference ? [reference] : this.projection.lifecycleReferences(item?.externalRefs), event.data.message, this.projection.ancestorIds(item, items))];
+        });
+        const through = events.at(-1).sequence;
+        await this.store.commit(boardId, after, through, records);
+        after = through;
+        if (events.length < 500) break;
+        events = await source.events(boardId, after, 500);
+      }
+      if (snapshot) await this.store.snapshot(boardId, await workLogSnapshots(boardId, source, items, seenReferences, this.projection));
+      this.log({ operationId, boardId, stage: "work-log.project", result: "success", durationMs: Date.now() - started });
+    } catch (error) {
+      const code = error?.code;
+      this.log({ operationId, boardId, stage: "work-log.project", result: "failure", code: code && /^[A-Z_]{1,80}$/.test(code) ? code : "WORK_LOG_PROJECTION_FAILED", durationMs: Date.now() - started });
+      throw error;
+    }
+  }
+  async append(source, boardId, itemId, fact) {
+    requireValue(/^[a-z][a-z0-9.-]{0,79}$/.test(fact.stage) && ["success", "failure", "cancelled"].includes(fact.result), "INVALID_WORK_LOG");
+    const board = { id: boardId }, items = await allItems(source, boardId), item = items.find((item2) => item2.id === itemId);
+    requireValue(item, "ITEM_NOT_FOUND");
+    const { references = [], summary, ...activity } = fact;
+    const id = factKey(activity, references, itemId, fact.dispatchId ?? itemId, this.options.references ?? defaultReferences);
+    const record = this.projection.activityRecord(board, item, id, Date.now(), activity, references, summary, this.projection.ancestorIds(item, items));
+    await this.store.append(boardId, record);
+    await this.options.onRecord?.({ boardId, itemId, record });
+  }
+  async record(source, boardId, id) {
+    if (!id.startsWith("activity-")) return source.record(boardId, id);
+    await source.records(boardId, { limit: 1 });
+    await this.synchronize(boardId, source);
+    return await this.store.record(boardId, id) ?? source.record(boardId, id);
+  }
+  async records(source, boardId, query = {}) {
+    if (query.kind === "decision" || query.status && query.status !== "confirmed") return source.records(boardId, query);
+    await this.synchronize(boardId, source);
+    const { cursor, limit = 50, ...filter } = query, fingerprint = sha256HexSync(JSON.stringify({ ...filter, limit }));
+    requireValue(Number.isSafeInteger(limit) && limit > 0 && limit <= 200, "INVALID_LIMIT");
+    const saved = parseCursor(cursor, boardId, fingerprint);
+    const manual = await source.records(boardId, { ...filter, limit: 200 });
+    const automatic = await this.store.page(boardId, query.itemId, saved?.automatic ?? 0, limit);
+    if (saved && (saved.revision !== manual.revision || saved.logRevision !== automatic.revision)) throw new KanbanError("CURSOR_STALE");
+    const remaining = manual.items.slice(saved?.manual ?? 0), autoIds = new Set(automatic.items.map((item) => item.id));
+    const items = [...remaining, ...automatic.items].sort(order).slice(0, limit);
+    const usedAuto = items.filter((item) => autoIds.has(item.id)).length, usedManual = items.length - usedAuto;
+    const next = {
+      version: 1,
+      board: boardId,
+      query: fingerprint,
+      revision: manual.revision,
+      logRevision: automatic.revision,
+      manual: (saved?.manual ?? 0) + usedManual,
+      automatic: (saved?.automatic ?? 0) + usedAuto
+    };
+    return {
+      revision: manual.revision,
+      total: manual.total + automatic.total,
+      items,
+      ...next.manual < manual.total || next.automatic < automatic.total ? { nextCursor: JSON.stringify(next) } : {}
+    };
+  }
+};
+async function allItems(source, board) {
+  const items = [];
+  let cursor;
+  do {
+    const page = await source.query(board, { view: "all", limit: 200, ...cursor ? { cursor } : {} });
+    items.push(...page.items);
+    cursor = page.nextCursor;
+  } while (cursor);
+  return items;
+}
+function parseCursor(cursor, board, query) {
+  if (!cursor) return;
+  let value;
+  try {
+    value = JSON.parse(cursor);
+  } catch {
+    throw new KanbanError("INVALID_CURSOR");
+  }
+  requireValue(value?.version === 1 && value.board === board && value.query === query, "CURSOR_SCOPE_MISMATCH");
+  requireValue([value.manual, value.automatic, value.revision, value.logRevision].every((value2) => Number.isSafeInteger(value2) && value2 >= 0), "INVALID_CURSOR");
+  return value;
+}
+function factKey(activity, refs, itemId, fallback, systems) {
+  const tree = refs.find((ref2) => ref2.system === systems.workspace);
+  if (tree && activity.stage === "worktree.prepared") return `${tree.id}:worktree.prepared`;
+  if (activity.dispatchId) return `${activity.dispatchId}:${activity.stage}:${activity.code ?? ""}${["execution.running", "execution.unknown"].includes(activity.stage) && fallback.startsWith("event:") ? ":" + fallback : ""}`;
+  const ref = refs.find((ref2) => [systems.nativeExecution, systems.execution].includes(ref2.system));
+  return ref ? JSON.stringify([itemId, activity.stage, ref.system, ref.id]) : fallback;
+}
+
+// src/runtime/journal-command.ts
+async function journalCommand(journal, service, boardId, key, command) {
+  if ((await journal.get(key))?.done) return;
+  const board = await service.read(boardId);
+  const entry = await journal.update(key, (old) => old ?? { request: { operationId: randomUUID(), expectedRevision: board.revision, command } });
+  if (entry.done) return;
+  try {
+    await service.execute(boardId, entry.request);
+  } catch (error) {
+    if (error instanceof KanbanError && error.code === "REVISION_CONFLICT") {
+      const latest = await service.read(boardId);
+      await journal.update(key, (old) => old?.request.operationId !== entry.request.operationId || old.done ? old : {
+        request: { ...entry.request, operationId: randomUUID(), expectedRevision: latest.revision }
+      });
+    }
+    throw error;
+  }
+  await journal.update(key, (old) => ({ ...old, done: true }));
+}
+
+// src/runtime/record-controls.ts
+var recordControlKey = (board, record) => "record-control:" + JSON.stringify([board, record]);
+async function advanceRecordControl(service, journal, run, control) {
+  const ids = /* @__PURE__ */ new Set([run.rootItemId, ...run.itemIds ?? []]);
+  let board;
+  try {
+    board = await service.read(run.boardId);
+  } catch (error) {
+    if (control.action === "cancel" && error.code === "BOARD_NOT_FOUND") return "cancelled";
+    throw error;
+  }
+  let items = board.items.filter((item) => ids.has(item.id));
+  for (let index = 0; index < board.items.length; index++) {
+    const children = board.items.filter((item) => ids.has(item.planning?.parentId));
+    if (children.every((item) => ids.has(item.id))) break;
+    for (const child of children) ids.add(child.id);
+  }
+  items = board.items.filter((item) => ids.has(item.id));
+  for (const item of items.filter((item2) => !["completed", "cancelled"].includes(item2.status))) await requestItemControl(service, journal, run, control, item);
+  const latest = await service.read(run.boardId), active = latest.items.filter((item) => ids.has(item.id) && !["completed", "cancelled"].includes(item.status));
+  if (control.action === "cancel") return active.length ? "cancelling" : "cancelled";
+  const managed = active.filter((item) => control.controls[item.id]);
+  if (managed.some((item) => item.control?.state === "unknown")) return "unknown";
+  if (managed.some((item) => item.control?.state === "failed")) return "blocked";
+  const target = control.action === "pause" ? "paused" : "resumed";
+  return managed.every((item) => item.control?.state === target) ? control.action === "pause" ? "paused" : "running" : control.action === "pause" ? "pausing" : "resuming";
+}
+async function requestItemControl(service, journal, run, control, item) {
+  const action = control.action, controlId = sha256HexSync(JSON.stringify([run.sourceBoardId, run.recordId, control.operationId, run.boardId, item.id, action]));
+  if (item.control?.id !== controlId) {
+    if (action === "resume" && (!control.controls[item.id] || item.control?.id !== control.controls[item.id])) return;
+    if (action === "pause" && item.control?.action === "pause") return;
+    await journalCommand(
+      journal,
+      service,
+      run.boardId,
+      "record-control-item:" + controlId,
+      { type: "request-control", itemId: item.id, controlId, action }
+    );
+  }
+  const saved = await journal.update(recordControlKey(run.sourceBoardId, run.recordId), (old) => ({ ...old, controls: { ...old.controls, [item.id]: controlId } }));
+  control.controls = saved.controls;
+}
+async function requestRecordControl(service, journal, boardId, request) {
+  requireValue(/^[\w-]{1,128}$/.test(request.operationId) && ["pause", "resume", "cancel"].includes(request.action), "INVALID_RECORD_CONTROL");
+  const board = await service.read(boardId), actor = await service.currentPrincipal(), record = await service.record(boardId, request.recordId);
+  requireValue(actor.kind === "human" && board.members?.some((m) => m.kind === actor.kind && m.id === actor.id && m.roles?.includes("coordinator")), "COORDINATOR_REQUIRED");
+  requireValue(record.kind === "decision" && record.deletedAt === void 0, "DECISION_REQUIRED");
+  await journal.update(recordControlKey(boardId, record.id), (old) => {
+    if (old?.operationId === request.operationId) {
+      requireValue(old.action === request.action, "IDEMPOTENCY_CONFLICT");
+      return old;
+    }
+    requireValue(!old || old.action !== "cancel", "RECORD_CANCELLING");
+    requireValue(request.action !== "resume" || old?.action === "pause", "TASK_NOT_PAUSED");
+    return { boardId, recordId: record.id, operationId: request.operationId, action: request.action, controls: old?.controls ?? {} };
+  });
+  if (request.action === "cancel") await journalCommand(journal, service, boardId, "record-cancelling:" + JSON.stringify([boardId, record.id, request.operationId]), { type: "request-record-cancellation", recordId: record.id });
+}
+
+// src/runtime/record-execution.ts
+function createRecordExecution(options) {
+  let stopped = false;
+  const pending2 = /* @__PURE__ */ new Map();
+  const resume = (run) => {
+    requireValue(!stopped, "SERVICE_STOPPING");
+    let job = pending2.get(run.id);
+    if (!job) {
+      job = advance(options, run).finally(() => {
+        pending2.delete(run.id);
+      });
+      pending2.set(run.id, job);
+    }
+    return job;
+  };
+  return {
+    itemResources: async (boardId, parentId) => {
+      const board = await options.service.read(boardId), parent = parentId ? (await options.service.item(boardId, parentId)).item : void 0;
+      const refs = parent?.externalRefs?.filter((ref) => ref.system === options.resources.system) ?? [];
+      const resources = await options.resources.list();
+      return { resources, selected: refs.length === 1 ? refs[0] : void 0, readonly: refs.length === 1, required: refs.length === 1 || options.requiresItemResource?.(board) === true };
+    },
+    recordResources: async () => await options.resources.list(),
+    runRecord: async (boardId, request) => {
+      requireValue(!stopped, "SERVICE_STOPPING");
+      const started = Date.now(), operationId = sha256HexSync(JSON.stringify([boardId, request.operationId]));
+      let run;
+      try {
+        run = await prepare(options, boardId, request);
+        options.log({ operationId, boardId, stage: "record.prepare", result: "success", durationMs: Date.now() - started });
+      } catch (error) {
+        options.log({ operationId, boardId, stage: "record.prepare", result: "failure", code: safeCode(error, "RECORD_PREPARATION_FAILED"), durationMs: Date.now() - started });
+        throw error;
+      }
+      return resume(run);
+    },
+    controlRecord: async (boardId, request) => {
+      await requestRecordControl(options.service, options.journal, boardId, request);
+      for (const run of await options.journal.get("record-runs:" + boardId) ?? []) if (run.recordId === request.recordId) {
+        await pending2.get(run.id)?.catch(() => {
+        });
+        await resume(run);
+      }
+      const runs = (await options.journal.get("record-runs:" + boardId) ?? []).filter((run) => run.recordId === request.recordId);
+      if (request.action === "cancel" && runs.every((run) => ["completed", "failed", "cancelled"].includes(run.state))) await finishDecisionCancellation(options, boardId, request.recordId, request.operationId);
+    },
+    recordExecutions: async (boardId, recordId) => {
+      await options.service.record(boardId, recordId);
+      const runs = await options.journal.get("record-runs:" + boardId) ?? [];
+      return runs.filter((run) => run.recordId === recordId).map(view);
+    },
+    async scan() {
+      if (stopped) return;
+      const errors = [];
+      for (const board of await options.service.catalog()) {
+        if (stopped) return;
+        for (const run of await options.journal.get("record-runs:" + board.id) ?? []) {
+          if (stopped) return;
+          if (!["completed", "failed", "cancelled"].includes(run.state)) {
+            try {
+              await resume(run);
+            } catch (error) {
+              errors.push(error);
+            }
+          }
+        }
+      }
+      for (const row of await options.journal.find("record-control:", (value) => value.action === "cancel" && !value.settled)) {
+        if (!row.value.boardId || !row.value.recordId) continue;
+        try {
+          await finishDecisionCancellation(options, row.value.boardId, row.value.recordId, row.value.operationId);
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      if (errors.length) throw new AggregateError(errors, "RECORD_EXECUTION_SCAN_FAILED");
+    },
+    async quiesce() {
+      stopped = true;
+      await Promise.allSettled([...pending2.values()]);
+    }
+  };
+}
+async function validateResourceReferences(resources, record) {
+  const refs = record.externalRefs?.filter((ref) => ref.system === resources.system) ?? [];
+  requireValue(refs.length <= 16 && new Set(refs.map((ref) => ref.id)).size === refs.length, "INVALID_RESOURCE_SELECTION");
+  await resources.validate(refs);
+}
+async function prepare(options, boardId, request) {
+  requireValue(typeof request.operationId === "string" && /^[a-zA-Z0-9_-]{1,128}$/.test(request.operationId), "INVALID_OPERATION_ID");
+  requireValue(!(await options.service.read(boardId)).lifecycle, "BOARD_STOPPING");
+  const record = await options.service.record(boardId, request.recordId);
+  const control = await options.journal.get(recordControlKey(boardId, record.id));
+  requireValue(record.deletedAt === void 0 && (!control || control.action === "resume" && control.settled), "RECORD_CONTROL_ACTIVE");
+  const frozen = await options.journal.get("record-operation:" + request.operationId);
+  if (frozen) {
+    requireValue(frozen.sourceBoardId === boardId && frozen.recordId === request.recordId && (frozen.requestRevision ?? frozen.recordRevision) === request.expectedRevision && (!frozen.placement || frozen.placement === (request.placement ?? "current-board")), "IDEMPOTENCY_CONFLICT");
+    const current = (await options.journal.get("record-runs:" + boardId))?.find((run) => run.id === frozen.id);
+    requireValue(current, "RECORD_EXECUTION_CHECKPOINT_MISSING");
+    return freezeOperation(options, request, current);
+  }
+  requireValue(record.kind === "decision" && record.status === "confirmed", "DECISION_NOT_CONFIRMED");
+  requireValue(record.revision === request.expectedRevision, "REVISION_CONFLICT");
+  const board = await options.service.read(boardId);
+  requireValue(board.automation, "AUTOMATION_BINDING_REQUIRED");
+  await validateResourceReferences(options.resources, record);
+  requireValue(record.externalRefs?.some((ref) => ref.system === options.resources.system), "REMOTE_PROJECT_REQUIRED");
+  const id = sha256HexSync(JSON.stringify([boardId, record.id, record.revision]));
+  const placement = request.placement ?? "current-board";
+  requireValue(["current-board", "new-board"].includes(placement), "INVALID_EXECUTION_PLACEMENT");
+  const saved = await options.journal.update("record-runs:" + boardId, (previous) => {
+    requireValue(!previous?.some((row) => row.recordId === record.id && row.state === "completed"), "DECISION_EXECUTION_COMPLETED");
+    const same = previous?.find((row) => row.id === id || row.recordId === record.id && decisionSignature(row.record) === decisionSignature(record));
+    if (same) {
+      requireValue(!same.placement || same.placement === placement, "DECISION_EXECUTION_PLACEMENT_CONFLICT");
+      return previous;
+    }
+    requireValue(!previous?.some((row) => row.recordId === record.id && !["completed", "failed"].includes(row.state)), "DECISION_EXECUTION_UNSETTLED");
+    requireValue((previous?.length ?? 0) < 100, "RECORD_EXECUTION_LIMIT");
+    return [...previous ?? [], newRun(board, record, request, id, options.resources.system)];
+  });
+  await options.journal.update("record-context:" + id, (old) => old ?? { sourceBoardId: boardId, recordId: record.id, recordRevision: record.revision, runId: id });
+  const original = saved.find((row) => row.id === id || row.recordId === record.id && decisionSignature(row.record) === decisionSignature(record));
+  return freezeOperation(options, request, original);
+}
+async function freezeOperation(options, request, run) {
+  await options.journal.update("record-operation:" + request.operationId, (previous) => {
+    requireValue(!previous || previous.id === run.id && (previous.requestRevision ?? previous.recordRevision) === request.expectedRevision && (!previous.placement || previous.placement === (request.placement ?? "current-board")), "IDEMPOTENCY_CONFLICT");
+    return {
+      schema: 2,
+      id: run.id,
+      sourceBoardId: run.sourceBoardId,
+      recordId: run.recordId,
+      recordRevision: run.recordRevision,
+      requestRevision: request.expectedRevision,
+      ...run.placement ? { placement: run.placement } : {}
+    };
+  });
+  return run;
+}
+async function advance(options, run) {
+  const started = Date.now();
+  try {
+    const control = await options.journal.get(recordControlKey(run.sourceBoardId, run.recordId));
+    if (control && !control.settled) {
+      const state2 = await advanceRecordControl(options.service, options.journal, run, control);
+      const updated2 = await save(options, { ...run, state: state2, updatedAt: Date.now() });
+      if (state2 !== run.state) options.log({ operationId: control.operationId, boardId: run.sourceBoardId, stage: "record.control." + control.action, result: state2 === "unknown" || state2 === "blocked" ? "failure" : "success", code: updated2.code, durationMs: Date.now() - started });
+      if (control.action === "resume" && state2 === "running") {
+        const runs = await options.journal.get("record-runs:" + run.sourceBoardId);
+        if (runs?.filter((row) => row.recordId === run.recordId).every((row) => ["running", "completed", "failed", "cancelled"].includes(row.state))) await options.journal.update(recordControlKey(run.sourceBoardId, run.recordId), (old) => ({ ...old, settled: true }));
+      }
+      if (state2 === "cancelled") {
+        const runs = await options.journal.get("record-runs:" + run.sourceBoardId);
+        if (runs?.filter((row) => row.recordId === run.recordId).every((row) => ["completed", "failed", "cancelled"].includes(row.state))) await finishDecisionCancellation(options, run.sourceBoardId, run.recordId, control.operationId);
+      }
+      return view(updated2);
+    }
+    await validateResourceReferences(options.resources, run.record);
+    await materialize(options, run);
+    const board = await options.service.read(run.boardId);
+    const items = run.itemIds ? await Promise.all(run.itemIds.map(async (id) => board.items.find((item) => item.id === id) ?? (await options.service.item(run.boardId, id)).item)) : board.items;
+    const state = runState(items);
+    if (state === "completed" && run.rootItemId && !run.itemIds?.includes(run.rootItemId) && board.items.find((item) => item.id === run.rootItemId)?.status !== "completed") {
+      await once(options, run, "close-root", { type: "close-plan", itemId: run.rootItemId, resultRef: "kanban-run:" + run.id });
+    }
+    const code = state === "failed" ? "DECISION_TASK_CANCELLED" : void 0;
+    if (run.state === state && run.code === code) return view(run);
+    const updated = await save(options, { ...run, state, code, updatedAt: Date.now() });
+    options.log({ operationId: run.id, boardId: run.sourceBoardId, stage: "record.run", result: state === "failed" ? "failure" : "success", code: updated.code, durationMs: Date.now() - started });
+    return view(updated);
+  } catch (error) {
+    const code = safeCode(error, "RECORD_EXECUTION_FAILED");
+    if (code === "SERVICE_STOPPING") throw error;
+    await save(options, { ...run, state: "blocked", code, updatedAt: Date.now() });
+    options.log({ operationId: run.id, boardId: run.sourceBoardId, stage: "record.run", result: "failure", code, durationMs: Date.now() - started });
+    throw error;
+  }
+}
+function decisionSignature(record) {
+  return sha256HexSync(JSON.stringify([record.title, record.content, record.rationale, record.externalRefs]));
+}
+function newRun(board, record, request, id, resourceSystem) {
+  const placement = request.placement ?? "current-board";
+  requireValue(["current-board", "new-board"].includes(placement), "INVALID_EXECUTION_PLACEMENT");
+  requireValue(placement === "new-board" || board.automation?.enabled, "AUTOMATION_PAUSED");
+  const refs = record.externalRefs.filter((ref) => ref.system === resourceSystem);
+  const types = board.workTypes ?? DEFAULT_KANBAN_WORK_TYPES;
+  const task = types.find((type) => type.id === (board.defaultWorkType ?? "task") && type.executable) ?? types.find((type) => type.executable);
+  const parent = types.filter((type) => !type.executable && type.rank < (task?.rank ?? 0)).sort((a, b) => b.rank - a.rank)[0];
+  requireValue(task && (refs.length === 1 || parent), "DECISION_WORK_TYPES_REQUIRED");
+  const itemIds = refs.map((_, index) => "work-" + id + "-" + index);
+  return {
+    id,
+    sourceBoardId: board.id,
+    recordId: record.id,
+    recordRevision: record.revision,
+    boardId: placement === "new-board" ? "run-" + id : board.id,
+    placement,
+    taskKind: task.id,
+    parentKind: parent?.id,
+    rootItemId: refs.length === 1 ? itemIds[0] : "feature-" + id,
+    itemIds,
+    state: "preparing",
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    record,
+    automation: structuredClone(board.automation)
+  };
+}
+function runState(items) {
+  if (items.some((item) => item.status === "cancelled")) return "failed";
+  if (items.length && items.every((item) => item.status === "completed")) return "completed";
+  if (items.some((item) => item.blocked)) return "blocked";
+  return items.length && items.every((item) => ["completed", "review"].includes(item.status)) ? "review" : "running";
+}
+async function materialize(options, run) {
+  if (run.boardId !== run.sourceBoardId) {
+    const actor = await options.service.currentPrincipal(), source = await options.service.read(run.sourceBoardId);
+    await options.service.create({
+      id: run.boardId,
+      title: run.record.title,
+      scope: { kind: "collection", namespace: "decision-run", id: run.id },
+      members: [{ ...actor, responsibility: "Review decision execution", roles: ["coordinator", "reviewer", "worker"] }],
+      ...run.placement && source.workTypes ? { workTypes: source.workTypes, defaultWorkType: source.defaultWorkType } : {},
+      policy: { requireEstimate: false, review: "independent" }
+    });
+  }
+  const refs = run.record.externalRefs.filter((ref) => ref.system === options.resources.system);
+  const group = !!run.rootItemId && !run.itemIds?.includes(run.rootItemId);
+  if (group) await once(options, run, "root", {
+    type: "create-item",
+    item: {
+      id: run.rootItemId,
+      title: run.record.title,
+      responsibility: run.record.content,
+      acceptance: run.record.rationale ?? run.record.content
+    },
+    planning: { kind: run.parentKind, priority: 2, dependencies: [], references: [] }
+  });
+  for (const [index, reference] of refs.entries()) {
+    await once(options, run, "item-" + index, {
+      type: "create-item",
+      item: {
+        id: run.itemIds?.[index] ?? "work-" + index,
+        title: run.record.title,
+        responsibility: run.record.content,
+        acceptance: run.record.rationale ?? run.record.content,
+        externalRefs: [reference, { system: options.resources.decisionSystem ?? "kanban-decision", id: run.id }]
+      },
+      ...run.taskKind ? { planning: { kind: run.taskKind, priority: 2, dependencies: [], references: [], ...group ? { parentId: run.rootItemId } : {} } } : {}
+    });
+  }
+  if (run.boardId !== run.sourceBoardId) await once(options, run, "automation", { type: "configure-automation", settings: { ...run.automation, enabled: true, autoAccept: false } });
+  if (run.rootItemId && run.boardId === run.sourceBoardId) await once(options, run, "link-root", { type: "link-record", recordId: run.recordId, itemId: run.rootItemId });
+}
+async function once(options, run, stage, command) {
+  const key = "record-stage:" + run.id + ":" + stage;
+  await journalCommand(options.journal, options.service, run.boardId, key, command);
+}
+async function save(options, run) {
+  const rows = await options.journal.update("record-runs:" + run.sourceBoardId, (previous) => {
+    const current = previous ?? [];
+    requireValue(current.some((row) => row.id === run.id), "RECORD_EXECUTION_CHECKPOINT_MISSING");
+    return current.map((row) => row.id !== run.id || row.state === run.state && row.code === run.code ? row : run);
+  });
+  return rows.find((row) => row.id === run.id);
+}
+function view(run) {
+  const { id, recordId, recordRevision, boardId, rootItemId, itemIds, state, createdAt, updatedAt, code } = run;
+  return { id, recordId, recordRevision, boardId, ...rootItemId ? { rootItemId, itemIds } : {}, state, createdAt, updatedAt, ...code ? { code } : {} };
+}
+async function cancelDecision(options, boardId, recordId, operationId) {
+  const record = await options.service.record(boardId, recordId);
+  if (record.status !== "cancelled") await journalCommand(options.journal, options.service, boardId, "record-cancel:" + JSON.stringify([boardId, recordId, operationId]), { type: "cancel-record", recordId });
+  await options.journal.update(recordControlKey(boardId, recordId), (old) => ({ ...old, settled: true }));
+}
+async function finishDecisionCancellation(options, boardId, recordId, operationId) {
+  const runs = (await options.journal.get("record-runs:" + boardId) ?? []).filter((run) => run.recordId === recordId);
+  if (runs.some((run) => !["completed", "failed", "cancelled"].includes(run.state))) return;
+  const record = await options.service.record(boardId, recordId);
+  const control = await options.journal.get(recordControlKey(boardId, recordId));
+  requireValue(control, "RECORD_CONTROL_ACTIVE");
+  const state = await advanceRecordControl(options.service, options.journal, { id: operationId, sourceBoardId: boardId, boardId, recordId, recordRevision: record.revision, itemIds: record.itemIds, state: "cancelling", createdAt: 0, updatedAt: 0 }, control);
+  if (state === "cancelled") await cancelDecision(options, boardId, recordId, operationId);
+}
+
+// src/runtime/analysis-aggregation.ts
+async function completeCompositePlans(service, journal, boardId, serviceFor) {
+  const workflow = await service.workflow(boardId), boardSnapshot = await service.read(boardId);
+  const roots = new Set(boardSnapshot.items.filter((item) => item.planning?.execution === "children").map((item) => item.id));
+  for (const id of roots) {
+    const board = await service.read(boardId), parent = board.items.find((item) => item.id === id);
+    if (!board.automation || !parent || parent.control?.action === "cancel" || parent.owner || parent.blocked || parent.planning?.execution !== "children" || !["backlog", "open"].includes(parent.status)) continue;
+    if (!await childrenCompleted(service, boardId, id)) continue;
+    await journalCommand(
+      journal,
+      serviceFor(board.automation.coordinator),
+      boardId,
+      "aggregate-complete:" + id,
+      { type: "close-plan", itemId: id, resultRef: "kanban:plans:" + JSON.stringify(Object.values(workflow.plans).filter((plan) => plan.rootItemId === id).map((plan) => plan.id)) }
+    );
+  }
+}
+async function childrenCompleted(service, boardId, parentId) {
+  let cursor, count = 0;
+  do {
+    const page = await service.query(boardId, { view: "all", parentId, limit: 200, cursor });
+    if (page.items.some((item) => item.status !== "completed")) return false;
+    count += page.items.length;
+    cursor = page.nextCursor;
+  } while (cursor);
+  return count > 0;
+}
+
+// src/runtime/analysis-decomposition.ts
+function validateSubtasks(value) {
+  if (value === void 0) return;
+  requireValue(Array.isArray(value) && value.length >= 2 && value.length <= 16, "AUTOMATION_SUBTASKS_INVALID");
+  const tasks = value, keys = new Set(tasks.map((task) => task?.key));
+  requireValue(keys.size === tasks.length, "AUTOMATION_SUBTASKS_INVALID");
+  for (const task of tasks) {
+    requireValue(task && typeof task.key === "string" && /^[a-zA-Z0-9_-]{1,64}$/.test(task.key) && [task.title, task.responsibility, task.acceptance].every((text) => typeof text === "string" && text.trim().length > 0 && text.length <= 8e3), "AUTOMATION_SUBTASKS_INVALID");
+    requireValue(Array.isArray(task.dependsOn) && task.dependsOn.length <= 16 && new Set(task.dependsOn).size === task.dependsOn.length && task.dependsOn.every((key) => keys.has(key) && key !== task.key), "AUTOMATION_SUBTASK_DEPENDENCY_INVALID");
+    if (task.estimate) requireValue(["low", "medium", "high"].includes(task.estimate.confidence) && [task.estimate.complexity, task.estimate.workUnits, task.estimate.durationMs].every((number) => Number.isFinite(number) && number > 0), "AUTOMATION_ESTIMATE_INVALID");
+  }
+  const pending2 = [...tasks], done2 = /* @__PURE__ */ new Set();
+  while (pending2.length) {
+    const index = pending2.findIndex((task) => task.dependsOn.every((key) => done2.has(key)));
+    requireValue(index >= 0, "DEPENDENCY_CYCLE");
+    done2.add(pending2.splice(index, 1)[0].key);
+  }
+  return tasks;
+}
+async function adoptDecomposition(journal, board, parent, input, service, inherited = []) {
+  const types = board.workTypes ?? DEFAULT_KANBAN_WORK_TYPES, parentRank = types.find((type2) => type2.id === (parent.planning?.kind ?? board.defaultWorkType ?? "task"))?.rank;
+  const type = types.filter((type2) => type2.executable && parentRank !== void 0 && type2.rank > parentRank).sort((a, b) => a.rank - b.rank)[0];
+  requireValue(type, "AUTOMATION_SUBTASK_TYPE_UNAVAILABLE");
+  const ids = new Map(input.subtasks.map((task) => [task.key, "sub-" + sha256HexSync(JSON.stringify([input.id, task.key])).slice(0, 40)]));
+  const definitions = input.subtasks.map((task) => ({
+    id: ids.get(task.key),
+    workType: type.id,
+    title: task.title,
+    responsibility: task.responsibility,
+    acceptance: task.acceptance,
+    assignee: board.automation.worker,
+    externalRefs: inherited,
+    dependsOn: [.../* @__PURE__ */ new Set([...input.dependencies, ...task.dependsOn.map((key) => ids.get(key))])],
+    outputs: ["result"]
+  }));
+  for (const [index, definition] of definitions.entries()) {
+    const estimate = input.subtasks[index].estimate;
+    requireValue(board.policy.requireEstimate === false || estimate, "ESTIMATE_REQUIRED");
+    if (estimate) await journal.update("decomposition-estimate:" + JSON.stringify([board.id, definition.id]), (old) => old ?? estimate);
+    await journal.update("decomposition-status:" + JSON.stringify([board.id, definition.id]), (old) => old ?? { itemId: definition.id, state: "ready", reason: input.reason, dependencies: definition.dependsOn });
+  }
+  await service.execute(board.id, { operationId: "analysis-plan:" + input.id, expectedRevision: board.revision, command: { type: "publish-plan", plan: {
+    schema: "kanban.plan/1",
+    id: input.id,
+    revision: 1,
+    sealed: true,
+    rootItemId: parent.id,
+    items: definitions
+  } } });
+}
+
+// src/runtime/analysis.ts
+var keyFor = (board, item) => "analysis-current:" + JSON.stringify([board, item]);
+async function analysisStatus(journal, board, item) {
+  const key = await journal.get(keyFor(board, item));
+  return key ? (await journal.get(key))?.status ?? null : await journal.get("decomposition-status:" + JSON.stringify([board, item])) ?? null;
+}
+function analysisSignature(board) {
+  return sha256HexSync(JSON.stringify([board.automation, board.items.map((item) => [item.id, item.title, item.responsibility, item.acceptance, item.planning])]));
+}
+async function analyzeItem(options, board, item, target, service) {
+  const started = Date.now();
+  if (!options.active()) return;
+  const loaded = await loadJob(options, board, item, target);
+  if (!loaded || !options.active()) return;
+  const { key } = loaded;
+  let { job } = loaded;
+  if (job.phase === "prepared") job = await submitAnalysis(options, key, job);
+  if (!options.active()) return;
+  if (job.phase === "submitting") job = await observeAnalysis(options, key, job);
+  job = await finalizeAnalysis(options, board.id, item, key, job);
+  if (job.result?.ready && job.status.state === "ready" && !board.executionControl?.paused && board.automation?.enabled && options.active()) {
+    try {
+      await adoptAnalysis(options.journal, board, item, job, service, options.inheritReferences?.(item.externalRefs ?? []) ?? []);
+    } catch (error) {
+      await saveFailure(options, key, job, safeCode(error, "AUTOMATION_PLAN_REJECTED"));
+    }
+  }
+  if (!options.active()) return;
+  const status = (await options.journal.get(key))?.status;
+  if (status) {
+    const currentBoard = await service.read(board.id), currentItem = currentBoard.items.find((i) => i.id === item.id);
+    if (currentItem.control?.action === "cancel" || ["completed", "cancelled"].includes(currentItem.status)) return;
+    if (JSON.stringify(currentItem.analysis) !== JSON.stringify(status)) await service.execute(board.id, { operationId: "analysis-status:" + job.id + ":" + sha256HexSync(JSON.stringify(status)), expectedRevision: currentBoard.revision, command: { type: "report-analysis", itemId: item.id, operationId: job.id, status } });
+  }
+  options.log({ operationId: job.id, stage: "automation.analysis", result: status?.state === "failed" || status?.state === "unknown" ? "failure" : "success", code: status?.code, durationMs: Date.now() - started });
+}
+async function finalizeAnalysis(options, boardId, item, key, job) {
+  if (!options.active() || job.phase !== "settled" || !options.onSettled) return job;
+  try {
+    await options.onSettled({
+      boardId,
+      id: job.id,
+      item,
+      request: job.input,
+      outcome: job.terminalOutcome ?? (job.status.state === "failed" ? "failed" : "succeeded"),
+      code: job.status.code
+    });
+    return job;
+  } catch (error) {
+    return options.active() ? saveFailure(options, key, job, safeCode(error, "AUTOMATION_ANALYSIS_FINALIZATION_FAILED")) : job;
+  }
+}
+async function loadJob(options, board, item, target) {
+  requireValue(board.items.length <= 200, "AUTOMATION_CONTEXT_LIMIT");
+  const signature = analysisSignature(board), currentKey = await options.journal.get(keyFor(board.id, item.id));
+  const currentJob = currentKey ? await options.journal.get(currentKey) : void 0;
+  if (!board.automation?.enabled && currentJob?.phase !== "submitting") return;
+  const key = currentJob?.phase === "submitting" ? currentKey : "analysis:" + sha256HexSync(JSON.stringify([board.id, item.id, item.launch?.requestedAt, item.launch?.analysisEpoch, signature]));
+  let job = await options.journal.get(key);
+  if (!job) {
+    requireValue(target, "AUTOMATION_TARGET_CHANGED");
+    const id = await options.journal.update("analysis-identity:" + key, (old) => old ?? randomUUID());
+    const input = await options.port.prepare({ id, board, item, target });
+    const candidate = { id, signature, itemRevision: item.revision, phase: "prepared", status: { itemId: item.id, state: "analyzing" }, input };
+    job = await options.journal.update(key, (previous) => previous ?? candidate);
+  }
+  if (!options.active()) return;
+  if (currentKey !== key) await options.journal.update("analysis-history:" + JSON.stringify([board.id, item.id]), (old) => ({ ...old, keys: [.../* @__PURE__ */ new Set([...old?.keys ?? [], ...currentKey ? [currentKey] : [], key])] }));
+  await options.journal.update(keyFor(board.id, item.id), () => key);
+  if (!options.active()) return;
+  return { key, job };
+}
+async function submitAnalysis(options, key, job) {
+  try {
+    await options.port.prepareExecution(job.id, job.input);
+  } catch (error) {
+    return options.active() ? saveFailure(options, key, job, safeCode(error, "AUTOMATION_ANALYSIS_PREPARE_FAILED")) : job;
+  }
+  if (!options.active()) return job;
+  const claimed = await options.journal.claim(key), latest = await options.journal.get(key);
+  if (!claimed || !options.active()) return latest;
+  try {
+    await options.port.submit(job.input);
+  } catch {
+    return options.active() ? options.journal.update(key, (current) => current.phase === "submitting" ? { ...current, status: { ...job.status, state: "unknown", code: "AUTOMATION_ADMISSION_UNKNOWN" } } : current) : latest;
+  }
+  return latest;
+}
+async function observeAnalysis(options, key, job) {
+  const observation = await options.port.inspect(job.id, job.input);
+  if (!options.active() || observation.state === "running") return job;
+  if (observation.state === "unknown") return options.journal.update(key, (current) => current.phase === "submitting" ? { ...current, status: { ...job.status, state: "unknown", code: observation.code ?? "AUTOMATION_ADMISSION_UNKNOWN" } } : current);
+  if (observation.state === "failed" || observation.state === "cancelled") return saveFailure(options, key, job, observation.code ?? "AUTOMATION_ANALYSIS_FAILED", observation.state);
+  try {
+    requireValue(observation.output !== void 0, "AUTOMATION_ANALYSIS_INVALID");
+    const analysis = parseAnalysis(observation.output);
+    return options.journal.update(key, (current) => ({ ...current, phase: "settled", result: analysis, status: { itemId: job.status.itemId, state: analysis.ready ? "ready" : "clarification", reason: analysis.reason, dependencies: analysis.dependencies } }));
+  } catch (error) {
+    return saveFailure(options, key, job, safeCode(error, "AUTOMATION_ANALYSIS_INVALID"));
+  }
+}
+async function saveFailure(options, key, job, code, terminalOutcome = "failed") {
+  return options.journal.update(key, (current) => ({ ...current, phase: "settled", terminalOutcome, status: { itemId: job.status.itemId, state: "failed", code } }));
+}
+function parseAnalysis(output) {
+  const result = output;
+  requireValue(result && typeof result.ready === "boolean" && typeof result.reason === "string" && result.reason.length > 0 && result.reason.length <= 8e3, "AUTOMATION_ANALYSIS_INVALID");
+  requireValue(Array.isArray(result.dependencies) && result.dependencies.length <= 100 && result.dependencies.every((id) => typeof id === "string" && id.length > 0 && id.length <= 256), "AUTOMATION_DEPENDENCIES_INVALID");
+  if (result.estimate) requireValue(["low", "medium", "high"].includes(result.estimate.confidence) && [result.estimate.complexity, result.estimate.workUnits, result.estimate.durationMs].every((value) => Number.isFinite(value) && value > 0), "AUTOMATION_ESTIMATE_INVALID");
+  const subtasks = validateSubtasks(result.subtasks);
+  return { ready: result.ready, reason: result.reason, dependencies: [...new Set(result.dependencies)], ...subtasks ? { subtasks } : {}, ...result.estimate ? { estimate: result.estimate } : {} };
+}
+async function adoptAnalysis(journal, snapshot, item, job, service, inherited) {
+  if ((await service.workflow(snapshot.id)).plans[job.id]) return;
+  const board = await service.read(snapshot.id), current = board.items.find((candidate) => candidate.id === item.id);
+  requireValue(board.automation?.enabled && current && analysisSignature(board) === job.signature, "AUTOMATION_ANALYSIS_STALE");
+  requireValue(board.policy.requireEstimate === false || job.result?.estimate, "ESTIMATE_REQUIRED");
+  const dependencies = [.../* @__PURE__ */ new Set([...item.planning?.dependencies ?? [], ...job.result.dependencies])];
+  if (job.result?.subtasks?.length) return adoptDecomposition(journal, board, item, { id: job.id, reason: job.result.reason, dependencies, subtasks: job.result.subtasks }, service, inherited);
+  await service.execute(board.id, { operationId: "analysis-plan:" + job.id, expectedRevision: board.revision, command: { type: "publish-plan", plan: {
+    schema: "kanban.plan/1",
+    id: job.id,
+    revision: 1,
+    sealed: true,
+    items: [{
+      id: item.id,
+      title: item.title,
+      responsibility: item.responsibility,
+      acceptance: item.acceptance,
+      expectedRevision: current.revision,
+      assignee: board.automation.worker,
+      dependsOn: dependencies,
+      outputs: ["result"]
+    }]
+  } } });
+}
+
+// src/runtime/automation.ts
+function createKanbanAutomation(options) {
+  let stopped = false, pending2;
+  const bridges = /* @__PURE__ */ new Map();
+  const scan = () => stopped ? Promise.resolve() : pending2 ??= scanBoards(options, bridges, () => !stopped).finally(() => {
+    pending2 = void 0;
+  });
+  return {
+    scan,
+    async quiesce() {
+      stopped = true;
+      await Promise.allSettled([...bridges.values()].map((bridge) => bridge.quiesce()));
+      let timer;
+      try {
+        await Promise.race([pending2?.catch(() => {
+        }), new Promise((resolve) => {
+          timer = setTimeout(resolve, 5e3);
+        })]);
+      } finally {
+        if (timer) clearTimeout(timer);
+        await options.journal.drain();
+      }
+    },
+    automationCatalog: () => {
+      requireValue(!stopped, "SERVICE_STOPPING");
+      return options.catalog();
+    },
+    analysisStatus: async (board, item) => (await options.service.item(board, item)).item.analysis ?? analysisStatus(options.journal, board, item),
+    verifyOutputs: (outputs) => options.journal.verify(outputs)
+  };
+}
+async function scanBoards(options, bridges, active) {
+  const errors = [];
+  for (const entry of await options.service.catalog()) {
+    if (!active()) return;
+    const started = Date.now();
+    try {
+      const board = await options.service.read(entry.id);
+      if (!active()) return;
+      if (!board.automation) {
+        await options.controls?.(board, options.service);
+        continue;
+      }
+      const service = options.serviceFor(board.automation.coordinator);
+      let bridge = bridges.get(board.id);
+      if (!bridge) {
+        bridge = await createBridge(options, board.id);
+        bridges.set(board.id, bridge);
+      }
+      if (!active()) {
+        await bridge.quiesce();
+        return;
+      }
+      await options.controls?.(board, service);
+      if (!active()) return;
+      await bridge.scan();
+      if (!active()) return;
+      await options.drain?.(await service.read(board.id), service);
+      await planNext(options, await service.read(board.id), active);
+      if (active()) await bridge.scan();
+      if (active()) await completeCompositePlans(options.service, options.journal, board.id, options.serviceFor);
+      options.log({ operationId: board.id, boardId: board.id, stage: "automation.scan", result: "success", durationMs: Date.now() - started });
+    } catch (error) {
+      errors.push(error);
+      options.log({ operationId: entry.id, boardId: entry.id, stage: "automation.scan", result: "failure", code: safeCode(error, "AUTOMATION_SCAN_FAILED"), durationMs: Date.now() - started });
+    }
+  }
+  if (errors.length) throw new AggregateError(errors, "KANBAN_AUTOMATION_FAILED");
+}
+async function planNext(options, board, active) {
+  if (!options.analyze) return;
+  const workflow = await options.service.workflow(board.id), planned = new Set(Object.values(workflow.plans).flatMap((plan) => plan.itemIds));
+  const candidates = board.items.filter((item) => !planned.has(item.id) && ["backlog", "open"].includes(item.status) && !item.owner && !item.blocked && boardAllowsStart(board, item) && !["failed", "clarification"].includes(item.analysis?.state ?? "") && executableWorkItem(board, item) && (!item.control || item.control.action === "resume" && item.control.state === "resumed") && (item.launch?.admittedAt !== void 0 || taskDue(item, Date.now())));
+  for (const item of candidates) {
+    if (!active()) return;
+    if (!await dependenciesComplete(options.service, board, item)) continue;
+    const service = options.serviceFor(board.automation.coordinator);
+    if (item.launch?.admittedAt === void 0) {
+      if (!await admit(options, board, item, service)) return;
+      board = await service.read(board.id);
+      Object.assign(item, board.items.find((row) => row.id === item.id));
+    }
+    try {
+      await options.analyze(board, item, service, active);
+    } catch (error) {
+      const latest = await service.read(board.id), code = safeCode(error, "AUTOMATION_ANALYSIS_PREPARATION_FAILED");
+      await service.execute(board.id, { operationId: "analysis-prepare-failed:" + item.id + ":" + item.revision, expectedRevision: latest.revision, command: { type: "report-analysis", itemId: item.id, operationId: item.id, status: { itemId: item.id, state: "failed", code } } });
+      options.log({ operationId: item.id, boardId: board.id, stage: "automation.analysis.prepare", result: "failure", code, durationMs: 0 });
+    }
+    const status = await analysisStatus(options.journal, board.id, item.id);
+    if (status && ["analyzing", "unknown", "ready"].includes(status.state)) return;
+  }
+}
+async function admit(_options, board, item, service) {
+  const latest = await service.read(board.id);
+  try {
+    await service.execute(board.id, { operationId: "admit:" + item.id + ":" + item.revision, expectedRevision: latest.revision, command: { type: "admit-item", itemId: item.id, trigger: item.launch?.requestedAt !== void 0 ? "manual" : "automatic" } });
+    return true;
+  } catch (error) {
+    if (["REVISION_CONFLICT", "TASK_DEFINITION_FROZEN", "EDIT_LEASE_ACTIVE"].includes(safeCode(error, ""))) return false;
+    throw error;
+  }
+}
+async function createBridge(options, boardId) {
+  const board = await options.service.read(boardId), service = options.serviceFor(board.automation.coordinator);
+  const executor = await options.executor({ boardId, service, dependencies: (item) => dependencyResults(options, boardId, item) });
+  return createKanbanExecutionBridge({
+    fs: options.fs,
+    directory: options.directory + "/" + encodeURIComponent(boardId),
+    boardId,
+    service,
+    worker: async (actor) => options.serviceFor(actor),
+    executor,
+    executionReference: options.executionReference,
+    autoDispatch: async () => (await options.service.read(boardId)).automation?.enabled === true,
+    estimate: (item) => estimateFor(options.journal, boardId, item),
+    authorize: async (stage) => {
+      const latest = await options.service.read(boardId);
+      if (stage !== "inspect") {
+        requireValue(latest.automation?.enabled, "AUTOMATION_PAUSED");
+        requireValue(!latest.executionControl?.paused, "BOARD_EXECUTION_PAUSED");
+      }
+    },
+    log: (event) => options.log({ ...event, boardId })
+  });
+}
+async function estimateFor(journal, boardId, item) {
+  const decomposed = await journal.get("decomposition-estimate:" + JSON.stringify([boardId, item.id]));
+  if (decomposed) return decomposed;
+  const key = await journal.get("analysis-current:" + JSON.stringify([boardId, item.id]));
+  return key ? (await journal.get(key))?.result?.estimate : void 0;
+}
+async function dependencyResults(options, boardId, item) {
+  const workflow = await options.service.workflow(boardId), results = [];
+  for (const itemId of item.planning?.dependencies ?? []) {
+    const dispatch = Object.values(workflow.dispatches).reverse().find((dispatch2) => dispatch2.itemId === itemId && dispatch2.outcome === "accepted");
+    const outputs = [];
+    for (const output of dispatch?.outputs ?? []) {
+      requireValue(await options.journal.verify(dispatch?.outputs ?? [], dispatch?.id), "DEPENDENCY_OUTPUT_INVALID");
+      outputs.push({ reference: output, value: JSON.parse(await options.journal.get("artifact:" + output.sha256)) });
+    }
+    results.push({ itemId, outputs });
+  }
+  requireValue(new TextEncoder().encode(JSON.stringify(results)).byteLength <= 128 * 1024, "DEPENDENCY_CONTEXT_TOO_LARGE");
+  return results;
+}
+async function dependenciesComplete(service, board, item) {
+  for (const id of item.planning?.dependencies ?? []) {
+    const dependency = board.items.find((i) => i.id === id) ?? (await service.item(board.id, id)).item;
+    if (dependency.status !== "completed") return false;
+  }
+  return true;
+}
+
+// src/runtime/analysis-history.ts
+async function analysisHistory(journal, boardId, itemId) {
+  const key = "analysis-history:" + JSON.stringify([boardId, itemId]);
+  let saved = await journal.get(key);
+  if (!saved?.indexed) {
+    const rows = await journal.find("analysis:", (job, entryKey) => job.status?.itemId === itemId && entryKey === "analysis:" + sha256HexSync(JSON.stringify([boardId, itemId, job.itemRevision, job.signature])));
+    saved = await journal.update(key, (old) => ({ keys: [.../* @__PURE__ */ new Set([...old?.keys ?? [], ...rows.map((row) => row.key)])], indexed: true }));
+  }
+  const jobs = await journal.getMany(saved.keys);
+  return jobs.filter((job) => !!job);
+}
+
+// src/runtime/logging.ts
+function runtimeLogger(journal) {
+  const emit = (_message, event) => journal.diagnostic(event);
+  return { info: emit, warn: emit };
+}
+
+// src/runtime/board-deletion-inspection.ts
+var settled = /* @__PURE__ */ new Set(["idle", "completed", "failed", "cancelled"]);
+async function boardDeletionBlockers({ service, journal }, boardId, items) {
+  const board = await service.read(boardId), workflow = await service.workflow(boardId), rows = [];
+  for (const item of board.items) if (!["completed", "cancelled"].includes(item.status) && (item.owner || item.transfer || item.status === "claimed")) rows.push({ code: "BOARD_EXECUTION_ACTIVE", itemId: item.id });
+  for (const item of board.items) if (item.control?.action === "cancel" && item.control.state !== "cancelled" && !["completed", "cancelled"].includes(item.status)) rows.push({ code: "BOARD_CONTROL_UNSETTLED", itemId: item.id });
+  for (const dispatch of Object.values(workflow.dispatches)) if (["prepared", "running", "unknown", "succeeded"].includes(dispatch.outcome)) rows.push({ code: "BOARD_EXECUTION_UNSETTLED", itemId: dispatch.itemId });
+  const reviews = await journal.findForBoard("review-operation:", boardId, (job) => job.boardId === boardId && job.phase !== "settled");
+  rows.push(...reviews.map(({ value }) => ({ code: "BOARD_MAINTENANCE_ACTIVE", itemId: value.itemId })));
+  const runs = await journal.findForBoard("record-runs:", boardId, (runs2) => runs2.some((run) => (run.sourceBoardId === boardId || run.boardId === boardId) && !["completed", "failed", "cancelled"].includes(run.state)));
+  if (runs.length) rows.push({ code: "BOARD_DECISION_UNSETTLED" });
+  rows.push(...await pendingCollaboration(journal, boardId));
+  rows.push(...(await inspectItems(items ?? await deletionItems(service, boardId), (item) => itemBlockers(service, journal, boardId, item.id))).flat());
+  return [...new Map(rows.map((row) => [JSON.stringify([row.code, row.itemId, row.sessionId]), row])).values()];
+}
+async function deletionPreview(options, boardId) {
+  const { service } = options;
+  const board = await service.read(boardId), actor = await service.currentPrincipal();
+  requireValue(board.deletedAt === void 0, "BOARD_DELETED");
+  requireValue(actor.kind === "human" && board.members?.some((row) => row.kind === actor.kind && row.id === actor.id && row.roles?.includes("coordinator")), "COORDINATOR_REQUIRED");
+  const items = await deletionItems(service, boardId), itemTitles = Object.fromEntries(items.map((item) => [item.id, item.title]));
+  const operationId = randomUUID();
+  const blockers = await inspectionStage(operationId, "local-and-sessions", () => boardDeletionBlockers(options, boardId, items), options.journal);
+  const resources = (await inspectionStage(operationId, "work-resources", () => inspectItems(items, async (item) => (await service.workResources?.(boardId, item.id) ?? []).map((resource) => ({ itemId: item.id, resource }))), options.journal)).flat();
+  for (const { itemId, resource } of resources) if (resource.state === "in-use" && resource.ownership !== "other" && resource.ownership !== "unknown" && !blockers.some((row) => row.code === "BOARD_EXECUTION_ACTIVE" && row.itemId === itemId)) blockers.push({ code: "BOARD_EXECUTION_ACTIVE", itemId });
+  const result = { ...board.lifecycle?.intent === "delete" ? { pendingDeletion: { operationId: board.lifecycle.operationId, mode: board.lifecycle.mode, phase: board.lifecycle.phase, code: board.lifecycle.code } } : {}, boardId, title: board.title, revision: board.revision, itemTitles, blockers, pendingItems: board.items.filter((item) => !["completed", "cancelled"].includes(item.status)).length, resources };
+  requireValue((await service.read(boardId)).revision === board.revision, "REVISION_CONFLICT");
+  return { ...result, version: sha256HexSync(JSON.stringify(result)) };
+}
+async function deletionItems(service, board) {
+  const items = [];
+  let cursor;
+  do {
+    const page = await service.query(board, { view: "all", includeDeleted: true, limit: 200, ...cursor ? { cursor } : {} });
+    items.push(...page.items.map(({ id, title }) => ({ id, title })));
+    cursor = page.nextCursor;
+    requireValue(items.length <= 1e4, "BOARD_DELETE_RESOURCE_LIMIT");
+  } while (cursor);
+  return items;
+}
+async function itemBlockers(service, journal, board, item) {
+  const rows = [];
+  if ((await analysisHistory(journal, board, item)).some((job) => job.phase !== "settled")) rows.push({ code: "BOARD_ANALYSIS_UNSETTLED", itemId: item });
+  if (!service.executionSession) return rows;
+  const detail = await service.executionSession(board, item, { includeRelated: true });
+  if (detail.sessionsCode) rows.push({ code: detail.sessionsCode, itemId: item });
+  for (const session of detail.sessions ?? []) {
+    if (session.purposes?.every((purpose) => purpose === "discussion")) continue;
+    const executions = session.executions.filter((run) => run.purpose !== "discussion");
+    const pending2 = executions.length && executions.every((run) => run.state) ? executions.some((run) => !settled.has(run.state)) : !settled.has(session.state);
+    if (session.stale || pending2) rows.push({ code: "BOARD_SESSION_UNSETTLED", itemId: item, sessionId: session.sessionId });
+  }
+  return rows;
+}
+async function pendingCollaboration(journal, boardId) {
+  const [fixes, replies] = await Promise.all([
+    journal.findForBoard("fix:", boardId, (fix) => !fix.accepted && fix.state !== "cancelled"),
+    journal.findForBoard("task-reply:", boardId, () => true)
+  ]);
+  const delivered = await journal.getMany(replies.map((row) => "task-reply-delivered:" + row.key.slice("task-reply:".length)));
+  const cancelled2 = await journal.getMany(replies.map((row) => "task-reply-cancelled:" + row.key.slice("task-reply:".length)));
+  return [
+    ...fixes.map(({ value }) => ({ code: "BOARD_FIX_UNSETTLED", itemId: value.itemId })),
+    ...replies.filter((_, index) => (!delivered[index] || replies[index].value.phase === "cancelling") && !cancelled2[index]).map(({ value }) => ({ code: "BOARD_REPLY_UNSETTLED", itemId: value.request.itemId }))
+  ];
+}
+async function inspectItems(items, run) {
+  const results = [];
+  let next = 0, stopped = false;
+  const workers = Array.from({ length: Math.min(4, items.length) }, async () => {
+    while (!stopped && next < items.length) {
+      const index = next++;
+      try {
+        results[index] = await run(items[index]);
+      } catch (error) {
+        stopped = true;
+        throw error;
+      }
+    }
+  });
+  const settled2 = await Promise.allSettled(workers), failed = settled2.find((row) => row.status === "rejected");
+  if (failed?.status === "rejected") throw failed.reason;
+  return results;
+}
+async function inspectionStage(operationId, stage, run, journal) {
+  const log = runtimeLogger(journal);
+  const started = Date.now();
+  try {
+    const result = await run();
+    log.info("board.deletion.inspect", { operation: "kanban.board.delete", operationId, stage, result: "success", durationMs: Date.now() - started });
+    return result;
+  } catch (error) {
+    log.warn("board.deletion.inspect", { operation: "kanban.board.delete", operationId, stage, result: "failure", code: safeCode(error, "BOARD_INSPECTION_FAILED"), durationMs: Date.now() - started });
+    throw error;
+  }
+}
+
+// src/runtime/board-stop.ts
+var keyFor2 = (board) => "board-stop:" + board;
+function createBoardStop(options, remove) {
+  const log = runtimeLogger(options.journal);
+  return {
+    cancelBoard: (board, request) => requestStop(options, board, { ...request, mode: "cancel" }, "cancel"),
+    requestBoardDeletion: (board, request) => requestStop(options, board, request, "delete"),
+    preparePending: async () => {
+      for (const row of await pending(options)) {
+        const started = Date.now();
+        try {
+          await admit2(options, row.value);
+        } catch (error) {
+          log.warn("Board stop admission pending", { operation: "kanban.board.stop", operationId: row.value.request.operationId, boardId: row.value.boardId, stage: "admit", result: "failure", code: safeCode(error, "BOARD_STOP_ADMISSION_UNKNOWN"), durationMs: Date.now() - started });
+        }
+      }
+    },
+    resumePending: async () => {
+      for (const row of await pending(options)) {
+        const started = Date.now(), saved = row.value;
+        try {
+          if ((await options.service.read(saved.boardId)).deletedAt !== void 0) {
+            await done(options, saved);
+            continue;
+          }
+          if ((await authorize(options, saved)).lifecycle?.operationId !== saved.request.operationId) continue;
+          const preview = await deletionPreview(options, saved.boardId);
+          if (preview.blockers.length) {
+            await progress(options, saved, "blocked", preview.blockers[0].code);
+            continue;
+          }
+          await progress(options, saved, "ready");
+          if (saved.intent === "cancel") {
+            await done(options, saved);
+            continue;
+          }
+          const current = await deletionPreview(options, saved.boardId);
+          await remove(saved.boardId, { operationId: sha256HexSync(JSON.stringify([saved.request.operationId, current.version])), expectedRevision: current.revision, version: current.version, cleanup: saved.request.cleanup === true });
+          await done(options, saved);
+          log.info("Deferred board deletion completed", { operation: "kanban.board.stop", operationId: saved.request.operationId, boardId: saved.boardId, stage: "delete", result: "success", durationMs: Date.now() - started });
+        } catch (error) {
+          const code = safeCode(error, "BOARD_DELETION_UNKNOWN");
+          await progress(options, saved, "blocked", code).catch(() => {
+          });
+          log.warn("Deferred board deletion pending", { operation: "kanban.board.stop", operationId: saved.request.operationId, boardId: saved.boardId, stage: "settle", result: "failure", code, durationMs: Date.now() - started });
+        }
+      }
+    }
+  };
+}
+function pending({ journal }) {
+  return journal.find("board-stop:", (value) => value.phase !== "done");
+}
+async function authorize(options, saved) {
+  const board = await options.service.read(saved.boardId), actor = await options.service.currentPrincipal();
+  requireValue(actor.kind === "human" && actor.id === saved.principalId && board.members?.some((member) => member.kind === actor.kind && member.id === actor.id && member.roles?.includes("coordinator")), "COORDINATOR_REQUIRED");
+  return board;
+}
+async function requestStop(options, boardId, request, intent) {
+  requireValue(/^[\w-]{1,128}$/.test(request.operationId) && Number.isSafeInteger(request.expectedRevision), "INVALID_OPERATION_ID");
+  if (intent === "delete") requireValue(typeof request.cleanup === "boolean" && ["drain", "cancel"].includes(request.mode ?? "") && /^[a-f0-9]{64}$/.test(request.version ?? ""), "INVALID_BOARD_CONTROL");
+  const actor = await options.service.currentPrincipal(), board = await authorize(options, { boardId, principalId: actor.id });
+  const old = await options.journal.get(keyFor2(boardId));
+  if (old?.request.operationId === request.operationId) {
+    requireValue(old.intent === intent && JSON.stringify(old.request) === JSON.stringify(request), "IDEMPOTENCY_CONFLICT");
+    if (old.phase !== "done") await admit2(options, old);
+    return;
+  }
+  requireValue(board.deletedAt === void 0, "BOARD_DELETED");
+  requireValue(!old || old.intent === "cancel" && intent === "delete", "BOARD_STOP_PENDING");
+  requireValue(board.revision === request.expectedRevision, "REVISION_CONFLICT");
+  if (intent === "delete") {
+    const preview = await deletionPreview(options, boardId);
+    requireValue(preview.version === request.version, "BOARD_DELETE_PREVIEW_CHANGED");
+  }
+  const saved = await options.journal.update(keyFor2(boardId), (current) => {
+    requireValue(!current || current.request.operationId === old?.request.operationId, "BOARD_STOP_PENDING");
+    return { boardId, principalId: actor.id, intent, request: structuredClone(request), phase: "prepared" };
+  });
+  await admit2(options, saved);
+}
+async function admit2(options, saved) {
+  if (saved.phase !== "prepared") return;
+  const board = await authorize(options, saved);
+  if (board.deletedAt !== void 0) {
+    await done(options, saved);
+    return;
+  }
+  await journalCommand(
+    options.journal,
+    options.service,
+    saved.boardId,
+    "board-stop-admit:" + JSON.stringify([saved.boardId, saved.request.operationId]),
+    { type: "request-board-stop", controlId: saved.request.operationId, intent: saved.intent, mode: saved.request.mode ?? "cancel" }
+  );
+  await options.journal.update(keyFor2(saved.boardId), (old) => old?.request.operationId === saved.request.operationId ? { ...old, phase: "admitted" } : old);
+}
+async function progress(options, saved, phase, code) {
+  const board = await authorize(options, saved);
+  if (board.deletedAt !== void 0 || board.lifecycle?.operationId !== saved.request.operationId || board.lifecycle?.phase === phase && board.lifecycle.code === code) return;
+  await journalCommand(
+    options.journal,
+    options.service,
+    saved.boardId,
+    "board-stop-progress:" + JSON.stringify([saved.boardId, saved.request.operationId, board.revision, phase, code ?? ""]),
+    { type: "observe-board-stop", controlId: saved.request.operationId, phase, code }
+  );
+}
+async function done(options, saved) {
+  await options.journal.update(keyFor2(saved.boardId), (old) => old?.request.operationId === saved.request.operationId ? { ...old, phase: "done" } : old);
+}
+
+// src/runtime/board-deletion.ts
+function createBoardDeletion(options) {
+  const stop = createBoardStop(options, (board, request) => removeBoard(options, board, request));
+  return {
+    ...stop,
+    previewDeletion: (id) => traced(id, randomUUID(), "preview", () => deletionPreview(options, id), options.journal),
+    assertSettled: async (id) => {
+      const rows = await boardDeletionBlockers(options, id);
+      requireValue(!rows.length, rows[0]?.code ?? "BOARD_EXECUTION_UNSETTLED");
+    },
+    deleteBoard: (id, request) => traced(id, request.operationId, "delete", () => removeBoard(options, id, request), options.journal)
+  };
+}
+async function removeBoard(options, id, request) {
+  const { service, journal } = options;
+  requireValue(/^[\w-]{1,128}$/.test(request.operationId) && typeof request.cleanup === "boolean" && /^[a-f0-9]{64}$/.test(request.version), "INVALID_OPERATION_ID");
+  const key = "board-deletion:" + id, receipt = await journal.get(key);
+  if (receipt?.request.operationId === request.operationId) {
+    requireValue(JSON.stringify(receipt.request) === JSON.stringify(request), "IDEMPOTENCY_CONFLICT");
+    if ((await service.read(id)).deletedAt !== void 0) return;
+  }
+  const current = await deletionPreview(options, id);
+  requireValue(current.revision === request.expectedRevision && current.version === request.version, "BOARD_DELETE_PREVIEW_CHANGED");
+  requireValue(!current.blockers.length, current.blockers[0]?.code ?? "BOARD_EXECUTION_UNSETTLED");
+  await journal.update(key, () => ({ request, preview: current, phase: "prepared" }));
+  if (request.cleanup) await cleanupResources(options, id, request, current);
+  const board = await service.read(id);
+  requireValue(board.revision === request.expectedRevision, "BOARD_DELETE_PREVIEW_CHANGED");
+  await service.execute(id, { operationId: request.operationId, expectedRevision: board.revision, command: { type: "delete-board" } });
+  await journal.update(key, (old) => ({ ...old, phase: "deleted" }));
+}
+async function cleanupResources({ service, journal }, id, request, preview) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of preview.resources) {
+    const key = JSON.stringify([row.resource.kind, row.resource.id, row.resource.location]);
+    const group = groups.get(key) ?? [];
+    group.push(row);
+    groups.set(key, group);
+  }
+  for (const group of groups.values()) if (group.every((row) => row.resource.canCleanup && row.resource.ownership !== "other" && row.resource.ownership !== "unknown")) {
+    const { itemId, resource } = group[0];
+    requireValue(service.cleanupWorkResource, "WORK_RESOURCE_CLEANUP_UNAVAILABLE");
+    await traced(id, request.operationId, "cleanup", () => service.cleanupWorkResource(id, {
+      itemId,
+      resourceId: resource.id,
+      version: resource.version,
+      operationId: sha256HexSync(JSON.stringify([request.operationId, resource.id]))
+    }), journal);
+  }
+}
+async function traced(boardId, operationId, stage, run, journal) {
+  const log = runtimeLogger(journal);
+  const started = Date.now();
+  operationId = /^[\w-]{1,128}$/.test(operationId) ? operationId : randomUUID();
+  try {
+    const result = await run();
+    log.info("board.deletion", { operation: "kanban.board.delete", boardId, operationId, stage, result: "success", durationMs: Date.now() - started });
+    return result;
+  } catch (error) {
+    log.warn("board.deletion", { operation: "kanban.board.delete", boardId, operationId, stage, result: "failure", code: safeCode(error, "BOARD_DELETE_FAILED"), durationMs: Date.now() - started });
+    throw error;
+  }
+}
+function withBoardDeletion(service, deletion) {
+  let barrier = Promise.resolve(), stopping = false;
+  const pending2 = /* @__PURE__ */ new Set();
+  const items = /* @__PURE__ */ new Map();
+  const itemMutation = (board, item, run, checkDeleted = true) => {
+    const key = JSON.stringify([board, item]);
+    const next = (items.get(key) ?? Promise.resolve()).catch(() => {
+    }).then(async () => {
+      if (checkDeleted) requireValue((await service.item(board, item)).item.deletedAt === void 0, "ITEM_DELETED");
+      return run();
+    });
+    items.set(key, next);
+    void next.finally(() => {
+      if (items.get(key) === next) items.delete(key);
+    }).catch(() => {
+    });
+    return next;
+  };
+  let quiescing, disposing;
+  const quiesce = () => {
+    stopping = true;
+    if (!quiescing) {
+      const acknowledgements = Promise.allSettled([service.quiesce?.() ?? Promise.resolve(), ...pending2]);
+      quiescing = (async () => {
+        await barrier;
+        const [ack] = await acknowledgements;
+        if (ack.status === "rejected") throw ack.reason;
+      })();
+    }
+    return quiescing;
+  };
+  const close = (method) => method === "quiesce" ? quiesce() : disposing ??= quiesce().then(() => service.dispose?.());
+  const admit3 = (run) => {
+    if (stopping) return Promise.reject(new KanbanError("SERVICE_STOPPING"));
+    const next = barrier.then(run);
+    pending2.add(next);
+    void next.finally(() => pending2.delete(next)).catch(() => {
+    });
+    return next;
+  };
+  const exclusive = (run) => {
+    if (stopping) return Promise.reject(new KanbanError("SERVICE_STOPPING"));
+    const admitted = [...pending2], next = barrier.then(async () => {
+      await Promise.allSettled(admitted);
+      return run();
+    });
+    barrier = next.catch(() => {
+    });
+    return next;
+  };
+  const active = async (id, run) => {
+    requireValue((await service.read(id)).deletedAt === void 0, "BOARD_DELETED");
+    return run();
+  };
+  return {
+    ...service,
+    ...service.quiesce ? { quiesce: () => close("quiesce") } : {},
+    ...service.dispose ? { dispose: () => close("dispose") } : {},
+    previewDeletion: deletion.previewDeletion,
+    deleteBoard: (id, request) => exclusive(() => deletion.deleteBoard(id, request)),
+    execute: (id, request) => admit3(() => active(id, () => {
+      if (request.command.type === "delete-board") throw new KanbanError("BOARD_DELETE_CONFIRMATION_REQUIRED");
+      return "itemId" in request.command && request.command.itemId ? itemMutation(id, request.command.itemId, () => service.execute(id, request), false) : service.execute(id, request);
+    })),
+    scan: async () => {
+      await admit3(async () => {
+        await deletion.preparePending();
+        await service.scan();
+      });
+      if (!stopping) await exclusive(() => deletion.resumePending());
+    },
+    cancelBoard: (id, request) => admit3(() => active(id, () => deletion.cancelBoard(id, request))),
+    requestBoardDeletion: (id, request) => admit3(() => active(id, () => deletion.requestBoardDeletion(id, request))),
+    ...service.cancelFix ? { cancelFix: (id, request) => admit3(() => active(id, () => service.cancelFix(id, request))) } : {},
+    ...service.controlRecord ? { controlRecord: (id, request) => admit3(() => active(id, () => service.controlRecord(id, request))) } : {},
+    ...service.fixTask ? { fixTask: (id, request) => admit3(() => active(id, () => itemMutation(id, request.itemId, () => service.fixTask(id, request)))) } : {},
+    ...service.replyTask ? { replyTask: (id, request) => admit3(() => active(id, () => itemMutation(id, request.itemId, () => service.replyTask(id, request)))) } : {},
+    ...service.runRecord ? { runRecord: (id, request) => admit3(() => active(id, () => service.runRecord(id, request))) } : {},
+    ...service.runItemOperation ? { runItemOperation: (id, request) => admit3(() => active(id, () => itemMutation(id, request.itemId, () => service.runItemOperation(id, request)))) } : {},
+    ...service.bindItemOperation ? { bindItemOperation: (id, request) => admit3(() => active(id, () => itemMutation(id, request.itemId, () => service.bindItemOperation(id, request)))) } : {},
+    ...service.cleanupWorkResource ? { cleanupWorkResource: (id, request) => admit3(() => service.cleanupWorkResource(id, request)) } : {}
+  };
+}
+
+// src/runtime/control.ts
+function controlExecution(options, _journal, executionId, operationId, action, attemptId = executionId, previousKey, direct = false) {
+  return options.control.control({ executionId, operationId, action, attemptId, previousKey, ...direct ? { fallbackSubmission: true } : {} });
+}
+
+// src/runtime/task-maintenance-cancellation.ts
+async function cancelTaskMaintenance(options, journal, board, item, controlId) {
+  const jobs = await journal.findForBoard("review-operation:", board, (job) => job.itemId === item && job.phase !== "settled");
+  for (const row of jobs) {
+    const saved = await journal.update(row.key, (old) => old.phase === "prepared" ? { ...old, phase: "settled", state: "failed", code: "USER_CANCELLED" } : old);
+    if (saved.phase === "settled") continue;
+    if (saved.action === "accept") return "accepted";
+    requireValue(saved.request ?? saved.input, "TASK_CONTROL_ROUTE_MISSING");
+    const id = sha256HexSync(JSON.stringify([controlId, saved.id]));
+    const state = await options.control.control({ executionId: saved.sessionId ?? saved.id, operationId: id, action: "cancel", attemptId: saved.id, kind: saved.request ? "submission" : "call", prepared: saved.request ?? saved.input });
+    if (state !== "cancelled") return state === "unknown" ? "unknown" : "accepted";
+    await journal.update(row.key, (old) => old.phase === "settled" ? old : { ...old, phase: "settled", state: "failed", code: "USER_CANCELLED" });
+  }
+  return cancelPostloads(options, journal, board, item, controlId);
+}
+async function cancelPostloads(options, journal, board, item, controlId) {
+  const rows = await journal.find(options.finalizerPrefix ?? "execution-finalizer:", (job) => job.boardId === board && job.dispatch.itemId === item && !job.done);
+  for (const row of rows) {
+    const job = await journal.update(row.key, (old) => old.phase === "prepared" ? { ...old, phase: "settled", done: true, observation: { outcome: "cancelled", code: "USER_CANCELLED" } } : old);
+    if (job.done) continue;
+    const state = await controlExecution(options, journal, job.dispatch.id, sha256HexSync(JSON.stringify([controlId, job.dispatch.id])), "cancel");
+    if (state !== "cancelled") return state === "unknown" ? "unknown" : "accepted";
+    await journal.update(row.key, (old) => ({ ...old, phase: "settled", done: true, observation: { outcome: "cancelled", code: "USER_CANCELLED" } }));
+  }
+  return "cancelled";
+}
+
+// src/runtime/task-reply-cancellation.ts
+async function cancelTaskReplies(options, journal, board, item, controlId) {
+  const replies = await journal.findForBoard("task-reply:", board, (reply) => reply.request.itemId === item);
+  for (const row of replies) {
+    const id = row.value.request.operationId;
+    if (await journal.get("task-reply-cancelled:" + id)) continue;
+    const saved = await journal.update(row.key, (old) => ({ ...old, phase: old.phase === "prepared" ? "cancelled" : old.phase === "cancelled" ? "cancelled" : "cancelling" }));
+    if (saved.phase !== "cancelled") {
+      requireValue(options.control, "TASK_CONTROL_UNSUPPORTED");
+      const state = await options.control.control({ executionId: saved.sessionId, attemptId: id, operationId: sha256HexSync(JSON.stringify([controlId, id])), action: "cancel", kind: "submission" });
+      if (state !== "cancelled") return state === "unknown" ? "unknown" : "accepted";
+    }
+    await journal.update("task-reply-cancelled:" + id, () => true);
+  }
+  return "cancelled";
+}
+
+// src/runtime/board-stop-work.ts
+async function scanBoardStopWork(options) {
+  for (const board of await options.service.list()) {
+    if (board.lifecycle?.mode !== "cancel" || board.lifecycle.phase === "ready") continue;
+    const control = board.lifecycle.operationId;
+    if (options.fixes) for (const row of await options.journal.findForBoard("fix:", board.id, (fix) => !fix.accepted && fix.state !== "cancelled"))
+      await attempt(options.journal, board.id, control, "fix.cancel", () => options.fixes.cancelFix(board.id, { fixId: row.value.id, operationId: sha256HexSync(JSON.stringify([control, row.value.id])) }));
+    if (options.records) for (const run of await options.journal.get("record-runs:" + board.id) ?? []) {
+      const key = "record-control:" + JSON.stringify([board.id, run.recordId]);
+      if ((await options.journal.get(key))?.action !== "cancel") await attempt(options.journal, board.id, control, "record.cancel", () => options.records.controlRecord(board.id, { recordId: run.recordId, operationId: sha256HexSync(JSON.stringify([control, run.recordId])), action: "cancel" }));
+    }
+    for (const item of board.items.filter((item2) => ["completed", "cancelled"].includes(item2.status))) {
+      const id = sha256HexSync(JSON.stringify([control, item.id]));
+      await attempt(options.journal, board.id, control, "reply.cancel", () => cancelTaskReplies(options.ports, options.journal, board.id, item.id, id));
+      await attempt(options.journal, board.id, control, "maintenance.cancel", () => cancelTaskMaintenance(options.ports, options.journal, board.id, item.id, id));
+    }
+  }
+}
+async function attempt(journal, boardId, operationId, stage, run) {
+  const started = Date.now();
+  try {
+    await run();
+  } catch (error) {
+    runtimeLogger(journal).warn("Board work settlement pending", { operation: "kanban.board.stop", operationId, boardId, stage, result: "failure", code: safeCode(error, "BOARD_WORK_STOP_UNKNOWN"), durationMs: Date.now() - started });
+  }
+}
+
+// src/runtime/task-analysis-controls.ts
+async function controlTaskAnalyses(options, journal, board, item) {
+  const analyses = await analysisHistory(journal, board, item.id);
+  requireValue(analyses.length || !["analyzing", "unknown"].includes(item.analysis?.state ?? ""), "TASK_CONTROL_ROUTE_MISSING");
+  const keys = (await journal.get("analysis-history:" + JSON.stringify([board, item.id])))?.keys ?? [];
+  const byId = new Map((await journal.getMany(keys)).flatMap((job, index) => job ? [[job.id, keys[index]]] : []));
+  for (const job of analyses) {
+    if (job.phase === "settled") continue;
+    const key = byId.get(job.id);
+    requireValue(key, "TASK_CONTROL_ROUTE_MISSING");
+    const state = await controlAnalysis(options, journal, key, job, item.control);
+    if (state) return state;
+  }
+}
+async function controlAnalysis(options, journal, key, job, control) {
+  if (control.action === "cancel") {
+    const current = await journal.update(key, (old) => old.phase === "prepared" ? cancelled(old) : old);
+    if (current.phase === "settled") return;
+  } else if (job.phase === "prepared") return;
+  const state = await controlExecution(options, journal, job.id, control.id + "-analysis-" + job.id, control.action);
+  const target = control.action === "pause" ? "paused" : control.action === "resume" ? "resumed" : "cancelled";
+  if (state !== target) return state;
+  if (control.action === "cancel") await journal.update(key, (old) => cancelled(old));
+}
+function cancelled(job) {
+  return { ...job, phase: "settled", terminalOutcome: "cancelled", status: { ...job.status, state: "failed", code: "USER_CANCELLED" } };
+}
+
+// src/runtime/task-controls.ts
+async function scanTaskControls(options, journal, board, service) {
+  const log = runtimeLogger(journal);
+  for (const item of board.items) {
+    const control = item.control;
+    if (!control || ["failed", "paused", "resumed", "cancelled"].includes(control.state)) continue;
+    const started = Date.now();
+    let result;
+    try {
+      const state = await observe(options, journal, board, item, service);
+      const latest = state === "cancelled" ? await service.read(board.id) : board;
+      const childrenPending = latest.items.some((child) => child.planning?.parentId === item.id && !["completed", "cancelled"].includes(child.status));
+      result = { state: state === "cancelled" && childrenPending ? "accepted" : state };
+    } catch (error) {
+      result = controlFailure(error);
+    }
+    if (result.state === control.state && result.code === control.code) continue;
+    const fields = { operation: "kanban.task.control", operationId: control.id, boardId: board.id, itemId: item.id, stage: control.action, result: ["failed", "unknown"].includes(result.state) ? "failure" : "success", code: result.code, state: result.state, durationMs: Date.now() - started };
+    if (fields.result === "failure") log.warn("Task control observed", fields);
+    else log.info("Task control observed", fields);
+    await journalCommand(
+      journal,
+      service,
+      board.id,
+      "task-control-projection:" + JSON.stringify([board.id, item.id, control.id]) + ":" + result.state + ":" + (result.code ?? ""),
+      { type: "control-receipt", itemId: item.id, controlId: control.id, ...result }
+    );
+  }
+}
+async function observe(options, journal, board, item, service) {
+  const control = item.control;
+  if (control.action === "cancel") {
+    const state = await cancelTaskReplies(options, journal, board.id, item.id, control.id);
+    if (state !== "cancelled") return state;
+    const maintenance = await cancelTaskMaintenance(options, journal, board.id, item.id, control.id);
+    if (maintenance !== "cancelled") return maintenance;
+  }
+  const analysis = await controlTaskAnalyses(options, journal, board.id, item);
+  if (analysis) return analysis;
+  const workflow = await service.workflow(board.id);
+  const dispatch = Object.values(workflow.dispatches).filter((d) => d.itemId === item.id).sort((a, b) => b.attempt - a.attempt)[0];
+  if (dispatch) {
+    if (control.action === "cancel" && ["failed", "cancelled", "rejected"].includes(dispatch.outcome)) return "cancelled";
+    return controlExecution(options, journal, dispatch.continuation ? dispatch.executionSessionId ?? dispatch.id : dispatch.id, control.id, control.action, dispatch.id, "task-control:" + board.id + ":" + control.id, !!dispatch.continuation);
+  }
+  requireValue((!item.owner || item.owner.kind === "human") && !item.externalRefs?.some((ref) => ref.system === (options.references ?? defaultReferences).execution), "TASK_CONTROL_ROUTE_MISSING");
+  return control.action === "cancel" ? "cancelled" : control.action === "pause" ? "paused" : "resumed";
+}
+function controlFailure(error) {
+  const raw = error?.code, code = typeof raw === "string" && /^[A-Z][A-Z0-9_]{0,79}$/.test(raw) ? raw : "TASK_CONTROL_UNKNOWN";
+  return { state: ["TASK_CONTROL_UNSUPPORTED", "CALL_READ_ONLY", "CONTROL_EPOCH_CONFLICT"].includes(code) ? "failed" : "unknown", code };
+}
+
+// src/runtime/runtime-lifecycle.ts
+async function verifyRuntimeLifecycle(service, journal, board, command) {
+  if (command.type === "delete-item") {
+    const blocker = (await boardDeletionBlockers({ service, journal }, board.id)).find((row) => row.itemId === command.itemId);
+    if (blocker) throw new KanbanError(blocker.code);
+  }
+  if (command.type === "cancel-record" || command.type === "delete-record") {
+    const runs = await journal.get("record-runs:" + board.id);
+    if (runs?.some((run) => run.recordId === command.recordId && !["completed", "failed", "cancelled"].includes(run.state))) throw new KanbanError("RECORD_EXECUTION_UNSETTLED");
+  }
+}
+function runtimeLifecycle(service, journal, extensions, beforeScan) {
+  let stopping = false, pending2, closing, disposing;
+  const scan = () => stopping ? Promise.resolve() : pending2 ??= (async () => {
+    await service.scan();
+    await beforeScan();
+    await all(extensions, "scan", journal);
+  })().finally(() => {
+    pending2 = void 0;
+  });
+  const quiesce = () => closing ??= (async () => {
+    stopping = true;
+    const results = await Promise.allSettled([all(extensions, "quiesce", journal), pending2]);
+    await service.quiesce();
+    await journal.drain();
+    failures(results, "KANBAN_QUIESCE_FAILED");
+  })();
+  return { scan, quiesce, dispose: () => disposing ??= (async () => {
+    await quiesce();
+    await all(extensions, "dispose", journal);
+    await service.dispose();
+  })() };
+}
+async function all(extensions, method, journal) {
+  const results = await Promise.allSettled(extensions.map(async (extension, index) => {
+    const started = Date.now();
+    try {
+      await extension[method]?.();
+    } catch (error) {
+      journal.diagnostic({ operationId: "runtime:" + method + ":" + index, stage: "runtime." + method, result: "failure", code: safeCode(error, "KANBAN_" + method.toUpperCase() + "_FAILED"), durationMs: Date.now() - started });
+      throw error;
+    }
+  }));
+  failures(results, "KANBAN_" + method.toUpperCase() + "_FAILED");
+}
+function failures(results, code) {
+  const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+  if (errors.length) throw new AggregateError(errors, code);
+}
+
+// src/runtime/runtime.ts
+async function assembleKanbanRuntime(options) {
+  const directory = options.directory ?? "/kanban", fs = options.fs;
+  const store = options.store ?? await SeqKanbanStore.open(fs, directory);
+  const journal = options.journal instanceof KanbanAutomationJournal ? options.journal : new KanbanAutomationJournal(fs, { directory: directory + "/runtime", diagnostic: options.log, ...options.journal });
+  const workLog = new KanbanWorkLog(fs, { directory: directory + "/runtime", diagnostic: options.log, ...options.workLog });
+  await journal.open();
+  await workLog.open();
+  let verifyDeletion = async () => {
+  };
+  const createService = options.createService ?? createKanbanActivityModule;
+  const serviceFor = (actor) => createService({
+    ...options,
+    store,
+    actor,
+    referenceSystem: options.referenceSystem ?? defaultReferences.execution,
+    verifyLifecycle: async (board, command) => {
+      await verifyRuntimeLifecycle(service, journal, board, command);
+      await options.verifyLifecycle?.(board, command);
+    },
+    verifyDeletion: async (board) => {
+      await verifyDeletion(board.id);
+      await options.verifyDeletion?.(board);
+    },
+    onCommitted: async (id, source, now) => {
+      await workLog.synchronize(id, source);
+      await options.onCommitted?.(id, source, now);
+    }
+  });
+  const service = serviceFor(options.actor), context = { fs, store, journal, workLog, service, serviceFor };
+  const extensions = options.extensions?.(context) ?? [];
+  return assembleRuntime(options, context, extensions, (verify) => {
+    verifyDeletion = verify;
+  });
+}
+function assembleRuntime(options, context, extensions, setDeletion) {
+  const { service, journal, workLog } = context, directory = options.directory ?? "/kanban";
+  const records = options.resources ? createRecordExecution({ service, journal, resources: options.resources, requiresItemResource: options.requiresItemResource, log: options.log ?? (() => {
+  }) }) : void 0;
+  const automation = options.automation ? createKanbanAutomation({
+    ...options.automation,
+    ...context,
+    directory: directory + "/automation",
+    log: options.log ?? (() => {
+    })
+  }) : void 0;
+  const capabilities = Object.assign({}, ...extensions.map((extension) => extension.capabilities));
+  const client = {
+    ...service,
+    ...capabilities,
+    ...records ? { ...records, recordExecutions: async (board, id) => (await workLog.record(service, board, id)).kind === "decision" ? records.recordExecutions(board, id) : [] } : {},
+    ...automation ? { automationCatalog: automation.automationCatalog, analysisStatus: automation.analysisStatus } : {},
+    records: (board, query) => workLog.records(service, board, query),
+    record: (board, id) => workLog.record(service, board, id)
+  };
+  const deletion = createBoardDeletion({ service: client, journal });
+  setDeletion(deletion.assertSettled);
+  const participants = [...extensions, ...records ? [records] : [], ...automation ? [automation] : []];
+  const lifecycle = runtimeLifecycle(service, journal, participants, async () => {
+    await scanBoardStopWork({ service, journal, ports: options.control ?? { control: { control: async () => "unknown" } }, fixes: capabilities.cancelFix ? { cancelFix: capabilities.cancelFix } : void 0, records });
+    if (!automation && options.control) for (const board of await service.list()) await scanTaskControls(options.control, journal, board, service);
+  });
+  return { ...context, service: withBoardDeletion({ ...client, ...lifecycle }, deletion) };
+}
+
+// src/runtime/board-drain.ts
+async function drainBoardAnalyses(ports, journal, board, service) {
+  if (!board.lifecycle) return;
+  for (const item of board.items) {
+    const jobs = await analysisHistory(journal, board.id, item.id);
+    const keys = (await journal.get("analysis-history:" + JSON.stringify([board.id, item.id])))?.keys ?? [];
+    for (const job of jobs) {
+      if (job.phase === "settled") continue;
+      const key = keys[(await journal.getMany(keys)).findIndex((row) => row?.id === job.id)];
+      if (!key) continue;
+      const view2 = job.phase === "submitting" ? await ports.control.inspect?.(job.id, job.id) : void 0;
+      if (job.phase === "submitting" && (!view2 || !view2.settled)) continue;
+      const saved = await journal.update(key, (old) => old.phase !== job.phase ? old : { ...old, phase: "settled", terminalOutcome: view2?.outcome ?? (job.phase === "prepared" ? "cancelled" : void 0), status: { ...old.status, state: "failed", code: "BOARD_STOPPED_AFTER_ANALYSIS" } });
+      if (saved.phase === "settled" && !["completed", "cancelled"].includes(item.status) && item.control?.action !== "cancel") await journalCommand(
+        journal,
+        service,
+        board.id,
+        "board-drained-analysis:" + JSON.stringify([board.id, job.id]),
+        { type: "report-analysis", itemId: item.id, operationId: job.id, status: saved.status }
+      );
+    }
+  }
+}
+
+// src/runtime/work-context.ts
+async function workContext(journal, board, item, references = defaultReferences) {
+  const runId = item.externalRefs?.find((ref) => ref.system === references.decision)?.id;
+  let decision = runId ? await journal.get("record-context:" + runId) : void 0;
+  if (runId && !decision) {
+    const runs = await journal.get("record-runs:" + board.id);
+    const run = runs?.find((run2) => run2.id === runId);
+    if (run) decision = { sourceBoardId: run.sourceBoardId, recordId: run.recordId, recordRevision: run.recordRevision, runId };
+  }
+  const snapshot = decision ? (await journal.get("record-runs:" + decision.sourceBoardId))?.find((run) => run.id === decision.runId)?.record : void 0;
+  return {
+    board: { id: board.id, title: board.title, revision: board.revision },
+    decision: decision ? { ...decision, ...snapshot ? { snapshot } : {} } : null,
+    task: {
+      id: item.id,
+      revision: item.revision,
+      parentId: item.planning?.parentId ?? null,
+      title: item.title,
+      responsibility: item.responsibility,
+      acceptance: item.acceptance,
+      dependencies: item.planning?.dependencies ?? []
+    },
+    resources: item.externalRefs?.filter((ref) => ref.system === references.resource) ?? []
+  };
+}
+
+export {
+  safeCode,
+  KanbanAutomationJournal,
+  defaultReferences,
+  KanbanWorkLog,
+  journalCommand,
+  recordControlKey,
+  advanceRecordControl,
+  requestRecordControl,
+  createRecordExecution,
+  validateResourceReferences,
+  completeCompositePlans,
+  validateSubtasks,
+  adoptDecomposition,
+  analysisStatus,
+  analysisSignature,
+  analyzeItem,
+  parseAnalysis,
+  createKanbanAutomation,
+  dependencyResults,
+  analysisHistory,
+  boardDeletionBlockers,
+  deletionPreview,
+  createBoardDeletion,
+  withBoardDeletion,
+  cancelTaskMaintenance,
+  cancelTaskReplies,
+  scanBoardStopWork,
+  scanTaskControls,
+  assembleKanbanRuntime,
+  drainBoardAnalyses,
+  workContext
+};
+//# sourceMappingURL=chunk-FEE2YBZ7.js.map