@nestos/kanban 0.0.0-stage → 0.5.1

package/dist/chunk-OHQTKGQN.js

@@ -0,0 +1,1498 @@
+import {
+  executionObservationChanged
+} from "./chunk-RQP77ZTY.js";
+import {
+  assigneeKey,
+  candidates,
+  discoveryState,
+  eligible,
+  executable,
+  identity,
+  owned,
+  participant,
+  policy,
+  principal,
+  principalKey,
+  requireValue,
+  text,
+  validateBoard,
+  validateCandidates,
+  validateEstimate,
+  workType
+} from "./chunk-ATUFFNLV.js";
+import {
+  KanbanError
+} from "./chunk-G6FCDLDF.js";
+import {
+  TASK_START_DELAY_MS,
+  taskDue,
+  taskEditing,
+  taskStartAt
+} from "./chunk-O4OGAAV4.js";
+import {
+  executableWorkItem,
+  sameAutomationBinding
+} from "./chunk-5XKOCKY2.js";
+import {
+  randomUUID,
+  sha256HexSync
+} from "./chunk-TB2RZGDV.js";
+import {
+  boardAllowsStart
+} from "./chunk-QTMTBEBA.js";
+
+// src/planning.ts
+function plan(item) {
+  return item.planning ?? { kind: "task", priority: 2, dependencies: [], references: [] };
+}
+function summary(item) {
+  return {
+    launch: item.launch,
+    analysis: item.analysis,
+    control: item.control,
+    issues: item.issues,
+    blocked: item.blocked,
+    id: item.id,
+    number: item.number,
+    title: item.title,
+    status: item.status,
+    revision: item.revision,
+    createdAt: item.createdAt,
+    updatedAt: item.updatedAt,
+    discoveryFingerprint: item.origin?.fingerprint,
+    pendingAmendments: item.amendments?.filter((proposal) => proposal.status === "pending").length,
+    externalRefs: item.externalRefs,
+    closedAt: item.closedAt,
+    planning: plan(item),
+    sessionIds: item.participants.map((p) => p.sessionId)
+  };
+}
+function terminal(item) {
+  return item.status === "completed" || item.status === "cancelled";
+}
+function catalog(state) {
+  return [...state.board.items.map(summary), ...state.archiveIndex ?? []];
+}
+function limits(state) {
+  const p = state.board.policy;
+  return { ready: p.maxReady ?? 20, inProgress: p.maxInProgress ?? 3, perAgent: p.maxInProgressPerAssignee ?? p.maxInProgressPerAgent ?? 1, perAssignee: p.maxInProgressPerAssignee ?? p.maxInProgressPerAgent ?? 1 };
+}
+function validatePlan(state, item, value) {
+  requireValue(typeof value.kind === "string" && Number.isInteger(value.priority) && value.priority >= 0 && value.priority <= 4, "INVALID_PLANNING");
+  requireValue(Array.isArray(value.dependencies) && value.dependencies.length <= 100 && Array.isArray(value.references) && value.references.length <= 100, "PLANNING_LIMIT");
+  value.dependencies.forEach(identity);
+  value.references.forEach(text);
+  if (value.area !== void 0) identity(value.area);
+  if (value.milestone !== void 0) identity(value.milestone);
+  requireValue(value.execution === void 0 || ["direct", "children"].includes(value.execution), "INVALID_EXECUTION_MODE");
+  const type = workType(state.board, value.kind);
+  if (value.dueAt !== void 0) requireValue(Number.isFinite(value.dueAt) && value.dueAt >= 0, "INVALID_DUE_DATE");
+  const all = catalog(state), parent = all.find((i) => i.id === value.parentId);
+  if (value.parentId) {
+    identity(value.parentId);
+    requireValue(parent && !parent.archivedAt && !terminal(parent) && !["claimed", "review"].includes(parent.status), "PARENT_UNAVAILABLE");
+    requireValue(parent.id !== item.id && workType(state.board, parent.planning.kind).rank < type.rank, "INVALID_PARENT_KIND");
+  }
+  requireValue(value.execution === "children" || !all.some((child) => child.planning.parentId === item.id), "CHILDREN_REQUIRE_AGGREGATION");
+  requireValue(!all.some((child) => child.planning.parentId === item.id && workType(state.board, child.planning.kind).rank <= type.rank), "INVALID_CHILD_KIND");
+  for (const id of value.dependencies) requireValue(id !== item.id && all.some((i) => i.id === id), "INVALID_DEPENDENCY");
+  const visited = /* @__PURE__ */ new Set(), pending = [...value.dependencies];
+  while (pending.length) {
+    const id = pending.pop();
+    requireValue(id !== item.id, "DEPENDENCY_CYCLE");
+    if (visited.has(id)) continue;
+    visited.add(id);
+    pending.push(...all.find((i) => i.id === id)?.planning.dependencies ?? []);
+  }
+}
+function assertReady(state, item) {
+  requireValue(executable(state.board, item), "PLAN_NOT_EXECUTABLE");
+  requireValue(!item.blocked, "ITEM_BLOCKED");
+  const all = catalog(state);
+  requireValue(plan(item).dependencies.every((id) => all.find((i) => i.id === id)?.status === "completed"), "DEPENDENCIES_UNFINISHED");
+}
+function setStage(state, item, stage, now) {
+  requireValue(["proposed", "backlog", "open"].includes(item.status), "ITEM_NOT_PLANNABLE");
+  requireValue(stage === "backlog" || stage === "open", "INVALID_STAGE");
+  if (stage === "open") {
+    assertReady(state, item);
+    requireValue(item.status === "open" || state.board.items.filter((i) => i.status === "open").length < limits(state).ready, "READY_LIMIT");
+  }
+  item.status = stage;
+  item.readyAt = now;
+  item.updatedAt = now;
+  item.revision++;
+}
+function automaticStage(state, item) {
+  const all = catalog(state);
+  const dependenciesComplete = plan(item).dependencies.every((id) => all.find((i) => i.id === id)?.status === "completed");
+  return executable(state.board, item) && !item.blocked && dependenciesComplete && state.board.items.filter((i) => i.status === "open").length < limits(state).ready ? "open" : "backlog";
+}
+
+// src/amendments.ts
+var textOf = (item) => ({ title: item.title, responsibility: item.responsibility, acceptance: item.acceptance });
+var textDigest = (item) => sha256HexSync(JSON.stringify(textOf(item)));
+function workFingerprint(item) {
+  const planning = plan(item);
+  return sha256HexSync(JSON.stringify({
+    text: textOf(item),
+    kind: planning.kind,
+    parentId: planning.parentId ?? null,
+    area: planning.area ?? null,
+    milestone: planning.milestone ?? null,
+    priority: planning.priority,
+    dependencies: [...planning.dependencies].sort(),
+    dueAt: planning.dueAt ?? null
+  }));
+}
+function validateSources(sources) {
+  requireValue(Array.isArray(sources) && sources.length <= 100, "SOURCE_LIMIT");
+  for (const source of sources) {
+    identity(source.sessionId);
+    identity(source.messageId);
+    identity(source.revision);
+    requireValue(source.role === "user" || source.role === "assistant", "INVALID_SOURCE");
+  }
+}
+function proposeAmendment(item, change, actor, now, runId) {
+  text(change.title);
+  text(change.responsibility);
+  text(change.acceptance);
+  validateSources(change.sources);
+  const proposed = textOf(change), fingerprint = textDigest(proposed);
+  if (textDigest(item) === fingerprint || item.amendments?.some((p) => p.fingerprint === fingerprint)) return;
+  requireValue((item.amendments?.length ?? 0) < 20, "AMENDMENT_LIMIT");
+  (item.amendments ??= []).push({
+    runId,
+    id: `amendment-${sha256HexSync(JSON.stringify([runId, item.id, fingerprint]))}`,
+    fingerprint,
+    baseRevision: item.revision,
+    baseDigest: textDigest(item),
+    proposed,
+    proposedBy: principal(actor),
+    sources: structuredClone(change.sources),
+    createdAt: now,
+    status: "pending"
+  });
+}
+function requireReviewer(board, actor) {
+  const key = principalKey(principal(actor));
+  requireValue(
+    board.members?.some((m) => principalKey(m) === key && m.roles?.some((role) => role === "coordinator" || role === "reviewer")),
+    "REVIEWER_REQUIRED"
+  );
+}
+function reviewAmendment(board, command, actor, now) {
+  requireReviewer(board, actor);
+  const item = board.items.find((i) => i.id === command.itemId), proposal = item?.amendments?.find((p) => p.id === command.amendmentId);
+  requireValue(item && proposal?.status === "pending", "AMENDMENT_NOT_PENDING");
+  if (command.accept) {
+    requireValue(principal(actor).kind === "human" || principalKey(proposal.proposedBy) !== principalKey(principal(actor)), "INDEPENDENT_REVIEW_REQUIRED");
+    requireValue(["proposed", "backlog", "open"].includes(item.status), "ITEM_NOT_PLANNABLE");
+    requireValue(textDigest(item) === proposal.baseDigest, "AMENDMENT_STALE");
+    Object.assign(item, proposal.proposed);
+    if (item.status === "open") {
+      item.status = "backlog";
+      item.readyAt = now;
+    }
+  } else {
+    requireValue(!!command.reason?.trim(), "AMENDMENT_REASON_REQUIRED");
+    text(command.reason);
+  }
+  proposal.status = command.accept ? "accepted" : "rejected";
+  proposal.reviewedAt = now;
+  proposal.reviewedBy = principal(actor);
+  proposal.reason = command.reason;
+  item.updatedAt = now;
+  item.revision++;
+}
+
+// src/project-records.ts
+function isRecordCommand(command) {
+  return ["append-record", "review-record", "link-record"].includes(command.type);
+}
+function applyRecord(state, command, actor, now, forceDraft = false) {
+  if (command.type === "append-record") {
+    append(state, command, actor, now, forceDraft);
+    return;
+  }
+  const record = state.records?.find((record2) => record2.id === command.recordId);
+  requireValue(record, "RECORD_NOT_FOUND");
+  if (command.type === "link-record") {
+    validateItems(state, [command.itemId]);
+    if (!record.itemIds.includes(command.itemId)) {
+      requireValue(record.itemIds.length < 100, "RECORD_LINK_LIMIT");
+      record.itemIds.push(command.itemId);
+    }
+  } else {
+    requireReviewer(state.board, actor);
+    requireValue(record.status === "draft", "RECORD_NOT_DRAFT");
+    if (command.accept) {
+      requireValue(principal(actor).kind === "human" || principalKey(record.author) !== principalKey(principal(actor)), "INDEPENDENT_REVIEW_REQUIRED");
+      supersede(state, record, now);
+      record.status = "confirmed";
+    } else record.status = "rejected";
+    record.reviewedBy = principal(actor);
+  }
+  record.updatedAt = now;
+  record.revision++;
+}
+function append(state, command, actor, now, forceDraft) {
+  validateSources(command.record.sources);
+  const { id, kind, title, content, rationale, itemIds, sources, supersedes, coordination, externalRefs } = command.record;
+  const input = structuredClone({ id, kind, title, content, rationale, itemIds, sources: sources.map((source) => ({ sessionId: source.sessionId, messageId: source.messageId, revision: source.revision, role: source.role })), supersedes, ...coordination ? { coordination } : {}, ...externalRefs ? { externalRefs } : {} });
+  identity(input.id);
+  text(input.title);
+  text(input.content);
+  validateRecordReferences(externalRefs);
+  requireValue(input.kind === "log" || input.kind === "decision", "INVALID_RECORD_KIND");
+  requireValue(!state.records?.some((record) => record.id === input.id), "RECORD_EXISTS");
+  requireValue((state.records?.length ?? 0) < 200, "RECORD_LIMIT");
+  validateItems(state, input.itemIds);
+  validateSources(input.sources);
+  if (input.rationale !== void 0) text(input.rationale);
+  if (input.kind === "decision") text(input.rationale ?? "");
+  if (coordination) validateCoordination(state, input);
+  if (input.supersedes) {
+    identity(input.supersedes);
+    requireValue(input.kind === "decision" && input.supersedes !== input.id && state.records?.some((record) => record.id === input.supersedes && record.kind === "decision" && record.status === "confirmed"), "INVALID_SUPERSEDED_RECORD");
+  }
+  const author = principal(actor), manual = author.kind === "human" && !forceDraft;
+  (state.records ??= []).push({
+    ...input,
+    author,
+    origin: manual ? "manual" : "flow",
+    status: manual && input.kind === "log" ? "confirmed" : "draft",
+    revision: 1,
+    createdAt: now,
+    updatedAt: now
+  });
+}
+function validateCoordination(state, input) {
+  requireValue(input.kind === "decision", "DECISION_COORDINATION_ONLY");
+  for (const owner of [input.coordination.manager, input.coordination.executor].filter(Boolean)) {
+    requireValue(owner && ["agent", "human", "service"].includes(owner.kind), "INVALID_PRINCIPAL");
+    identity(owner.id);
+    const member = state.board.members?.find((member2) => principalKey(member2) === principalKey(owner));
+    requireValue(member, "ASSIGNEE_NOT_REGISTERED");
+    if (owner === input.coordination.manager) requireValue(member.roles?.includes("coordinator"), "COORDINATOR_REQUIRED");
+  }
+}
+function validateItems(state, ids) {
+  requireValue(Array.isArray(ids) && ids.length <= 100 && new Set(ids).size === ids.length, "RECORD_LINK_LIMIT");
+  for (const id of ids) {
+    identity(id);
+    requireValue(state.board.items.some((item) => item.id === id) || state.archiveIndex?.some((item) => item.id === id), "ITEM_NOT_FOUND");
+  }
+}
+function supersede(state, record, now) {
+  if (!record.supersedes) return;
+  const previous = state.records?.find((entry) => entry.id === record.supersedes);
+  requireValue(previous?.kind === "decision" && previous.status === "confirmed", "SUPERSEDED_RECORD_CHANGED");
+  previous.status = "superseded";
+  previous.supersededBy = record.id;
+  previous.revision++;
+  previous.updatedAt = now;
+}
+function queryRecords(state, query = {}, summaries = (state.records ?? []).map(recordSummary)) {
+  const { cursor, ...filter } = query, limit = query.limit ?? 50;
+  requireValue(Number.isSafeInteger(limit) && limit > 0 && limit <= 200, "INVALID_LIMIT");
+  if (query.kind) requireValue(["log", "decision"].includes(query.kind), "INVALID_RECORD_KIND");
+  if (query.itemId !== void 0) identity(query.itemId);
+  if (query.status) requireValue(["draft", "confirmed", "rejected", "superseded"].includes(query.status), "INVALID_RECORD_STATUS");
+  const digest = sha256HexSync(JSON.stringify(filter));
+  let offset = 0;
+  if (cursor) {
+    let decoded;
+    try {
+      decoded = JSON.parse(decodeURIComponent(cursor));
+    } catch {
+      requireValue(false, "INVALID_CURSOR");
+    }
+    requireValue(decoded && typeof decoded === "object" && !Array.isArray(decoded) && typeof decoded.filter === "string" && typeof decoded.revision === "number", "INVALID_CURSOR");
+    requireValue(decoded.revision === state.board.revision && decoded.filter === digest, "CURSOR_STALE");
+    offset = decoded.offset;
+    requireValue(Number.isSafeInteger(offset) && offset >= 0, "INVALID_CURSOR");
+  }
+  const matched = summaries.filter((record) => (!query.kind || query.kind === record.kind) && (!query.itemId || record.itemIds.includes(query.itemId)) && (!query.status || query.status === record.status)).sort((a, b) => b.createdAt - a.createdAt || a.id.localeCompare(b.id));
+  const items = matched.slice(offset, offset + limit);
+  return { revision: state.board.revision, total: matched.length, items, ...offset + limit < matched.length ? { nextCursor: encodeURIComponent(JSON.stringify({ revision: state.board.revision, filter: digest, offset: offset + limit })) } : {} };
+}
+function recordFingerprint(record) {
+  return sha256HexSync(JSON.stringify({
+    kind: record.kind,
+    title: record.title,
+    content: record.content,
+    rationale: record.rationale ?? null,
+    itemIds: [...record.itemIds].sort(),
+    sources: record.sources.map((source) => JSON.stringify([source.sessionId, source.messageId, source.role])).sort(),
+    ...record.coordination ? { coordination: record.coordination } : {},
+    ...record.externalRefs ? { externalRefs: record.externalRefs } : {}
+  }));
+}
+function validateRecordReferences(refs) {
+  if (refs === void 0) return;
+  requireValue(Array.isArray(refs) && refs.length <= 100, "REFERENCE_LIMIT");
+  const keys = /* @__PURE__ */ new Set();
+  for (const ref of refs) {
+    requireValue(ref && typeof ref === "object", "INVALID_REFERENCE");
+    identity(ref.system);
+    identity(ref.id);
+    if (ref.revision !== void 0) text(ref.revision);
+    const key = JSON.stringify([ref.system, ref.id]);
+    requireValue(!keys.has(key), "DUPLICATE_REFERENCE");
+    keys.add(key);
+  }
+}
+function recordSummary(record) {
+  const { content: _content, rationale: _rationale, sources, ...metadata } = record;
+  return { ...metadata, sessionIds: [...new Set(sources.map((source) => source.sessionId))] };
+}
+
+// src/board.ts
+function createBoardState(input, actor, now) {
+  const board = { ...structuredClone(input), policy: policy(input.policy), revision: 1, items: [], participants: [] };
+  validateBoard(board);
+  if (actor.sessionId) participant(board.participants, actor.sessionId, actor.agentId, "creator", true, now);
+  for (const session of board.policy.escalationSessionIds) participant(board.participants, session, void 0, "escalation", true, now);
+  return { schema: 1, board, sequence: 0, events: [], escalations: [] };
+}
+
+// src/storage-codec.ts
+var boardKey = (id) => `board/${encodeURIComponent(id)}`;
+var archiveKey = (board, item) => `archive/${encodeURIComponent(board)}/${encodeURIComponent(item)}`;
+var rowKey = (kind, board, id) => `${kind}/${encodeURIComponent(board)}/${encodeURIComponent(id)}`;
+function rowKeys(raw) {
+  if (raw === null) return [];
+  const saved = JSON.parse(raw);
+  if (saved.layout !== 2) return [];
+  requireValue(Array.isArray(saved.itemIds) && Array.isArray(saved.recordIds) && saved.state?.board, "INVALID_STORAGE");
+  return [...saved.itemIds.map((id) => rowKey("item", saved.state.board.id, id)), ...saved.recordIds.map((id) => rowKey("record", saved.state.board.id, id))];
+}
+async function hydrate(saved, bodies) {
+  if (saved.raw === null) return null;
+  const parsed = JSON.parse(saved.raw);
+  if (parsed.layout !== 2) return validateState(parsed);
+  const state = validateState(parsed.state), id = state.board.id;
+  state.board.items = await Promise.all(parsed.itemIds.map(async (itemId) => {
+    const item = await decodeRow(requiredRow(saved, rowKey("item", id, itemId)), bodies);
+    requireValue(item.id === itemId, "INVALID_STORAGE");
+    return item;
+  }));
+  state.records = await Promise.all(parsed.recordIds.map(async (recordId) => {
+    const record = await decodeRow(requiredRow(saved, rowKey("record", id, recordId)), bodies);
+    requireValue(record.id === recordId, "INVALID_STORAGE");
+    return record;
+  }));
+  return state;
+}
+async function encodeBoard(state, bodies) {
+  const rows = {}, id = state.board.id;
+  for (const item of state.board.items) rows[rowKey("item", id, item.id)] = await encodeRow(item, bodies);
+  for (const record of state.records ?? []) rows[rowKey("record", id, record.id)] = await encodeRow(record, bodies);
+  const manifest = {
+    itemIndex: state.board.items.map(summary),
+    recordIndex: (state.records ?? []).map(recordSummary),
+    layout: 2,
+    generation: randomUUID(),
+    state: { ...state, board: { ...state.board, items: [] }, records: [] },
+    itemIds: state.board.items.map((item) => item.id),
+    recordIds: (state.records ?? []).map((record) => record.id)
+  };
+  return { raw: JSON.stringify(manifest), rows };
+}
+function rowChanges(before, after) {
+  const writes = Object.entries(after.rows).filter(([key, value]) => before.rows[key] !== value).map(([key, value]) => ({ key, value }));
+  for (const key of Object.keys(before.rows)) if (!(key in after.rows)) writes.push({ key, value: null });
+  return writes;
+}
+function receiptDigest(fingerprint) {
+  return `sha256:v1:${sha256HexSync(fingerprint)}`;
+}
+function verifyReceipt(saved, fingerprint) {
+  requireValue(saved === fingerprint || saved === receiptDigest(fingerprint), "IDEMPOTENCY_CONFLICT");
+}
+async function encodeRow(value, bodies) {
+  const raw = JSON.stringify(value), bytes = new TextEncoder().encode(raw);
+  if (!bodies || bytes.length <= 8192) return raw;
+  const ref = { body: "kanban-body/v1", sha256: sha256HexSync(bytes), bytes: bytes.length };
+  const existing = await bodies.read(ref.sha256);
+  if (existing !== null) verifyBody(existing, ref);
+  else {
+    let failure;
+    try {
+      await bodies.write(ref.sha256, bytes.buffer);
+    } catch (error) {
+      failure = error;
+    }
+    const confirmed = await bodies.read(ref.sha256);
+    if (confirmed === null) throw failure ?? new KanbanError("BODY_WRITE_UNCONFIRMED");
+    verifyBody(confirmed, ref);
+  }
+  return JSON.stringify(ref);
+}
+async function decodeRow(raw, bodies) {
+  const parsed = JSON.parse(raw);
+  if (parsed?.body !== "kanban-body/v1") return parsed;
+  requireValue(/^[a-f0-9]{64}$/.test(parsed.sha256) && Number.isSafeInteger(parsed.bytes) && parsed.bytes > 8192, "INVALID_BODY_REFERENCE");
+  requireValue(bodies, "BODY_STORE_REQUIRED");
+  const bytes = await bodies.read(parsed.sha256);
+  requireValue(bytes !== null, "BODY_MISSING");
+  verifyBody(bytes, parsed);
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+}
+function verifyBody(bytes, ref) {
+  requireValue(bytes instanceof ArrayBuffer && bytes.byteLength === ref.bytes && sha256HexSync(bytes) === ref.sha256, "BODY_INTEGRITY");
+}
+function requiredRow(saved, key) {
+  requireValue(typeof saved.rows[key] === "string", "MISSING_STORAGE_ROW");
+  return saved.rows[key];
+}
+function validateState(state) {
+  requireValue(state?.schema === 1 && state.board && Array.isArray(state.board.items) && Array.isArray(state.events), "INVALID_STORAGE");
+  return state;
+}
+function indexedView(raw) {
+  if (raw === null) return null;
+  const parsed = JSON.parse(raw);
+  if (parsed.layout === 2 && Array.isArray(parsed.itemIndex) && Array.isArray(parsed.recordIndex))
+    return { state: validateState(parsed.state), items: parsed.itemIndex, records: parsed.recordIndex };
+  return null;
+}
+function viewFromState(state) {
+  return { state: { ...state, board: { ...state.board, items: [] }, records: [] }, items: state.board.items.map(summary), records: (state.records ?? []).map(recordSummary) };
+}
+
+// src/numbering.ts
+var boardCounterKey = "counter/board";
+var boardNumberKey = (number) => `reference/board/${number}`;
+function counter(raw) {
+  requireValue(raw === null || /^(0|[1-9]\d*)$/.test(raw), "INVALID_NUMBER_COUNTER");
+  const value = raw === null ? 0 : Number(raw);
+  requireValue(Number.isSafeInteger(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER, "INVALID_NUMBER_COUNTER");
+  return value;
+}
+function storedBoardNumber(raw) {
+  if (raw === null) return void 0;
+  const parsed = JSON.parse(raw), number = (parsed.layout === 2 ? parsed.state?.board : parsed.board)?.number;
+  if (number !== void 0) requireValue(Number.isSafeInteger(number) && number > 0, "INVALID_NUMBERING");
+  return number;
+}
+function patchBoardNumber(raw, number) {
+  const parsed = JSON.parse(raw);
+  parsed.state.board.number = number;
+  return JSON.stringify(parsed);
+}
+function numberEntities(state) {
+  const high = state.numbering ??= { item: 0, log: 0, decision: 0 };
+  const items = [...state.board.items, ...state.archiveIndex ?? [], ...(state.archiveWrites ?? []).flatMap((write) => write.value ? [write.value.item] : [])];
+  high.item = assign(items, high.item);
+  for (const kind of ["log", "decision"]) high[kind] = assign((state.records ?? []).filter((record) => record.kind === kind), high[kind]);
+}
+function assign(rows, high) {
+  counter(String(high));
+  const used = /* @__PURE__ */ new Map(), known = /* @__PURE__ */ new Map();
+  for (const row of rows) if (row.number !== void 0) {
+    requireValue(Number.isSafeInteger(row.number) && row.number > 0 && (!used.has(row.number) || used.get(row.number) === row.id) && (!known.has(row.id) || known.get(row.id) === row.number), "INVALID_NUMBERING");
+    used.set(row.number, row.id);
+    known.set(row.id, row.number);
+    high = Math.max(high, row.number);
+  }
+  for (const row of rows) if (row.number === void 0) {
+    if (!known.has(row.id)) {
+      requireValue(high < Number.MAX_SAFE_INTEGER, "NUMBER_COUNTER_EXHAUSTED");
+      known.set(row.id, ++high);
+    }
+    row.number = known.get(row.id);
+  }
+  return high;
+}
+function allocateBoardNumber(raw, high) {
+  const known = storedBoardNumber(raw);
+  if (known !== void 0) return known;
+  requireValue(high < Number.MAX_SAFE_INTEGER, "NUMBER_COUNTER_EXHAUSTED");
+  return high + 1;
+}
+
+// src/archives.ts
+function archiveItems(state, ids, reason, now) {
+  text(reason);
+  requireValue(ids.length > 0 && ids.length <= 50 && new Set(ids).size === ids.length, "ARCHIVE_BATCH_LIMIT");
+  const items = ids.map((id) => state.board.items.find((i) => i.id === id));
+  requireValue(items.every((item) => item && terminal(item)), "ARCHIVE_REQUIRES_CLOSED_ITEM");
+  for (const item of items) {
+    const archived = { item, archivedAt: now, reason };
+    (state.archiveIndex ??= []).push({ ...summary(item), archivedAt: now, archiveReason: reason });
+    (state.archiveWrites ??= []).push({ id: item.id, value: archived });
+  }
+  const selected = new Set(ids);
+  state.board.items = state.board.items.filter((i) => !selected.has(i.id));
+}
+function restoreItem(state, id, now) {
+  const record = state.restore;
+  requireValue(record?.item.id === id && state.archiveIndex?.some((i) => i.id === id), "ARCHIVED_ITEM_NOT_FOUND");
+  requireValue(!state.board.items.some((i) => i.id === id), "ITEM_EXISTS");
+  record.item.restoredAt = now;
+  record.item.updatedAt = now;
+  record.item.revision++;
+  state.board.items.push(record.item);
+  state.archiveIndex = state.archiveIndex.filter((i) => i.id !== id);
+  (state.archiveWrites ??= []).push({ id, value: null });
+  delete state.restore;
+}
+function archiveExpired(state, now) {
+  const age = state.board.policy.archiveAfterMs;
+  if (age === void 0) return [];
+  const ids = state.board.items.filter((i) => terminal(i) && now - Math.max(i.closedAt ?? i.updatedAt, i.restoredAt ?? 0) >= age).slice(0, 50).map((i) => i.id);
+  if (ids.length) archiveItems(state, ids, "retention-policy", now);
+  return ids;
+}
+
+// src/planning-commands.ts
+function planningCommand(command) {
+  return ["edit-item", "plan-item", "set-stage", "publish-proposal", "cancel-item", "close-plan", "archive-items", "restore-item", "block-item", "unblock-item", "link-reference", "release-item"].includes(command.type);
+}
+function applyPlanningCommand(state, command, now, actor, internal = false) {
+  if (command.type === "archive-items") return archiveItems(state, command.itemIds, command.reason, now);
+  if (command.type === "restore-item") return restoreItem(state, command.itemId, now);
+  const item = state.board.items.find((i) => i.id === command.itemId);
+  requireValue(item, "ITEM_NOT_FOUND");
+  if (isOperational(command)) operate(item, command, now, actor);
+  else {
+    if (!internal && ["edit-item", "plan-item", "review-amendment"].includes(command.type)) assertDefinitionEditable(item, now);
+    updatePlan(state, item, command, now);
+  }
+}
+function isOperational(command) {
+  return ["block-item", "unblock-item", "link-reference", "release-item"].includes(command.type);
+}
+function operate(item, command, now, actor) {
+  if (command.type === "release-item") {
+    requireValue(["claimed", "review"].includes(item.status) && item.owner?.token === command.token, "OWNER_MISMATCH");
+    requireValue(["backlog", "cancelled"].includes(command.next), "INVALID_STAGE");
+    text(command.reason);
+    item.status = command.next;
+    if (command.next === "cancelled") {
+      item.closedAt = now;
+      item.closureReason = command.reason;
+    }
+    delete item.owner;
+    delete item.transfer;
+    delete item.estimate;
+  } else if (command.type === "link-reference") attachReference(item, command.reference);
+  else {
+    requireValue(!terminal(item), "ITEM_COMPLETED");
+    if (item.status === "claimed") owned(item, actor, command.token ?? "", now);
+    if (command.type === "block-item") {
+      text(command.reason);
+      item.blocked = { reason: command.reason, at: now };
+    } else delete item.blocked;
+  }
+  item.updatedAt = now;
+  item.revision++;
+}
+function updatePlan(state, item, command, now) {
+  if (command.type === "cancel-item") requireValue(item.launch?.admittedAt === void 0, "TASK_CONTROL_REQUIRED");
+  if (command.type === "publish-proposal") {
+    requireValue(item.status === "proposed", "NOT_PROPOSED");
+    return setStage(state, item, command.stage ?? "backlog", now);
+  }
+  if (command.type === "set-stage") return setStage(state, item, command.stage, now);
+  requireValue(["proposed", "backlog", "open"].includes(item.status), "ITEM_NOT_PLANNABLE");
+  if (command.type === "edit-item") {
+    text(command.title);
+    text(command.responsibility);
+    text(command.acceptance);
+    item.title = command.title;
+    item.responsibility = command.responsibility;
+    item.acceptance = command.acceptance;
+    if (item.status === "open") return setStage(state, item, "backlog", now);
+  } else if (command.type === "plan-item") {
+    validatePlan(state, item, command.planning);
+    item.planning = command.planning;
+    if (item.status === "open") return setStage(state, item, "backlog", now);
+  } else {
+    requireValue(catalog(state).filter((i) => i.planning.parentId === item.id).every(terminal), "CHILDREN_UNFINISHED");
+    if (command.type === "close-plan") {
+      requireValue(!executable(state.board, item), "TASK_REQUIRES_REVIEW");
+      text(command.resultRef);
+      const children = catalog(state).filter((child) => child.planning.parentId === item.id);
+      if (item.planning?.execution === "children") requireValue(children.length > 0 && children.every((child) => child.status === "completed"), "CHILDREN_UNFINISHED");
+      item.status = "completed";
+      item.resultRef = command.resultRef;
+    } else {
+      text(command.reason);
+      item.status = "cancelled";
+      item.closureReason = command.reason;
+    }
+    item.closedAt = now;
+  }
+  item.updatedAt = now;
+  item.revision++;
+}
+function attachReference(item, reference) {
+  identity(reference.system);
+  identity(reference.id);
+  if (reference.revision !== void 0) text(reference.revision);
+  item.externalRefs ??= [];
+  if (item.externalRefs.some((r) => r.system === reference.system && r.id === reference.id && r.revision === reference.revision)) return;
+  requireValue(item.externalRefs.length < 100, "REFERENCE_LIMIT");
+  item.externalRefs.push(reference);
+}
+
+// src/workflow-plans.ts
+function requireCoordinator(state, actor) {
+  requireValue(state.board.members?.some((member) => principalKey(member) === principalKey(principal(actor)) && member.roles?.includes("coordinator")), "COORDINATOR_REQUIRED");
+}
+function publishPlan(state, plan2, actor, apply) {
+  requireCoordinator(state, actor);
+  requireValue(plan2 && typeof plan2 === "object", "INVALID_WORK_PLAN");
+  identity(plan2.id);
+  requireValue(plan2.schema === "kanban.plan/1" && typeof plan2.sealed === "boolean" && Array.isArray(plan2.items) && plan2.items.length > 0 && plan2.items.length <= 100, "INVALID_WORK_PLAN");
+  const workflow = state.workflow, previous = workflow.plans[plan2.id];
+  requireValue(Number.isSafeInteger(plan2.revision) && plan2.revision === (previous?.revision ?? 0) + 1, "PLAN_REVISION_CONFLICT");
+  requireValue(!Object.values(workflow.dispatches).some((dispatch) => dispatch.planId === plan2.id && ["prepared", "running", "unknown", "succeeded"].includes(dispatch.outcome)), "PLAN_EXECUTION_UNSETTLED");
+  if (plan2.decisionId) {
+    const decision = state.records?.find((record) => record.id === plan2.decisionId && record.kind === "decision" && record.status === "confirmed");
+    requireValue(decision, "DECISION_NOT_CONFIRMED");
+    if (decision.coordination) requireValue(principalKey(decision.coordination.manager) === principalKey(principal(actor)), "DECISION_MANAGER_REQUIRED");
+  }
+  if (plan2.rootItemId) {
+    const root = state.board.items.find((item) => item.id === plan2.rootItemId);
+    requireValue(root && !root.owner && ["backlog", "open"].includes(root.status), "PLAN_ROOT_UNAVAILABLE");
+    if (root.planning?.execution !== "children") apply({ type: "plan-item", itemId: root.id, planning: { ...plan(root), execution: "children" } });
+  }
+  const ordered = orderWork(plan2.items, state), definitions = {};
+  for (const item of ordered) {
+    const digest = sha256HexSync(JSON.stringify(item));
+    requireValue(!Object.values(workflow.plans).some((other) => other.id !== plan2.id && other.itemIds.includes(item.id)), "ITEM_IN_OTHER_PLAN");
+    const exists = state.board.items.some((old) => old.id === item.id) || state.archiveIndex?.some((old) => old.id === item.id);
+    if (exists && previous?.definitions[item.id]?.digest !== digest) {
+      requireValue(!previous?.definitions[item.id], "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+      adoptItem(state, item, apply);
+    }
+    if (!exists) apply({
+      type: "create-item",
+      item: { id: item.id, title: item.title, responsibility: item.responsibility, acceptance: item.acceptance, eligiblePrincipals: [item.assignee], externalRefs: item.externalRefs },
+      planning: { kind: item.workType ?? state.board.defaultWorkType ?? "task", priority: 2, dependencies: item.dependsOn, references: [], ...plan2.rootItemId ? { parentId: plan2.rootItemId } : {} }
+    });
+    definitions[item.id] = { digest, inputs: item.inputs, outputs: item.outputs ?? [] };
+  }
+  workflow.plans[plan2.id] = { schema: plan2.schema, id: plan2.id, revision: plan2.revision, decisionId: plan2.decisionId, rootItemId: plan2.rootItemId, sealed: plan2.sealed, itemIds: ordered.map((item) => item.id), definitions };
+}
+function adoptItem(state, definition, apply) {
+  const item = state.board.items.find((item2) => item2.id === definition.id);
+  requireValue(item && definition.expectedRevision === item.revision && ["backlog", "open"].includes(item.status) && !item.owner && !item.blocked, "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+  requireValue(!definition.workType || definition.workType === item.planning?.kind, "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+  requireValue(!definition.externalRefs || definition.externalRefs.every((ref) => item.externalRefs?.some((existing) => JSON.stringify(existing) === JSON.stringify(ref))), "PLAN_RESOURCE_MISMATCH");
+  requireValue(item.title === definition.title && item.responsibility === definition.responsibility && item.acceptance === definition.acceptance, "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+  requireValue(plan(item).dependencies.every((id) => definition.dependsOn.includes(id)), "EXISTING_DEPENDENCY_REQUIRED");
+  apply({ type: "plan-item", itemId: item.id, planning: { ...plan(item), dependencies: definition.dependsOn } });
+  item.eligiblePrincipals = [definition.assignee];
+  delete item.eligibleAgentIds;
+  validateCandidates(state.board, item, true);
+}
+function orderWork(items, state) {
+  for (const item of items) validateDefinition(item);
+  const ids = new Set(items.map((item) => item.id));
+  requireValue(ids.size === items.length, "DUPLICATE_PLAN_ITEM");
+  for (const item of items) {
+    identity(item.id);
+    requireValue(Array.isArray(item.dependsOn) && item.dependsOn.length <= 100 && new Set(item.dependsOn).size === item.dependsOn.length, "INVALID_DEPENDENCIES");
+    requireValue(Object.keys(item.inputs ?? {}).length <= 100 && Array.isArray(item.outputs ?? []) && (item.outputs ?? []).length <= 100 && new Set(item.outputs ?? []).size === (item.outputs ?? []).length, "PLAN_BINDING_LIMIT");
+    for (const name of [...Object.keys(item.inputs ?? {}), ...item.outputs ?? []]) requireValue(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(name), "INVALID_OUTPUT_NAME");
+    for (const binding of Object.values(item.inputs ?? {})) {
+      requireValue(binding && item.dependsOn.includes(binding.fromItemId) && typeof binding.output === "string", "INPUT_DEPENDENCY_REQUIRED");
+      const producer = items.find((other) => other.id === binding.fromItemId), existing = Object.values(state.workflow.dispatches).some((dispatch) => dispatch.itemId === binding.fromItemId && dispatch.outcome === "accepted" && dispatch.outputs?.some((output) => output.name === binding.output));
+      requireValue(producer ? producer.outputs?.includes(binding.output) : existing, "OUTPUT_NOT_DECLARED");
+    }
+    for (const dependency of item.dependsOn) requireValue(ids.has(dependency) || [...state.board.items, ...state.archiveIndex ?? []].some((old) => old.id === dependency), "DEPENDENCY_NOT_FOUND");
+  }
+  const ordered = [], remaining = [...items], done = /* @__PURE__ */ new Set();
+  while (remaining.length) {
+    const next = remaining.findIndex((item2) => item2.dependsOn.every((id) => !ids.has(id) || done.has(id)));
+    requireValue(next >= 0, "DEPENDENCY_CYCLE");
+    const [item] = remaining.splice(next, 1);
+    ordered.push(item);
+    done.add(item.id);
+  }
+  return ordered;
+}
+function validateDefinition(item) {
+  requireValue(item && typeof item === "object" && !Array.isArray(item), "INVALID_WORK_DEFINITION");
+  const assignee = item.assignee;
+  requireValue(assignee && ["agent", "human", "service"].includes(assignee.kind), "INVALID_PRINCIPAL");
+  identity(assignee.id);
+  if (item.inputs !== void 0) requireValue(item.inputs && typeof item.inputs === "object" && !Array.isArray(item.inputs), "INVALID_INPUT_BINDINGS");
+  if (item.outputs !== void 0) requireValue(Array.isArray(item.outputs) && item.outputs.every((name) => typeof name === "string"), "INVALID_OUTPUT_NAMES");
+}
+
+// src/task-commands.ts
+var types = ["set-launch-mode", "retry-analysis", "begin-edit", "end-edit", "save-edit", "request-run", "admit-item", "report-analysis", "request-control", "control-receipt", "report-issue", "resolve-issue"];
+function taskCommand(command) {
+  return types.includes(command.type);
+}
+function assertDefinitionEditable(item, now, editId, actor) {
+  requireValue(["proposed", "backlog", "open"].includes(item.status) && !item.owner && item.launch?.admittedAt === void 0, "TASK_DEFINITION_FROZEN");
+  if (taskEditing(item, now)) requireValue(item.launch.editing.id === editId && !!actor && principalKey(item.launch.editing.principal) === principalKey(principal(actor)), "EDIT_LEASE_ACTIVE");
+}
+function applyTaskCommand(state, command, actor, now) {
+  const item = state.board.items.find((i) => i.id === command.itemId);
+  requireValue(item, "ITEM_NOT_FOUND");
+  item.launch ??= { startAt: taskStartAt(item) };
+  if (["begin-edit", "end-edit", "save-edit"].includes(command.type)) edit(state, item, command, actor, now);
+  else if (command.type === "retry-analysis") {
+    identity(command.retryId);
+    requireValue(["failed", "clarification"].includes(item.analysis?.state ?? "") && !item.owner, "ANALYSIS_NOT_RETRYABLE");
+    item.launch.analysisEpoch = command.retryId;
+    delete item.analysis;
+  } else if (command.type === "set-launch-mode") {
+    assertDefinitionEditable(item, now);
+    setMode(item, command.mode);
+  } else if (command.type === "request-run") {
+    assertDefinitionEditable(item, now);
+    item.launch.requestedAt ??= now;
+  } else if (command.type === "admit-item") {
+    requireCoordinator(state, actor);
+    assertDefinitionEditable(item, now);
+    requireValue(boardAllowsStart(state.board, item), "BOARD_EXECUTION_PAUSED");
+    requireValue(command.trigger === "manual" ? item.launch.requestedAt !== void 0 : taskDue(item, now), "START_NOT_DUE");
+    requireValue(!item.blocked && item.control?.action !== "pause", "ITEM_BLOCKED");
+    requireValue(item.planning?.dependencies.every((id) => catalog(state).find((i) => i.id === id)?.status === "completed") ?? true, "DEPENDENCIES_UNFINISHED");
+    item.launch.admittedAt = now;
+  } else if (command.type === "report-analysis") {
+    requireCoordinator(state, actor);
+    identity(command.operationId);
+    requireValue(command.status.itemId === item.id, "ANALYSIS_SCOPE_MISMATCH");
+    item.analysis = structuredClone(command.status);
+  } else if (command.type === "request-control") requestControl(state, item, command);
+  else if (command.type === "control-receipt") {
+    requireCoordinator(state, actor);
+    requireValue(item.control?.id === command.controlId, "STALE_CONTROL_RECEIPT");
+    requireValue(["accepted", "paused", "resumed", "failed", "unknown"].includes(command.state), "INVALID_CONTROL_STATE");
+    item.control.state = command.state;
+    item.control.code = command.code;
+  } else issues(state, item, command, actor);
+  item.updatedAt = now;
+  item.revision++;
+}
+function edit(state, item, command, actor, now) {
+  if (command.type === "begin-edit") {
+    assertDefinitionEditable(item, now, command.editId, actor);
+    identity(command.editId);
+    requireValue(Number.isSafeInteger(command.leaseMs) && command.leaseMs >= 1e3 && command.leaseMs <= 3e5, "INVALID_EDIT_LEASE");
+    item.launch.editing = { id: command.editId, principal: principal(actor), expiresAt: now + command.leaseMs };
+    return;
+  }
+  if (command.type !== "save-edit" && command.type !== "end-edit") return;
+  assertDefinitionEditable(item, now, command.editId, actor);
+  requireValue(taskEditing(item, now) && item.launch.editing.id === command.editId, "EDIT_LEASE_EXPIRED");
+  if (command.type === "save-edit") {
+    text(command.title);
+    text(command.responsibility);
+    text(command.acceptance);
+    validatePlan(state, item, command.planning);
+    if (command.launchMode !== void 0) setMode(item, command.launchMode);
+    Object.assign(item, { title: command.title, responsibility: command.responsibility, acceptance: command.acceptance, planning: command.planning });
+    if (command.externalRefs) {
+      item.externalRefs = [];
+      for (const ref of command.externalRefs) attachReference(item, ref);
+    }
+  }
+  if (command.type === "save-edit") for (const plan2 of Object.values(state.workflow?.plans ?? {})) {
+    const definition = plan2.definitions[item.id];
+    if (!definition) continue;
+    requireValue(Object.values(definition.inputs ?? {}).every((binding) => item.planning?.dependencies.includes(binding.fromItemId)), "EXISTING_DEPENDENCY_REQUIRED");
+    definition.digest = sha256HexSync(JSON.stringify([item.title, item.responsibility, item.acceptance, item.planning, item.externalRefs, definition.inputs, definition.outputs]));
+  }
+  delete item.launch.editing;
+}
+function requestControl(state, item, command) {
+  requireValue(!["completed", "cancelled", "review"].includes(item.status), "ITEM_COMPLETED");
+  identity(command.controlId);
+  requireValue(["pause", "resume"].includes(command.action), "INVALID_CONTROL_ACTION");
+  if (item.control?.id === command.controlId) {
+    requireValue(item.control.action === command.action, "IDEMPOTENCY_CONFLICT");
+    return;
+  }
+  requireValue(!item.control || !["requested", "unknown"].includes(item.control.state), "CONTROL_UNSETTLED");
+  const dispatch = Object.values(state.workflow?.dispatches ?? {}).find((d) => d.itemId === item.id && ["prepared", "running", "unknown"].includes(d.outcome));
+  requireValue(dispatch || item.launch?.admittedAt === void 0, "TASK_CONTROL_UNSUPPORTED");
+  requireValue(command.action === "pause" || item.control?.action === "pause", "TASK_NOT_PAUSED");
+  item.control = { id: command.controlId, dispatchId: dispatch?.id, action: command.action, state: "requested" };
+}
+function issues(state, item, command, actor) {
+  requireCoordinator(state, actor);
+  if (command.type === "report-issue") {
+    const issue = command.issue;
+    identity(issue.id);
+    identity(issue.attemptId);
+    requireValue(!issue.resolvedBy && ["clarification", "error"].includes(issue.type), "INVALID_ISSUE");
+    requireValue(state.workflow?.dispatches[issue.attemptId]?.itemId === item.id && item.owner?.token === state.workflow.dispatches[issue.attemptId].fence, "STALE_EXECUTION_RESULT");
+    item.issues ??= [];
+    const old = item.issues.find((i) => i.id === issue.id && i.attemptId === issue.attemptId);
+    if (!old) {
+      requireValue(item.issues.length < 200, "ISSUE_LIMIT");
+      item.issues.push(structuredClone(issue));
+    }
+  } else if (command.type === "resolve-issue") {
+    const issue = item.issues?.find((i) => i.id === command.issueId && i.attemptId === command.attemptId);
+    requireValue(issue, "ISSUE_NOT_FOUND");
+    identity(command.resolvedBy);
+    requireValue(!issue.resolvedBy || issue.resolvedBy === command.resolvedBy, "ISSUE_ALREADY_RESOLVED");
+    issue.resolvedBy = command.resolvedBy;
+  }
+}
+function initializeTaskLaunch(state, item) {
+  if (item.launch) return false;
+  const first = Object.values(state.workflow?.dispatches ?? {}).filter((d) => d.itemId === item.id).sort((a, b) => a.attempt - b.attempt)[0];
+  const admittedAt = first?.preparedAt ?? item.owner?.claimedAt;
+  item.launch = { startAt: taskStartAt(item), ...admittedAt === void 0 ? {} : { admittedAt } };
+  item.revision++;
+  return true;
+}
+function setMode(item, mode) {
+  requireValue(["automatic", "manual"].includes(mode), "INVALID_LAUNCH_MODE");
+  item.launch.mode = mode;
+  delete item.launch.requestedAt;
+}
+
+// src/board-control.ts
+function setBoardControl(state, command, actor, now, token) {
+  requireValue(actor.kind === "human", "FORBIDDEN");
+  requireValue(command.mode !== void 0 || command.paused !== void 0, "INVALID_BOARD_CONTROL");
+  requireValue(command.mode === void 0 || ["automatic", "manual"].includes(command.mode), "INVALID_LAUNCH_MODE");
+  requireValue(command.paused === void 0 || typeof command.paused === "boolean", "INVALID_BOARD_CONTROL");
+  const policy2 = state.board.executionControl ??= { mode: "automatic", paused: false, controls: {} };
+  if (command.mode) policy2.mode = command.mode;
+  if (command.paused === void 0 || command.paused === policy2.paused) return;
+  if (!command.paused) requireValue(!state.board.items.some((item) => policy2.controls[item.id] === item.control?.id && ["requested", "unknown"].includes(item.control.state)), "CONTROL_UNSETTLED");
+  policy2.paused = command.paused;
+  if (policy2.paused) policy2.controls = {};
+  state.board.items.forEach((item, index) => {
+    if (["completed", "cancelled", "review"].includes(item.status)) return;
+    const active = Object.values(state.workflow?.dispatches ?? {}).some((d) => d.itemId === item.id && ["prepared", "running", "unknown"].includes(d.outcome));
+    const managed = policy2.controls[item.id] === item.control?.id;
+    if (policy2.paused ? !active || item.control?.action === "pause" : !managed || item.control?.action !== "pause") return;
+    if (item.control && ["requested", "unknown"].includes(item.control.state)) return;
+    const controlId = token + "-" + index;
+    applyTaskCommand(state, { type: "request-control", itemId: item.id, controlId, action: policy2.paused ? "pause" : "resume" }, actor, now);
+    policy2.controls[item.id] = controlId;
+  });
+}
+
+// src/scan-commit.ts
+function applyDiscovery(state, batch, actor, now) {
+  const discovery = discoveryState(state), pending = discovery?.pending;
+  requireValue(pending && pending.runId === batch.runId && pending.token === batch.leaseToken && pending.leaseUntil > now, "SCAN_LEASE_EXPIRED");
+  requireValue(pending.request?.command.type === "apply-discovery" && JSON.stringify(pending.request.command.batch) === JSON.stringify(batch), "SCAN_BATCH_MISMATCH");
+  requireValue(batch.changes.length <= 50, "SCAN_CHANGE_LIMIT");
+  for (const change of batch.changes) {
+    identity(change.itemId);
+    validateSources(change.sources);
+    requireValue(change.sources.length > 0 && change.sources.some((s) => s.role === "user"), "USER_EVIDENCE_REQUIRED");
+    const item = change.action === "create" ? createItem(state, change, actor, now, batch.autoCreate, batch.runId) : updateItem(state, change, actor, now, batch.runId);
+    if (item) attachSources(item, change, now);
+  }
+  requireValue((batch.records?.length ?? 0) <= 20, "SCAN_RECORD_LIMIT");
+  for (const record of batch.records ?? []) {
+    requireValue(record.sources.some((source) => source.role === "user"), "USER_EVIDENCE_REQUIRED");
+    const duplicate = state.records?.some((old) => recordFingerprint(old) === recordFingerprint(record));
+    if (!duplicate) {
+      applyRecord(state, { type: "append-record", record }, actor, now, true);
+      state.records.find((entry) => entry.id === record.id).originRunId = batch.runId;
+    }
+  }
+  for (const checkpoint of batch.checkpoints) discovery.checkpoints[checkpoint.sessionId] = checkpoint.revision;
+  discovery.lastRun = { runId: batch.runId, outcome: "committed", at: now };
+  delete discovery.pending;
+}
+function createItem(state, change, actor, now, autoCreate, runId) {
+  text(change.title);
+  text(change.responsibility);
+  text(change.acceptance);
+  const item = {
+    origin: { kind: "discovery", principal: principal(actor), runId },
+    id: change.itemId,
+    title: change.title,
+    responsibility: change.responsibility,
+    acceptance: change.acceptance,
+    eligibleAgentIds: change.eligibleAgentIds,
+    eligiblePrincipals: change.eligiblePrincipals,
+    status: "proposed",
+    revision: 1,
+    createdAt: now,
+    readyAt: now,
+    updatedAt: now,
+    workUnits: 0,
+    participants: [],
+    sources: []
+  };
+  item.launch = { startAt: now + TASK_START_DELAY_MS };
+  item.planning = change.planning ?? { ...plan(item), kind: state.board.defaultWorkType ?? "task" };
+  const fingerprint = workFingerprint(item);
+  item.origin.fingerprint = fingerprint;
+  validateCandidates(state.board, item, executable(state.board, item));
+  if (state.archiveIndex?.some((old) => old.discoveryFingerprint === fingerprint)) return void 0;
+  const existing = state.board.items.find((old) => workFingerprint(old) === fingerprint || old.origin?.fingerprint === fingerprint);
+  if (existing) {
+    existing.revision++;
+    existing.updatedAt = now;
+    return existing;
+  }
+  requireValue(!state.board.items.some((old) => old.id === change.itemId) && !state.archiveIndex?.some((old) => old.id === change.itemId), "ITEM_EXISTS");
+  validatePlan(state, item, item.planning);
+  state.board.items.push(item);
+  if (autoCreate) setStage(state, item, automaticStage(state, item), now);
+  if (actor.sessionId) participant(item.participants, actor.sessionId, actor.agentId, "creator", true, now);
+  return item;
+}
+function updateItem(state, change, actor, now, runId) {
+  const item = state.board.items.find((i) => i.id === change.itemId);
+  requireValue(item, "ITEM_NOT_FOUND");
+  if (change.action === "update") {
+    requireValue(!change.planning, "SCAN_PLANNING_REQUIRES_REVIEW");
+    const ownDraft = item.status === "proposed" && item.origin?.kind === "discovery" && principalKey(item.origin.principal) === principalKey(principal(actor));
+    if (ownDraft) {
+      text(change.title);
+      text(change.responsibility);
+      text(change.acceptance);
+      item.title = change.title;
+      item.responsibility = change.responsibility;
+      item.acceptance = change.acceptance;
+    } else proposeAmendment(item, change, actor, now, runId);
+  } else requireValue(change.action === "link", "INVALID_CHANGE");
+  item.revision++;
+  item.updatedAt = now;
+  return item;
+}
+function attachSources(item, change, now) {
+  for (const source of change.sources) {
+    const subscribed = item.participants.find((p) => p.sessionId === source.sessionId)?.subscribed ?? false;
+    participant(item.participants, source.sessionId, void 0, source.role === "user" ? "creator" : "consultant", subscribed, now);
+    item.sources ??= [];
+    if (!item.sources.some((s) => s.sessionId === source.sessionId && s.messageId === source.messageId && s.revision === source.revision)) item.sources.push(source);
+  }
+}
+
+// src/automation.ts
+function configureAutomation(board, settings, actor) {
+  requireValue(settings && typeof settings.enabled === "boolean" && typeof settings.autoAccept === "boolean", "INVALID_AUTOMATION");
+  for (const ref of [settings.planner, settings.executor, ...settings.preparation ? [settings.preparation] : []]) {
+    requireValue(ref && typeof ref === "object", "INVALID_AUTOMATION_TARGET");
+    identity(ref.system);
+    identity(ref.id);
+    identity(ref.revision ?? "");
+  }
+  validateOptions(settings.preparationOptions);
+  requireValue(settings.preparation || !Object.keys(settings.preparationOptions ?? {}).length, "PREPARATION_REQUIRED");
+  const members = [...board.members ?? [], ...(board.agents ?? []).filter((agent) => !board.members?.some((member) => member.kind === "agent" && member.id === agent.agentId)).map((agent) => ({ kind: "agent", id: agent.agentId, responsibility: agent.responsibility }))];
+  for (const [principal2, role] of [[settings.coordinator, "coordinator"], [settings.worker, "worker"]]) {
+    requireValue(principal2 && ["agent", "human", "service"].includes(principal2.kind), "INVALID_PRINCIPAL");
+    identity(principal2.id);
+    const existing = members.find((member) => member.kind === principal2.kind && member.id === principal2.id);
+    if (existing) existing.roles = [.../* @__PURE__ */ new Set([...existing.roles ?? [], role])];
+    else members.push({ ...principal2, responsibility: role, roles: [role] });
+  }
+  addReviewer(members, actor);
+  board.members = members;
+  delete board.agents;
+  board.automation = structuredClone(settings);
+  board.policy.review = settings.autoAccept ? "assignee" : "independent";
+  validateBoard(board);
+}
+function addReviewer(members, actor) {
+  if (actor.kind !== "human" || !actor.id) return;
+  const existing = members.find((member) => member.kind === "human" && member.id === actor.id);
+  if (existing) existing.roles = [.../* @__PURE__ */ new Set([...existing.roles ?? [], "reviewer", "coordinator"])];
+  else members.push({ kind: "human", id: actor.id, responsibility: "Review work", roles: ["reviewer", "coordinator"] });
+}
+function validateOptions(options) {
+  if (options === void 0) return;
+  requireValue(options && typeof options === "object" && !Array.isArray(options) && Object.keys(options).length <= 16, "INVALID_PREPARATION_OPTIONS");
+  for (const [key, value] of Object.entries(options)) {
+    requireValue(/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(key) && typeof value === "string" && value.length <= 4096, "INVALID_PREPARATION_OPTIONS");
+  }
+}
+
+// src/workflow-continuation.ts
+function continueExecution(state, command, actor, now, apply) {
+  requireCoordinator(state, actor);
+  identity(command.dispatchId);
+  const workflow = state.workflow, previous = workflow.dispatches[command.previousDispatchId];
+  requireValue(previous && ["failed", "cancelled"].includes(previous.outcome), "EXECUTION_NOT_CONTINUABLE");
+  requireValue(!workflow.dispatches[command.dispatchId], "DISPATCH_EXISTS");
+  const item = state.board.items.find((item2) => item2.id === previous.itemId), plan2 = workflow.plans[previous.planId];
+  requireValue(item && ["backlog", "open"].includes(item.status) && !item.owner, "ITEM_NOT_CONTINUABLE");
+  const attempts = Object.values(workflow.dispatches).filter((row) => row.itemId === item.id);
+  requireValue(attempts.every((row) => row.attempt <= previous.attempt), "STALE_CONTINUATION");
+  requireValue(!attempts.some((row) => ["prepared", "running", "unknown", "succeeded"].includes(row.outcome)), "EXECUTION_UNSETTLED");
+  requireValue(plan2?.revision === previous.planRevision && plan2.definitions[item.id]?.digest === previous.definitionDigest, "PLAN_CHANGED");
+  requireValue(command.instruction === void 0 || typeof command.instruction === "string" && command.instruction.trim().length > 0 && command.instruction.length <= 8e3, "INVALID_CONTINUATION_INSTRUCTION");
+  requireValue(!item.blocked || item.blocked.reason === (previous.code ?? "EXECUTION_FAILED"), "ITEM_BLOCKED");
+  delete item.blocked;
+  if (item.status === "backlog") apply({ type: "set-stage", itemId: item.id, stage: "open" });
+  apply({ type: "claim", itemId: item.id, estimate: item.estimate }, previous.principal);
+  workflow.dispatches[command.dispatchId] = {
+    id: command.dispatchId,
+    itemId: item.id,
+    itemRevision: item.revision,
+    planId: previous.planId,
+    planRevision: previous.planRevision,
+    principal: previous.principal,
+    definitionDigest: previous.definitionDigest,
+    attempt: previous.attempt + 1,
+    fence: item.owner.token,
+    preparedAt: now,
+    outcome: "prepared",
+    inputs: structuredClone(previous.inputs),
+    continuation: { previousDispatchId: previous.id, ...command.instruction ? { instruction: command.instruction } : {} }
+  };
+}
+
+// src/workflow.ts
+function isWorkflowCommand(command) {
+  return ["publish-plan", "prepare-dispatch", "continue-execution", "observe-execution", "accept-execution"].includes(command.type);
+}
+function protectWorkflowItem(state, command) {
+  if (command.type === "configure-automation" && Object.values(state.workflow?.dispatches ?? {}).some((dispatch) => ["prepared", "running", "unknown", "succeeded"].includes(dispatch.outcome))) {
+    requireValue(sameAutomationBinding(state.board.automation, command.settings), "PLAN_EXECUTION_UNSETTLED");
+  }
+  if (!("itemId" in command) || !command.itemId || !state.workflow) return;
+  const plan2 = Object.values(state.workflow.plans).find((plan3) => plan3.itemIds.includes(command.itemId));
+  if (!plan2) return;
+  requireValue(!["edit-item", "plan-item", "review-amendment"].includes(command.type), "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+  if (plan2.sealed) requireValue(!["claim", "submit", "review", "close-plan"].includes(command.type), "WORKFLOW_COMMAND_REQUIRED");
+  const live = Object.values(state.workflow.dispatches).some((dispatch) => dispatch.itemId === command.itemId && ["prepared", "running", "unknown", "succeeded"].includes(dispatch.outcome));
+  if (live) requireValue(!["request-transfer", "accept-transfer", "release-item", "cancel-item"].includes(command.type), "EXECUTION_UNSETTLED");
+}
+function applyWorkflow(state, command, actor, now, apply) {
+  state.workflow ??= { plans: {}, dispatches: {}, ready: [], completedPlans: [] };
+  let changed = true;
+  if (command.type === "publish-plan") publishPlan(state, command.plan, actor, apply);
+  else if (command.type === "prepare-dispatch") prepare(state, command, actor, now, apply);
+  else if (command.type === "continue-execution") {
+    requireValue(!state.board.executionControl?.paused, "BOARD_EXECUTION_PAUSED");
+    continueExecution(state, command, actor, now, apply);
+  } else if (command.type === "observe-execution") changed = observe(state, command, actor, now);
+  else accept(state, command, actor, apply);
+  refreshReady(state);
+  return changed;
+}
+function prepare(state, command, actor, now, apply) {
+  identity(command.dispatchId);
+  const workflow = state.workflow;
+  requireValue(!workflow.dispatches[command.dispatchId], "DISPATCH_EXISTS");
+  refreshReady(state);
+  requireValue(workflow.ready.includes(command.itemId), "WORK_NOT_READY");
+  const plan2 = Object.values(workflow.plans).find((plan3) => plan3.itemIds.includes(command.itemId));
+  requireValue(!Object.values(workflow.dispatches).some((dispatch) => dispatch.itemId === command.itemId && ["prepared", "running", "unknown", "succeeded"].includes(dispatch.outcome)), "EXECUTION_UNSETTLED");
+  const item = state.board.items.find((item2) => item2.id === command.itemId);
+  if (item.status === "backlog") apply({ type: "set-stage", itemId: item.id, stage: "open" });
+  requireValue(!taskEditing(item, now), "EDIT_LEASE_ACTIVE");
+  requireValue(!state.board.executionControl?.paused, "BOARD_EXECUTION_PAUSED");
+  if (command.trigger === "automatic") requireValue(boardAllowsStart(state.board, item) && taskDue(item, now), "START_NOT_DUE");
+  item.launch ??= { startAt: taskStartAt(item) };
+  item.launch.admittedAt ??= now;
+  apply({ type: "claim", itemId: item.id, estimate: command.estimate });
+  const inputs = {};
+  for (const [name, binding] of Object.entries(plan2.definitions[item.id].inputs ?? {})) {
+    const producer = Object.values(workflow.dispatches).reverse().find((dispatch) => dispatch.itemId === binding.fromItemId && dispatch.outcome === "accepted");
+    const output = producer?.outputs?.find((output2) => output2.name === binding.output);
+    requireValue(output, "DEPENDENCY_OUTPUT_MISSING");
+    inputs[name] = structuredClone(output);
+  }
+  const attempt = Math.max(0, ...Object.values(workflow.dispatches).filter((dispatch) => dispatch.itemId === item.id).map((dispatch) => dispatch.attempt)) + 1;
+  workflow.dispatches[command.dispatchId] = { id: command.dispatchId, itemId: item.id, itemRevision: item.revision, planId: plan2.id, planRevision: plan2.revision, principal: principal(actor), definitionDigest: plan2.definitions[item.id].digest, attempt, fence: item.owner.token, preparedAt: now, outcome: "prepared", inputs };
+}
+function observe(state, command, actor, now) {
+  requireCoordinator(state, actor);
+  const dispatch = activeDispatch(state, command.dispatchId);
+  requireValue(command.fence === dispatch.fence && ["prepared", "running", "unknown"].includes(dispatch.outcome), "STALE_EXECUTION_RESULT");
+  requireValue(["running", "unknown", "succeeded", "failed", "cancelled"].includes(command.outcome), "INVALID_EXECUTION_OUTCOME");
+  if (command.code !== void 0) requireValue(/^[A-Z][A-Z0-9_]{0,79}$/.test(command.code), "INVALID_ERROR_CODE");
+  const item = state.board.items.find((item2) => item2.id === dispatch.itemId);
+  if (command.executionSessionId) {
+    identity(command.executionSessionId);
+    requireValue(!dispatch.executionSessionId || dispatch.executionSessionId === command.executionSessionId, "EXECUTION_SESSION_LOCKED");
+    dispatch.executionSessionId = command.executionSessionId;
+  }
+  if (command.controlCapabilities) {
+    requireValue(["boundary", "none"].includes(command.controlCapabilities.pause) && typeof command.controlCapabilities.resume === "boolean", "INVALID_CONTROL_CAPABILITIES");
+    dispatch.controlCapabilities = structuredClone(command.controlCapabilities);
+  }
+  const outputs = command.outputs ?? [];
+  validateOutputs(outputs);
+  if (["running", "unknown"].includes(command.outcome)) item.owner.leaseUntil = Math.max(item.owner.leaseUntil, now + state.board.policy.leaseMs);
+  if (!executionObservationChanged(dispatch, command)) return false;
+  if (command.outcome === "succeeded") {
+    const required = state.workflow.plans[dispatch.planId].definitions[item.id].outputs;
+    requireValue(required.every((name) => outputs.some((output) => output.name === name)), "REQUIRED_OUTPUT_MISSING");
+    item.status = state.board.policy.review === "assignee" ? "completed" : "review";
+    if (item.status === "completed") item.closedAt = now;
+    item.resultRef = `kanban:dispatch:${dispatch.id}`;
+    dispatch.outputs = structuredClone(outputs);
+  } else if (command.outcome === "failed" || command.outcome === "cancelled") {
+    item.status = "backlog";
+    item.blocked = { reason: command.code ?? "EXECUTION_FAILED", at: now };
+    delete item.owner;
+  }
+  dispatch.outcome = command.outcome === "succeeded" && state.board.policy.review === "assignee" ? "accepted" : command.outcome;
+  dispatch.code = command.code;
+  item.updatedAt = now;
+  item.revision++;
+  dispatch.itemRevision = item.revision;
+  return true;
+}
+function accept(state, command, actor, apply) {
+  requireCoordinator(state, actor);
+  const dispatch = activeDispatch(state, command.dispatchId);
+  requireValue(dispatch.outcome === "succeeded", "EXECUTION_NOT_SUCCEEDED");
+  apply({ type: "review", itemId: dispatch.itemId, accept: command.accept }, actor);
+  dispatch.outcome = command.accept ? "accepted" : "rejected";
+  if (!command.accept) {
+    const item = state.board.items.find((item2) => item2.id === dispatch.itemId);
+    item.status = "backlog";
+    item.blocked = { reason: "EXECUTION_REJECTED", at: item.updatedAt };
+  }
+}
+function activeDispatch(state, id) {
+  const dispatch = state.workflow.dispatches[id];
+  requireValue(dispatch, "DISPATCH_NOT_FOUND");
+  const item = state.board.items.find((item2) => item2.id === dispatch.itemId), plan2 = state.workflow.plans[dispatch.planId];
+  requireValue(plan2?.revision === dispatch.planRevision && item?.owner?.token === dispatch.fence && plan2.definitions[dispatch.itemId]?.digest === dispatch.definitionDigest, "STALE_EXECUTION_RESULT");
+  return dispatch;
+}
+function validateOutputs(outputs) {
+  requireValue(Array.isArray(outputs) && outputs.length <= 100 && outputs.every((output) => output && typeof output === "object" && typeof output.name === "string") && new Set(outputs.map((output) => output.name)).size === outputs.length, "INVALID_OUTPUTS");
+  for (const output of outputs) requireValue(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(output.name) && typeof output.ref === "string" && output.ref.length > 0 && output.ref.length <= 2048 && /^[a-f0-9]{64}$/.test(output.sha256) && Number.isSafeInteger(output.bytes) && output.bytes >= 0, "INVALID_OUTPUT_REFERENCE");
+}
+function refreshReady(state) {
+  if (!state.workflow) return;
+  const all = catalog(state), included = new Set(Object.values(state.workflow.plans).filter((plan2) => plan2.sealed).flatMap((plan2) => plan2.itemIds));
+  state.workflow.completedPlans = Object.values(state.workflow.plans).filter((plan2) => plan2.sealed && plan2.itemIds.every((id) => all.find((item) => item.id === id)?.status === "completed")).map((plan2) => plan2.id);
+  state.workflow.ready = state.board.items.filter((item) => included.has(item.id) && executableWorkItem(state.board, item) && ["backlog", "open"].includes(item.status) && !item.owner && !item.blocked && item.control?.action !== "pause" && (item.planning?.dependencies ?? []).every((id) => all.find((other) => other.id === id)?.status === "completed")).map((item) => item.id);
+}
+
+// src/transitions.ts
+function transition(state, item, command, actor, now, token) {
+  requireValue(item.status !== "completed" && item.status !== "cancelled", "ITEM_COMPLETED");
+  if (command.type === "claim" || command.type === "accept-transfer") claim(state, item, command, actor, now, token);
+  else if (command.type === "review") review(state, item, command.accept, actor, now);
+  else {
+    owned(item, actor, command.token, now);
+    if (command.type === "submit") requireValue(catalog(state).filter((i) => i.planning.parentId === item.id).every(terminal), "CHILDREN_UNFINISHED");
+    ownerUpdate(state.board, item, command, now, token);
+  }
+  if (command.type !== "renew") {
+    item.revision++;
+    item.updatedAt = now;
+  }
+}
+function claim(state, item, command, actor, now, token) {
+  const board = state.board, key = principalKey(principal(actor));
+  requireValue(!taskEditing(item, now), "EDIT_LEASE_ACTIVE");
+  eligible(board, item, actor);
+  assertReady(state, item);
+  requireValue(command.estimate || board.policy.requireEstimate === false, "ESTIMATE_REQUIRED");
+  if (command.estimate) validateEstimate(command.estimate);
+  const wip = board.items.filter((i) => i.status === "claimed" || i.status === "review");
+  if (command.type === "claim") requireValue(wip.length < limits(state).inProgress, "WIP_LIMIT");
+  requireValue(wip.filter((i) => i.id !== item.id && i.owner && assigneeKey(i.owner) === key).length < limits(state).perAssignee, principal(actor).kind === "agent" ? "AGENT_WIP_LIMIT" : "ASSIGNEE_WIP_LIMIT");
+  if (command.type === "claim") requireValue(item.status === "open" && !item.owner, "ALREADY_OWNED");
+  else {
+    requireValue(item.status === "claimed" && item.transfer && principalKey(transferTarget(item.transfer)) === key, "TRANSFER_NOT_OFFERED");
+    requireValue(item.transfer.expiresAt > now && item.owner && item.owner.leaseUntil > now, "TRANSFER_EXPIRED");
+    requireValue(assigneeKey(item.owner) !== key, "SELF_TRANSFER");
+  }
+  item.owner = { ...actor, principalId: key, token, claimedAt: now, leaseUntil: now + board.policy.leaseMs };
+  item.estimate = command.estimate;
+  item.status = "claimed";
+  item.progressAt = now;
+  delete item.transfer;
+  if (actor.sessionId) participant(item.participants, actor.sessionId, actor.agentId, "owner", true, now);
+}
+function review(state, item, accept2, actor, now) {
+  requireValue(item.status === "review", "NOT_IN_REVIEW");
+  const key = principalKey(principal(actor));
+  const registered = actor.sessionId && item.participants.some((p) => p.sessionId === actor.sessionId && p.roles.includes("reviewer")) || state.board.members?.some((m) => principalKey(m) === key && m.roles?.includes("reviewer"));
+  requireValue(registered, "REVIEWER_REQUIRED");
+  requireValue(!item.owner || assigneeKey(item.owner) !== key, "INDEPENDENT_REVIEW_REQUIRED");
+  item.status = accept2 ? "completed" : state.board.items.filter((i) => i.status === "open").length < limits(state).ready ? "open" : "backlog";
+  if (accept2) item.closedAt = now;
+  if (!accept2) {
+    delete item.owner;
+    delete item.estimate;
+    delete item.resultRef;
+    item.readyAt = now;
+  }
+}
+function ownerUpdate(board, item, command, now, token) {
+  switch (command.type) {
+    case "renew":
+      item.owner.leaseUntil = now + board.policy.leaseMs;
+      break;
+    case "progress":
+      requireValue(Number.isFinite(command.workUnits) && command.workUnits >= item.workUnits, "INVALID_WORK_UNITS");
+      item.workUnits = command.workUnits;
+      item.progressAt = now;
+      if (command.estimate) {
+        validateEstimate(command.estimate);
+        item.estimate = command.estimate;
+      }
+      break;
+    case "request-transfer":
+      requestTransfer(board, item, command, now, token);
+      break;
+    case "submit":
+      text(command.resultRef);
+      item.resultRef = command.resultRef;
+      item.status = board.policy.review === "assignee" ? "completed" : "review";
+      if (item.status === "completed") item.closedAt = now;
+      delete item.transfer;
+      break;
+  }
+}
+function requestTransfer(board, item, command, now, token) {
+  requireValue(Boolean(command.target) !== Boolean(command.agentId), "TRANSFER_TARGET_REQUIRED");
+  const target = command.target ?? { kind: "agent", id: command.agentId }, key = principalKey(target);
+  requireValue(candidates(board, item).some((p) => principalKey(p) === key), "AGENT_NOT_ELIGIBLE");
+  requireValue(assigneeKey(item.owner) !== key, "SELF_TRANSFER");
+  requireValue(!item.transfer, "TRANSFER_ALREADY_PENDING");
+  item.transfer = { id: token, target, ...target.kind === "agent" ? { agentId: target.id } : {}, requestedAt: now, expiresAt: now + board.policy.transferTimeoutMs };
+}
+function transferTarget(value) {
+  return value.target ?? { kind: "agent", id: value.agentId };
+}
+
+// src/reducer.ts
+function reduce(state, command, actor, operationId, now, token, workflowInternal = false) {
+  requireValue(state.board.deletedAt === void 0, "BOARD_DELETED");
+  numberEntities(state);
+  if (!workflowInternal) protectWorkflowItem(state, command);
+  const board = state.board;
+  if (command.type === "delete-board") return deleteBoard(state, actor, operationId, now);
+  if (command.type === "scan") {
+    scan(state, actor, operationId, now);
+    refreshReady(state);
+    return state;
+  }
+  let recordEvent = command.type !== "renew";
+  if (command.type === "set-board-control") setBoardControl(state, command, actor, now, token);
+  else if (taskCommand(command)) applyTaskCommand(state, command, actor, now);
+  else if (isWorkflowCommand(command)) recordEvent = applyWorkflow(state, command, actor, now, (inner, owner = actor) => {
+    reduce(state, inner, owner, operationId, now, token, true);
+  });
+  else if (command.type === "apply-discovery") applyDiscovery(state, command.batch, actor, now);
+  else if (isRecordCommand(command)) applyRecord(state, command, actor, now);
+  else if (command.type === "review-amendment") {
+    if (command.accept) assertDefinitionEditable(itemFor(board, command.itemId), now);
+    reviewAmendment(board, command, actor, now);
+  } else if (planningCommand(command)) applyPlanningCommand(state, command, now, actor, workflowInternal);
+  else if (command.type === "create-item") createItem2(state, command, actor, now, token);
+  else if (command.type === "configure-automation") configureAutomation(board, command.settings, actor);
+  else if (command.type === "register-session") {
+    const item = command.itemId ? itemFor(board, command.itemId) : void 0;
+    const list = item ? item.participants : board.participants;
+    participant(list, command.sessionId, command.agentId, command.role, command.subscribed, now);
+    if (item) item.revision++;
+  } else if (command.type === "message") {
+    text(command.message);
+    command.recipientSessionIds.forEach(identity);
+    if (command.itemId) itemFor(board, command.itemId);
+    requireValue(command.recipientSessionIds.every((id) => related(board).includes(id)), "UNKNOWN_RECIPIENT");
+  } else transition(state, itemFor(board, command.itemId), command, actor, now, token);
+  numberEntities(state);
+  refreshReady(state);
+  board.revision++;
+  if (recordEvent) append2(
+    state,
+    actor,
+    operationId,
+    now,
+    command.type,
+    "itemId" in command ? command.itemId : command.type === "create-item" ? command.item.id : "dispatchId" in command ? state.workflow?.dispatches[command.dispatchId]?.itemId : void 0,
+    eventData(command, state),
+    command.type === "message" ? command.recipientSessionIds : void 0
+  );
+  scan(state, actor, operationId, now);
+  return state;
+}
+function createItem2(state, command, actor, now, token) {
+  const { id, title, responsibility, acceptance, eligibleAgentIds, eligiblePrincipals, externalRefs } = command.item;
+  const input = { id, title, responsibility, acceptance, eligibleAgentIds, eligiblePrincipals, externalRefs }, board = state.board;
+  identity(input.id);
+  text(input.title);
+  text(input.responsibility);
+  text(input.acceptance);
+  requireValue(!board.items.some((i) => i.id === input.id) && !state.archiveIndex?.some((i) => i.id === input.id), "ITEM_EXISTS");
+  const item = { ...input, origin: { kind: "direct", principal: principal(actor) }, status: "backlog", revision: 1, createdAt: now, readyAt: now, updatedAt: now, workUnits: 0, participants: [] };
+  item.launch = { startAt: now + TASK_START_DELAY_MS };
+  requireValue(command.launch?.mode === void 0 || ["automatic", "manual"].includes(command.launch.mode), "INVALID_LAUNCH_MODE");
+  requireValue(command.launch?.paused === void 0 || typeof command.launch.paused === "boolean", "INVALID_TASK_PAUSE");
+  if (command.launch?.mode) item.launch.mode = command.launch.mode;
+  if (command.launch?.paused) item.control = { id: "initial-" + token, action: "pause", state: "paused" };
+  item.planning = command.planning ?? { ...plan(item), kind: board.defaultWorkType ?? "task" };
+  const references = item.externalRefs ?? [];
+  item.externalRefs = [];
+  for (const reference of references) attachReference(item, reference);
+  validateCandidates(board, item, executable(board, item));
+  validatePlan(state, item, item.planning);
+  if (item.planning.parentId) {
+    const parent = board.items.find((parent2) => parent2.id === item.planning.parentId);
+    if (parent.planning?.execution !== "children") {
+      parent.planning = { ...plan(parent), execution: "children" };
+      parent.updatedAt = now;
+      parent.revision++;
+    }
+  }
+  if (actor.sessionId) participant(item.participants, actor.sessionId, actor.agentId, "creator", true, now);
+  board.items.push(item);
+  if (command.stage === "open") setStage(state, item, "open", now);
+}
+function itemFor(board, id) {
+  const item = board.items.find((value) => value.id === id);
+  requireValue(item, "ITEM_NOT_FOUND");
+  return item;
+}
+function related(board) {
+  return [...new Set([...board.participants, ...board.items.flatMap((i) => i.participants)].map((p) => p.sessionId))];
+}
+function append2(state, actor, operationId, at, kind, itemId, data = {}, recipients) {
+  const archived = state.archiveWrites?.flatMap((write) => write.value?.item.participants ?? []) ?? [];
+  const members = [...archived, ...state.board.participants, ...state.board.items.filter((i) => i.id === itemId).flatMap((i) => i.participants)];
+  state.events.push({
+    sequence: ++state.sequence,
+    boardId: state.board.id,
+    itemId,
+    operationId,
+    at,
+    kind,
+    actor,
+    recipients: [...new Set(recipients ?? members.filter((p) => p.subscribed).map((p) => p.sessionId))],
+    data
+  });
+}
+function scan(state, actor, operationId, now) {
+  for (const item of state.board.items) {
+    if (initializeTaskLaunch(state, item)) {
+      state.board.revision++;
+      append2(state, actor, operationId, now, "task-launch-initialized", item.id, { code: "LEGACY_LAUNCH_INITIALIZED" });
+    }
+    if (terminal(item)) continue;
+    for (const reason of escalationReasons(state.board, item, now)) {
+      const epoch = reason === "transfer-timeout" ? item.transfer?.id : reason === "backlog-review" ? item.updatedAt : item.owner?.token ?? item.readyAt;
+      const key = JSON.stringify([item.id, epoch, reason]);
+      if (state.escalations.includes(key)) continue;
+      state.escalations.push(key);
+      state.board.revision++;
+      append2(state, actor, operationId, now, "escalated", item.id, { reason }, state.board.policy.escalationSessionIds);
+    }
+    if (item.transfer && item.transfer.expiresAt <= now) {
+      delete item.transfer;
+      item.revision++;
+      item.updatedAt = now;
+      state.board.revision++;
+    }
+  }
+  const archived = archiveExpired(state, now);
+  if (archived.length) {
+    state.board.revision++;
+    append2(state, actor, operationId, now, "items.archived", void 0, { reason: "retention-policy" });
+  }
+}
+function escalationReasons(board, item, now) {
+  const p = board.policy, result = [];
+  if (item.status === "backlog" && p.backlogReviewMs && now - item.updatedAt >= p.backlogReviewMs) result.push("backlog-review");
+  if (item.planning?.dueAt !== void 0 && now >= item.planning.dueAt) result.push("due-date");
+  if (item.blocked && now - item.blocked.at >= p.progressTimeoutMs) result.push("blocked-age");
+  if (!item.blocked && item.status === "open" && now - item.readyAt >= p.claimTimeoutMs) result.push("unclaimed");
+  if (item.status === "review" && now - item.updatedAt >= p.progressTimeoutMs) result.push("review-timeout");
+  if (item.transfer && now >= item.transfer.expiresAt) result.push("transfer-timeout");
+  if (item.status !== "claimed" || !item.owner) return result;
+  if (now >= item.owner.leaseUntil) result.push("lease-expired");
+  if (now - (item.progressAt ?? item.owner.claimedAt) >= p.progressTimeoutMs) result.push("no-progress");
+  if (now - item.owner.claimedAt >= Math.min(item.estimate?.durationMs ?? p.maxDurationMs, p.maxDurationMs)) result.push("execution-timeout");
+  if ((item.estimate?.complexity ?? 0) >= p.maxComplexity) result.push("complexity-threshold");
+  if (Math.max(item.workUnits, item.estimate?.workUnits ?? 0) >= p.maxWorkUnits) result.push("work-threshold");
+  if ((item.estimate?.durationMs ?? 0) >= p.maxDurationMs) result.push("duration-threshold");
+  return result;
+}
+function eventData(command, state) {
+  if (command.type === "set-board-control") return { code: "BOARD_" + (state.board.executionControl?.paused ? "PAUSE_REQUESTED" : state.board.executionControl?.mode?.toUpperCase()) };
+  if (command.type === "apply-discovery") return discoveryEvent(state, command.batch);
+  if (command.type === "report-analysis") return { code: command.status.code, reason: "analysis-" + command.status.state };
+  if (command.type === "control-receipt") return { code: command.code, reason: "control-" + command.state };
+  if (isWorkflowCommand(command)) return { readyItemIds: state.workflow?.ready, ..."dispatchId" in command ? { dispatchId: command.dispatchId } : { planId: command.plan.id }, ..."outcome" in command ? { reason: `execution-${command.outcome}`, code: command.code, status: state.board.items.find((item) => item.id === state.workflow?.dispatches[command.dispatchId]?.itemId)?.status } : command.type === "accept-execution" ? { reason: command.accept ? "accepted" : "rejected" } : {} };
+  if (command.type === "create-item") return { itemTitle: command.item.title };
+  if (command.type === "link-reference") return { reference: command.reference };
+  if (command.type === "block-item") return { reason: command.reason };
+  if (command.type === "release-item") return { reason: command.next === "cancelled" ? "cancelled" : "released" };
+  if (command.type === "review") return {
+    reason: command.accept ? "accepted" : "rejected",
+    dispatchId: Object.values(state.workflow?.dispatches ?? {}).find((dispatch) => dispatch.itemId === command.itemId && dispatch.outcome === "succeeded")?.id
+  };
+  if (command.type === "append-record") return { recordId: command.record.id, reason: command.record.kind === "decision" ? "decision-draft" : "log" };
+  if (command.type === "review-record" || command.type === "link-record") return { recordId: command.recordId };
+  if (command.type === "archive-items") return { itemIds: command.itemIds, reason: command.reason };
+  if (command.type === "cancel-item") return { reason: command.reason };
+  if (command.type === "plan-item") return { planning: command.planning };
+  if (command.type === "message") return { message: command.message };
+  if (command.type === "submit") return { resultRef: command.resultRef };
+  if (command.type === "claim" || command.type === "accept-transfer") return { estimate: command.estimate };
+  if (command.type === "progress") return { estimate: command.estimate, workUnits: command.workUnits };
+  return {};
+}
+function discoveryEvent(state, batch) {
+  return {
+    itemIds: batch.changes.map((change) => change.itemId),
+    recordIds: batch.records?.filter((record) => state.records?.some((entry) => entry.id === record.id && entry.originRunId === batch.runId)).map((record) => record.id),
+    ...state.board.items.some((item) => item.amendments?.some((proposal) => proposal.runId === batch.runId && proposal.status === "pending")) ? { reason: "amendment-proposed" } : state.board.items.some((item) => item.status === "proposed" && item.origin?.runId === batch.runId) ? { reason: "proposal-created" } : {}
+  };
+}
+function deleteBoard(state, actor, operationId, now) {
+  const owner = principal(actor), board = state.board;
+  requireValue(owner.kind === "human" && board.members?.some((member) => member.kind === owner.kind && member.id === owner.id && member.roles?.includes("coordinator")), "COORDINATOR_REQUIRED");
+  requireValue(!board.items.some((item) => item.owner || item.transfer || item.status === "claimed"), "BOARD_EXECUTION_ACTIVE");
+  requireValue(!Object.values(state.workflow?.dispatches ?? {}).some((dispatch) => ["prepared", "running", "unknown", "succeeded"].includes(dispatch.outcome)), "BOARD_EXECUTION_UNSETTLED");
+  board.deletedAt = now;
+  board.revision++;
+  if (board.automation) board.automation.enabled = false;
+  if (state.workflow) state.workflow.ready = [];
+  append2(state, actor, operationId, now, "delete-board");
+  return state;
+}
+
+export {
+  summary,
+  terminal,
+  catalog,
+  limits,
+  proposeAmendment,
+  queryRecords,
+  recordSummary,
+  createBoardState,
+  boardKey,
+  archiveKey,
+  rowKeys,
+  hydrate,
+  encodeBoard,
+  rowChanges,
+  receiptDigest,
+  verifyReceipt,
+  encodeRow,
+  decodeRow,
+  indexedView,
+  viewFromState,
+  boardCounterKey,
+  boardNumberKey,
+  counter,
+  storedBoardNumber,
+  patchBoardNumber,
+  numberEntities,
+  allocateBoardNumber,
+  reduce,
+  related,
+  escalationReasons
+};
+//# sourceMappingURL=chunk-OHQTKGQN.js.map