@nestos/kanban 0.0.0-stage → 0.5.1

package/dist/chunk-L44TM4EE.cjs

@@ -0,0 +1,1498 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk4XF6LQSUcjs = require('./chunk-4XF6LQSU.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk4KF7KUAIcjs = require('./chunk-4KF7KUAI.cjs');
+
+
+var _chunk2YFPV5GFcjs = require('./chunk-2YFPV5GF.cjs');
+
+
+
+
+
+var _chunkKYNYPKKHcjs = require('./chunk-KYNYPKKH.cjs');
+
+
+
+var _chunkPSKQAFDFcjs = require('./chunk-PSKQAFDF.cjs');
+
+
+
+var _chunk6MN3H3YFcjs = require('./chunk-6MN3H3YF.cjs');
+
+
+var _chunkLSE6JG5Icjs = require('./chunk-LSE6JG5I.cjs');
+
+// src/planning.ts
+function plan(item) {
+  return _nullishCoalesce(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: _optionalChain([item, 'access', _ => _.origin, 'optionalAccess', _2 => _2.fingerprint]),
+    pendingAmendments: _optionalChain([item, 'access', _3 => _3.amendments, 'optionalAccess', _4 => _4.filter, 'call', _5 => _5((proposal) => proposal.status === "pending"), 'access', _6 => _6.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), ..._nullishCoalesce(state.archiveIndex, () => ( []))];
+}
+function limits(state) {
+  const p = state.board.policy;
+  return { ready: _nullishCoalesce(p.maxReady, () => ( 20)), inProgress: _nullishCoalesce(p.maxInProgress, () => ( 3)), perAgent: _nullishCoalesce(_nullishCoalesce(p.maxInProgressPerAssignee, () => ( p.maxInProgressPerAgent)), () => ( 1)), perAssignee: _nullishCoalesce(_nullishCoalesce(p.maxInProgressPerAssignee, () => ( p.maxInProgressPerAgent)), () => ( 1)) };
+}
+function validatePlan(state, item, value) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, typeof value.kind === "string" && Number.isInteger(value.priority) && value.priority >= 0 && value.priority <= 4, "INVALID_PLANNING");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, Array.isArray(value.dependencies) && value.dependencies.length <= 100 && Array.isArray(value.references) && value.references.length <= 100, "PLANNING_LIMIT");
+  value.dependencies.forEach(_chunk4KF7KUAIcjs.identity);
+  value.references.forEach(_chunk4KF7KUAIcjs.text);
+  if (value.area !== void 0) _chunk4KF7KUAIcjs.identity.call(void 0, value.area);
+  if (value.milestone !== void 0) _chunk4KF7KUAIcjs.identity.call(void 0, value.milestone);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, value.execution === void 0 || ["direct", "children"].includes(value.execution), "INVALID_EXECUTION_MODE");
+  const type = _chunk4KF7KUAIcjs.workType.call(void 0, state.board, value.kind);
+  if (value.dueAt !== void 0) _chunk4KF7KUAIcjs.requireValue.call(void 0, 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) {
+    _chunk4KF7KUAIcjs.identity.call(void 0, value.parentId);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, parent && !parent.archivedAt && !terminal(parent) && !["claimed", "review"].includes(parent.status), "PARENT_UNAVAILABLE");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, parent.id !== item.id && _chunk4KF7KUAIcjs.workType.call(void 0, state.board, parent.planning.kind).rank < type.rank, "INVALID_PARENT_KIND");
+  }
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, value.execution === "children" || !all.some((child) => child.planning.parentId === item.id), "CHILDREN_REQUIRE_AGGREGATION");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !all.some((child) => child.planning.parentId === item.id && _chunk4KF7KUAIcjs.workType.call(void 0, state.board, child.planning.kind).rank <= type.rank), "INVALID_CHILD_KIND");
+  for (const id of value.dependencies) _chunk4KF7KUAIcjs.requireValue.call(void 0, 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();
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, id !== item.id, "DEPENDENCY_CYCLE");
+    if (visited.has(id)) continue;
+    visited.add(id);
+    pending.push(..._nullishCoalesce(_optionalChain([all, 'access', _7 => _7.find, 'call', _8 => _8((i) => i.id === id), 'optionalAccess', _9 => _9.planning, 'access', _10 => _10.dependencies]), () => ( [])));
+  }
+}
+function assertReady(state, item) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _chunk4KF7KUAIcjs.executable.call(void 0, state.board, item), "PLAN_NOT_EXECUTABLE");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !item.blocked, "ITEM_BLOCKED");
+  const all = catalog(state);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, plan(item).dependencies.every((id) => _optionalChain([all, 'access', _11 => _11.find, 'call', _12 => _12((i) => i.id === id), 'optionalAccess', _13 => _13.status]) === "completed"), "DEPENDENCIES_UNFINISHED");
+}
+function setStage(state, item, stage, now) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, ["proposed", "backlog", "open"].includes(item.status), "ITEM_NOT_PLANNABLE");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, stage === "backlog" || stage === "open", "INVALID_STAGE");
+  if (stage === "open") {
+    assertReady(state, item);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, 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) => _optionalChain([all, 'access', _14 => _14.find, 'call', _15 => _15((i) => i.id === id), 'optionalAccess', _16 => _16.status]) === "completed");
+  return _chunk4KF7KUAIcjs.executable.call(void 0, 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) => _chunk6MN3H3YFcjs.sha256HexSync.call(void 0, JSON.stringify(textOf(item)));
+function workFingerprint(item) {
+  const planning = plan(item);
+  return _chunk6MN3H3YFcjs.sha256HexSync.call(void 0, JSON.stringify({
+    text: textOf(item),
+    kind: planning.kind,
+    parentId: _nullishCoalesce(planning.parentId, () => ( null)),
+    area: _nullishCoalesce(planning.area, () => ( null)),
+    milestone: _nullishCoalesce(planning.milestone, () => ( null)),
+    priority: planning.priority,
+    dependencies: [...planning.dependencies].sort(),
+    dueAt: _nullishCoalesce(planning.dueAt, () => ( null))
+  }));
+}
+function validateSources(sources) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, Array.isArray(sources) && sources.length <= 100, "SOURCE_LIMIT");
+  for (const source of sources) {
+    _chunk4KF7KUAIcjs.identity.call(void 0, source.sessionId);
+    _chunk4KF7KUAIcjs.identity.call(void 0, source.messageId);
+    _chunk4KF7KUAIcjs.identity.call(void 0, source.revision);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, source.role === "user" || source.role === "assistant", "INVALID_SOURCE");
+  }
+}
+function proposeAmendment(item, change, actor, now, runId) {
+  _chunk4KF7KUAIcjs.text.call(void 0, change.title);
+  _chunk4KF7KUAIcjs.text.call(void 0, change.responsibility);
+  _chunk4KF7KUAIcjs.text.call(void 0, change.acceptance);
+  validateSources(change.sources);
+  const proposed = textOf(change), fingerprint = textDigest(proposed);
+  if (textDigest(item) === fingerprint || _optionalChain([item, 'access', _17 => _17.amendments, 'optionalAccess', _18 => _18.some, 'call', _19 => _19((p) => p.fingerprint === fingerprint)])) return;
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, (_nullishCoalesce(_optionalChain([item, 'access', _20 => _20.amendments, 'optionalAccess', _21 => _21.length]), () => ( 0))) < 20, "AMENDMENT_LIMIT");
+  (item.amendments ??= []).push({
+    runId,
+    id: `amendment-${_chunk6MN3H3YFcjs.sha256HexSync.call(void 0, JSON.stringify([runId, item.id, fingerprint]))}`,
+    fingerprint,
+    baseRevision: item.revision,
+    baseDigest: textDigest(item),
+    proposed,
+    proposedBy: _chunk4KF7KUAIcjs.principal.call(void 0, actor),
+    sources: structuredClone(change.sources),
+    createdAt: now,
+    status: "pending"
+  });
+}
+function requireReviewer(board, actor) {
+  const key = _chunk4KF7KUAIcjs.principalKey.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor));
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 
+    _optionalChain([board, 'access', _22 => _22.members, 'optionalAccess', _23 => _23.some, 'call', _24 => _24((m) => _chunk4KF7KUAIcjs.principalKey.call(void 0, m) === key && _optionalChain([m, 'access', _25 => _25.roles, 'optionalAccess', _26 => _26.some, 'call', _27 => _27((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 = _optionalChain([item, 'optionalAccess', _28 => _28.amendments, 'optionalAccess', _29 => _29.find, 'call', _30 => _30((p) => p.id === command.amendmentId)]);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, item && _optionalChain([proposal, 'optionalAccess', _31 => _31.status]) === "pending", "AMENDMENT_NOT_PENDING");
+  if (command.accept) {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor).kind === "human" || _chunk4KF7KUAIcjs.principalKey.call(void 0, proposal.proposedBy) !== _chunk4KF7KUAIcjs.principalKey.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor)), "INDEPENDENT_REVIEW_REQUIRED");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, ["proposed", "backlog", "open"].includes(item.status), "ITEM_NOT_PLANNABLE");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, textDigest(item) === proposal.baseDigest, "AMENDMENT_STALE");
+    Object.assign(item, proposal.proposed);
+    if (item.status === "open") {
+      item.status = "backlog";
+      item.readyAt = now;
+    }
+  } else {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, !!_optionalChain([command, 'access', _32 => _32.reason, 'optionalAccess', _33 => _33.trim, 'call', _34 => _34()]), "AMENDMENT_REASON_REQUIRED");
+    _chunk4KF7KUAIcjs.text.call(void 0, command.reason);
+  }
+  proposal.status = command.accept ? "accepted" : "rejected";
+  proposal.reviewedAt = now;
+  proposal.reviewedBy = _chunk4KF7KUAIcjs.principal.call(void 0, 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 = _optionalChain([state, 'access', _35 => _35.records, 'optionalAccess', _36 => _36.find, 'call', _37 => _37((record2) => record2.id === command.recordId)]);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, record, "RECORD_NOT_FOUND");
+  if (command.type === "link-record") {
+    validateItems(state, [command.itemId]);
+    if (!record.itemIds.includes(command.itemId)) {
+      _chunk4KF7KUAIcjs.requireValue.call(void 0, record.itemIds.length < 100, "RECORD_LINK_LIMIT");
+      record.itemIds.push(command.itemId);
+    }
+  } else {
+    requireReviewer(state.board, actor);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, record.status === "draft", "RECORD_NOT_DRAFT");
+    if (command.accept) {
+      _chunk4KF7KUAIcjs.requireValue.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor).kind === "human" || _chunk4KF7KUAIcjs.principalKey.call(void 0, record.author) !== _chunk4KF7KUAIcjs.principalKey.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor)), "INDEPENDENT_REVIEW_REQUIRED");
+      supersede(state, record, now);
+      record.status = "confirmed";
+    } else record.status = "rejected";
+    record.reviewedBy = _chunk4KF7KUAIcjs.principal.call(void 0, 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 } : {} });
+  _chunk4KF7KUAIcjs.identity.call(void 0, input.id);
+  _chunk4KF7KUAIcjs.text.call(void 0, input.title);
+  _chunk4KF7KUAIcjs.text.call(void 0, input.content);
+  validateRecordReferences(externalRefs);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, input.kind === "log" || input.kind === "decision", "INVALID_RECORD_KIND");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !_optionalChain([state, 'access', _38 => _38.records, 'optionalAccess', _39 => _39.some, 'call', _40 => _40((record) => record.id === input.id)]), "RECORD_EXISTS");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, (_nullishCoalesce(_optionalChain([state, 'access', _41 => _41.records, 'optionalAccess', _42 => _42.length]), () => ( 0))) < 200, "RECORD_LIMIT");
+  validateItems(state, input.itemIds);
+  validateSources(input.sources);
+  if (input.rationale !== void 0) _chunk4KF7KUAIcjs.text.call(void 0, input.rationale);
+  if (input.kind === "decision") _chunk4KF7KUAIcjs.text.call(void 0, _nullishCoalesce(input.rationale, () => ( "")));
+  if (coordination) validateCoordination(state, input);
+  if (input.supersedes) {
+    _chunk4KF7KUAIcjs.identity.call(void 0, input.supersedes);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, input.kind === "decision" && input.supersedes !== input.id && _optionalChain([state, 'access', _43 => _43.records, 'optionalAccess', _44 => _44.some, 'call', _45 => _45((record) => record.id === input.supersedes && record.kind === "decision" && record.status === "confirmed")]), "INVALID_SUPERSEDED_RECORD");
+  }
+  const author = _chunk4KF7KUAIcjs.principal.call(void 0, 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) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, input.kind === "decision", "DECISION_COORDINATION_ONLY");
+  for (const owner of [input.coordination.manager, input.coordination.executor].filter(Boolean)) {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, owner && ["agent", "human", "service"].includes(owner.kind), "INVALID_PRINCIPAL");
+    _chunk4KF7KUAIcjs.identity.call(void 0, owner.id);
+    const member = _optionalChain([state, 'access', _46 => _46.board, 'access', _47 => _47.members, 'optionalAccess', _48 => _48.find, 'call', _49 => _49((member2) => _chunk4KF7KUAIcjs.principalKey.call(void 0, member2) === _chunk4KF7KUAIcjs.principalKey.call(void 0, owner))]);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, member, "ASSIGNEE_NOT_REGISTERED");
+    if (owner === input.coordination.manager) _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([member, 'access', _50 => _50.roles, 'optionalAccess', _51 => _51.includes, 'call', _52 => _52("coordinator")]), "COORDINATOR_REQUIRED");
+  }
+}
+function validateItems(state, ids) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, Array.isArray(ids) && ids.length <= 100 && new Set(ids).size === ids.length, "RECORD_LINK_LIMIT");
+  for (const id of ids) {
+    _chunk4KF7KUAIcjs.identity.call(void 0, id);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, state.board.items.some((item) => item.id === id) || _optionalChain([state, 'access', _53 => _53.archiveIndex, 'optionalAccess', _54 => _54.some, 'call', _55 => _55((item) => item.id === id)]), "ITEM_NOT_FOUND");
+  }
+}
+function supersede(state, record, now) {
+  if (!record.supersedes) return;
+  const previous = _optionalChain([state, 'access', _56 => _56.records, 'optionalAccess', _57 => _57.find, 'call', _58 => _58((entry) => entry.id === record.supersedes)]);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([previous, 'optionalAccess', _59 => _59.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 = (_nullishCoalesce(state.records, () => ( []))).map(recordSummary)) {
+  const { cursor, ...filter } = query, limit = _nullishCoalesce(query.limit, () => ( 50));
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, Number.isSafeInteger(limit) && limit > 0 && limit <= 200, "INVALID_LIMIT");
+  if (query.kind) _chunk4KF7KUAIcjs.requireValue.call(void 0, ["log", "decision"].includes(query.kind), "INVALID_RECORD_KIND");
+  if (query.itemId !== void 0) _chunk4KF7KUAIcjs.identity.call(void 0, query.itemId);
+  if (query.status) _chunk4KF7KUAIcjs.requireValue.call(void 0, ["draft", "confirmed", "rejected", "superseded"].includes(query.status), "INVALID_RECORD_STATUS");
+  const digest = _chunk6MN3H3YFcjs.sha256HexSync.call(void 0, JSON.stringify(filter));
+  let offset = 0;
+  if (cursor) {
+    let decoded;
+    try {
+      decoded = JSON.parse(decodeURIComponent(cursor));
+    } catch (e) {
+      _chunk4KF7KUAIcjs.requireValue.call(void 0, false, "INVALID_CURSOR");
+    }
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, decoded && typeof decoded === "object" && !Array.isArray(decoded) && typeof decoded.filter === "string" && typeof decoded.revision === "number", "INVALID_CURSOR");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, decoded.revision === state.board.revision && decoded.filter === digest, "CURSOR_STALE");
+    offset = decoded.offset;
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, 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 _chunk6MN3H3YFcjs.sha256HexSync.call(void 0, JSON.stringify({
+    kind: record.kind,
+    title: record.title,
+    content: record.content,
+    rationale: _nullishCoalesce(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;
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, Array.isArray(refs) && refs.length <= 100, "REFERENCE_LIMIT");
+  const keys = /* @__PURE__ */ new Set();
+  for (const ref of refs) {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, ref && typeof ref === "object", "INVALID_REFERENCE");
+    _chunk4KF7KUAIcjs.identity.call(void 0, ref.system);
+    _chunk4KF7KUAIcjs.identity.call(void 0, ref.id);
+    if (ref.revision !== void 0) _chunk4KF7KUAIcjs.text.call(void 0, ref.revision);
+    const key = JSON.stringify([ref.system, ref.id]);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, !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: _chunk4KF7KUAIcjs.policy.call(void 0, input.policy), revision: 1, items: [], participants: [] };
+  _chunk4KF7KUAIcjs.validateBoard.call(void 0, board);
+  if (actor.sessionId) _chunk4KF7KUAIcjs.participant.call(void 0, board.participants, actor.sessionId, actor.agentId, "creator", true, now);
+  for (const session of board.policy.escalationSessionIds) _chunk4KF7KUAIcjs.participant.call(void 0, 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 [];
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, Array.isArray(saved.itemIds) && Array.isArray(saved.recordIds) && _optionalChain([saved, 'access', _60 => _60.state, 'optionalAccess', _61 => _61.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);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, 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);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, 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 _nullishCoalesce(state.records, () => ( []))) rows[rowKey("record", id, record.id)] = await encodeRow(record, bodies);
+  const manifest = {
+    itemIndex: state.board.items.map(summary),
+    recordIndex: (_nullishCoalesce(state.records, () => ( []))).map(recordSummary),
+    layout: 2,
+    generation: _chunk6MN3H3YFcjs.randomUUID.call(void 0, ),
+    state: { ...state, board: { ...state.board, items: [] }, records: [] },
+    itemIds: state.board.items.map((item) => item.id),
+    recordIds: (_nullishCoalesce(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:${_chunk6MN3H3YFcjs.sha256HexSync.call(void 0, fingerprint)}`;
+}
+function verifyReceipt(saved, fingerprint) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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: _chunk6MN3H3YFcjs.sha256HexSync.call(void 0, 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 _nullishCoalesce(failure, () => ( new (0, _chunk2YFPV5GFcjs.KanbanError)("BODY_WRITE_UNCONFIRMED")));
+    verifyBody(confirmed, ref);
+  }
+  return JSON.stringify(ref);
+}
+async function decodeRow(raw, bodies) {
+  const parsed = JSON.parse(raw);
+  if (_optionalChain([parsed, 'optionalAccess', _62 => _62.body]) !== "kanban-body/v1") return parsed;
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, /^[a-f0-9]{64}$/.test(parsed.sha256) && Number.isSafeInteger(parsed.bytes) && parsed.bytes > 8192, "INVALID_BODY_REFERENCE");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, bodies, "BODY_STORE_REQUIRED");
+  const bytes = await bodies.read(parsed.sha256);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, bytes !== null, "BODY_MISSING");
+  verifyBody(bytes, parsed);
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+}
+function verifyBody(bytes, ref) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, bytes instanceof ArrayBuffer && bytes.byteLength === ref.bytes && _chunk6MN3H3YFcjs.sha256HexSync.call(void 0, bytes) === ref.sha256, "BODY_INTEGRITY");
+}
+function requiredRow(saved, key) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, typeof saved.rows[key] === "string", "MISSING_STORAGE_ROW");
+  return saved.rows[key];
+}
+function validateState(state) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([state, 'optionalAccess', _63 => _63.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: (_nullishCoalesce(state.records, () => ( []))).map(recordSummary) };
+}
+
+// src/numbering.ts
+var boardCounterKey = "counter/board";
+var boardNumberKey = (number) => `reference/board/${number}`;
+function counter(raw) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, raw === null || /^(0|[1-9]\d*)$/.test(raw), "INVALID_NUMBER_COUNTER");
+  const value = raw === null ? 0 : Number(raw);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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 = _optionalChain([(parsed.layout === 2 ? _optionalChain([parsed, 'access', _64 => _64.state, 'optionalAccess', _65 => _65.board]) : parsed.board), 'optionalAccess', _66 => _66.number]);
+  if (number !== void 0) _chunk4KF7KUAIcjs.requireValue.call(void 0, 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, ..._nullishCoalesce(state.archiveIndex, () => ( [])), ...(_nullishCoalesce(state.archiveWrites, () => ( []))).flatMap((write) => write.value ? [write.value.item] : [])];
+  high.item = assign(items, high.item);
+  for (const kind of ["log", "decision"]) high[kind] = assign((_nullishCoalesce(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) {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, 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)) {
+      _chunk4KF7KUAIcjs.requireValue.call(void 0, 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;
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, high < Number.MAX_SAFE_INTEGER, "NUMBER_COUNTER_EXHAUSTED");
+  return high + 1;
+}
+
+// src/archives.ts
+function archiveItems(state, ids, reason, now) {
+  _chunk4KF7KUAIcjs.text.call(void 0, reason);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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));
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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;
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([record, 'optionalAccess', _67 => _67.item, 'access', _68 => _68.id]) === id && _optionalChain([state, 'access', _69 => _69.archiveIndex, 'optionalAccess', _70 => _70.some, 'call', _71 => _71((i) => i.id === id)]), "ARCHIVED_ITEM_NOT_FOUND");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !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(_nullishCoalesce(i.closedAt, () => ( i.updatedAt)), _nullishCoalesce(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);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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") {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, ["claimed", "review"].includes(item.status) && _optionalChain([item, 'access', _72 => _72.owner, 'optionalAccess', _73 => _73.token]) === command.token, "OWNER_MISMATCH");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, ["backlog", "cancelled"].includes(command.next), "INVALID_STAGE");
+    _chunk4KF7KUAIcjs.text.call(void 0, 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 {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, !terminal(item), "ITEM_COMPLETED");
+    if (item.status === "claimed") _chunk4KF7KUAIcjs.owned.call(void 0, item, actor, _nullishCoalesce(command.token, () => ( "")), now);
+    if (command.type === "block-item") {
+      _chunk4KF7KUAIcjs.text.call(void 0, 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") _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([item, 'access', _74 => _74.launch, 'optionalAccess', _75 => _75.admittedAt]) === void 0, "TASK_CONTROL_REQUIRED");
+  if (command.type === "publish-proposal") {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, item.status === "proposed", "NOT_PROPOSED");
+    return setStage(state, item, _nullishCoalesce(command.stage, () => ( "backlog")), now);
+  }
+  if (command.type === "set-stage") return setStage(state, item, command.stage, now);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, ["proposed", "backlog", "open"].includes(item.status), "ITEM_NOT_PLANNABLE");
+  if (command.type === "edit-item") {
+    _chunk4KF7KUAIcjs.text.call(void 0, command.title);
+    _chunk4KF7KUAIcjs.text.call(void 0, command.responsibility);
+    _chunk4KF7KUAIcjs.text.call(void 0, 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 {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, catalog(state).filter((i) => i.planning.parentId === item.id).every(terminal), "CHILDREN_UNFINISHED");
+    if (command.type === "close-plan") {
+      _chunk4KF7KUAIcjs.requireValue.call(void 0, !_chunk4KF7KUAIcjs.executable.call(void 0, state.board, item), "TASK_REQUIRES_REVIEW");
+      _chunk4KF7KUAIcjs.text.call(void 0, command.resultRef);
+      const children = catalog(state).filter((child) => child.planning.parentId === item.id);
+      if (_optionalChain([item, 'access', _76 => _76.planning, 'optionalAccess', _77 => _77.execution]) === "children") _chunk4KF7KUAIcjs.requireValue.call(void 0, children.length > 0 && children.every((child) => child.status === "completed"), "CHILDREN_UNFINISHED");
+      item.status = "completed";
+      item.resultRef = command.resultRef;
+    } else {
+      _chunk4KF7KUAIcjs.text.call(void 0, command.reason);
+      item.status = "cancelled";
+      item.closureReason = command.reason;
+    }
+    item.closedAt = now;
+  }
+  item.updatedAt = now;
+  item.revision++;
+}
+function attachReference(item, reference) {
+  _chunk4KF7KUAIcjs.identity.call(void 0, reference.system);
+  _chunk4KF7KUAIcjs.identity.call(void 0, reference.id);
+  if (reference.revision !== void 0) _chunk4KF7KUAIcjs.text.call(void 0, reference.revision);
+  item.externalRefs ??= [];
+  if (item.externalRefs.some((r) => r.system === reference.system && r.id === reference.id && r.revision === reference.revision)) return;
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, item.externalRefs.length < 100, "REFERENCE_LIMIT");
+  item.externalRefs.push(reference);
+}
+
+// src/workflow-plans.ts
+function requireCoordinator(state, actor) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([state, 'access', _78 => _78.board, 'access', _79 => _79.members, 'optionalAccess', _80 => _80.some, 'call', _81 => _81((member) => _chunk4KF7KUAIcjs.principalKey.call(void 0, member) === _chunk4KF7KUAIcjs.principalKey.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor)) && _optionalChain([member, 'access', _82 => _82.roles, 'optionalAccess', _83 => _83.includes, 'call', _84 => _84("coordinator")]))]), "COORDINATOR_REQUIRED");
+}
+function publishPlan(state, plan2, actor, apply) {
+  requireCoordinator(state, actor);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, plan2 && typeof plan2 === "object", "INVALID_WORK_PLAN");
+  _chunk4KF7KUAIcjs.identity.call(void 0, plan2.id);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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];
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, Number.isSafeInteger(plan2.revision) && plan2.revision === (_nullishCoalesce(_optionalChain([previous, 'optionalAccess', _85 => _85.revision]), () => ( 0))) + 1, "PLAN_REVISION_CONFLICT");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !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 = _optionalChain([state, 'access', _86 => _86.records, 'optionalAccess', _87 => _87.find, 'call', _88 => _88((record) => record.id === plan2.decisionId && record.kind === "decision" && record.status === "confirmed")]);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, decision, "DECISION_NOT_CONFIRMED");
+    if (decision.coordination) _chunk4KF7KUAIcjs.requireValue.call(void 0, _chunk4KF7KUAIcjs.principalKey.call(void 0, decision.coordination.manager) === _chunk4KF7KUAIcjs.principalKey.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor)), "DECISION_MANAGER_REQUIRED");
+  }
+  if (plan2.rootItemId) {
+    const root = state.board.items.find((item) => item.id === plan2.rootItemId);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, root && !root.owner && ["backlog", "open"].includes(root.status), "PLAN_ROOT_UNAVAILABLE");
+    if (_optionalChain([root, 'access', _89 => _89.planning, 'optionalAccess', _90 => _90.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 = _chunk6MN3H3YFcjs.sha256HexSync.call(void 0, JSON.stringify(item));
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, !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) || _optionalChain([state, 'access', _91 => _91.archiveIndex, 'optionalAccess', _92 => _92.some, 'call', _93 => _93((old) => old.id === item.id)]);
+    if (exists && _optionalChain([previous, 'optionalAccess', _94 => _94.definitions, 'access', _95 => _95[item.id], 'optionalAccess', _96 => _96.digest]) !== digest) {
+      _chunk4KF7KUAIcjs.requireValue.call(void 0, !_optionalChain([previous, 'optionalAccess', _97 => _97.definitions, 'access', _98 => _98[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: _nullishCoalesce(_nullishCoalesce(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: _nullishCoalesce(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);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, item && definition.expectedRevision === item.revision && ["backlog", "open"].includes(item.status) && !item.owner && !item.blocked, "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !definition.workType || definition.workType === _optionalChain([item, 'access', _99 => _99.planning, 'optionalAccess', _100 => _100.kind]), "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !definition.externalRefs || definition.externalRefs.every((ref) => _optionalChain([item, 'access', _101 => _101.externalRefs, 'optionalAccess', _102 => _102.some, 'call', _103 => _103((existing) => JSON.stringify(existing) === JSON.stringify(ref))])), "PLAN_RESOURCE_MISMATCH");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, item.title === definition.title && item.responsibility === definition.responsibility && item.acceptance === definition.acceptance, "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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;
+  _chunk4KF7KUAIcjs.validateCandidates.call(void 0, state.board, item, true);
+}
+function orderWork(items, state) {
+  for (const item of items) validateDefinition(item);
+  const ids = new Set(items.map((item) => item.id));
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, ids.size === items.length, "DUPLICATE_PLAN_ITEM");
+  for (const item of items) {
+    _chunk4KF7KUAIcjs.identity.call(void 0, item.id);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, Array.isArray(item.dependsOn) && item.dependsOn.length <= 100 && new Set(item.dependsOn).size === item.dependsOn.length, "INVALID_DEPENDENCIES");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, Object.keys(_nullishCoalesce(item.inputs, () => ( {}))).length <= 100 && Array.isArray(_nullishCoalesce(item.outputs, () => ( []))) && (_nullishCoalesce(item.outputs, () => ( []))).length <= 100 && new Set(_nullishCoalesce(item.outputs, () => ( []))).size === (_nullishCoalesce(item.outputs, () => ( []))).length, "PLAN_BINDING_LIMIT");
+    for (const name of [...Object.keys(_nullishCoalesce(item.inputs, () => ( {}))), ..._nullishCoalesce(item.outputs, () => ( []))]) _chunk4KF7KUAIcjs.requireValue.call(void 0, /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(name), "INVALID_OUTPUT_NAME");
+    for (const binding of Object.values(_nullishCoalesce(item.inputs, () => ( {})))) {
+      _chunk4KF7KUAIcjs.requireValue.call(void 0, 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" && _optionalChain([dispatch, 'access', _104 => _104.outputs, 'optionalAccess', _105 => _105.some, 'call', _106 => _106((output) => output.name === binding.output)]));
+      _chunk4KF7KUAIcjs.requireValue.call(void 0, producer ? _optionalChain([producer, 'access', _107 => _107.outputs, 'optionalAccess', _108 => _108.includes, 'call', _109 => _109(binding.output)]) : existing, "OUTPUT_NOT_DECLARED");
+    }
+    for (const dependency of item.dependsOn) _chunk4KF7KUAIcjs.requireValue.call(void 0, ids.has(dependency) || [...state.board.items, ..._nullishCoalesce(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)));
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, next >= 0, "DEPENDENCY_CYCLE");
+    const [item] = remaining.splice(next, 1);
+    ordered.push(item);
+    done.add(item.id);
+  }
+  return ordered;
+}
+function validateDefinition(item) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, item && typeof item === "object" && !Array.isArray(item), "INVALID_WORK_DEFINITION");
+  const assignee = item.assignee;
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, assignee && ["agent", "human", "service"].includes(assignee.kind), "INVALID_PRINCIPAL");
+  _chunk4KF7KUAIcjs.identity.call(void 0, assignee.id);
+  if (item.inputs !== void 0) _chunk4KF7KUAIcjs.requireValue.call(void 0, item.inputs && typeof item.inputs === "object" && !Array.isArray(item.inputs), "INVALID_INPUT_BINDINGS");
+  if (item.outputs !== void 0) _chunk4KF7KUAIcjs.requireValue.call(void 0, 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) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, ["proposed", "backlog", "open"].includes(item.status) && !item.owner && _optionalChain([item, 'access', _110 => _110.launch, 'optionalAccess', _111 => _111.admittedAt]) === void 0, "TASK_DEFINITION_FROZEN");
+  if (_chunkKYNYPKKHcjs.taskEditing.call(void 0, item, now)) _chunk4KF7KUAIcjs.requireValue.call(void 0, item.launch.editing.id === editId && !!actor && _chunk4KF7KUAIcjs.principalKey.call(void 0, item.launch.editing.principal) === _chunk4KF7KUAIcjs.principalKey.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor)), "EDIT_LEASE_ACTIVE");
+}
+function applyTaskCommand(state, command, actor, now) {
+  const item = state.board.items.find((i) => i.id === command.itemId);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, item, "ITEM_NOT_FOUND");
+  item.launch ??= { startAt: _chunkKYNYPKKHcjs.taskStartAt.call(void 0, item) };
+  if (["begin-edit", "end-edit", "save-edit"].includes(command.type)) edit(state, item, command, actor, now);
+  else if (command.type === "retry-analysis") {
+    _chunk4KF7KUAIcjs.identity.call(void 0, command.retryId);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, ["failed", "clarification"].includes(_nullishCoalesce(_optionalChain([item, 'access', _112 => _112.analysis, 'optionalAccess', _113 => _113.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);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, _chunkLSE6JG5Icjs.boardAllowsStart.call(void 0, state.board, item), "BOARD_EXECUTION_PAUSED");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, command.trigger === "manual" ? item.launch.requestedAt !== void 0 : _chunkKYNYPKKHcjs.taskDue.call(void 0, item, now), "START_NOT_DUE");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, !item.blocked && _optionalChain([item, 'access', _114 => _114.control, 'optionalAccess', _115 => _115.action]) !== "pause", "ITEM_BLOCKED");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, _nullishCoalesce(_optionalChain([item, 'access', _116 => _116.planning, 'optionalAccess', _117 => _117.dependencies, 'access', _118 => _118.every, 'call', _119 => _119((id) => _optionalChain([catalog, 'call', _120 => _120(state), 'access', _121 => _121.find, 'call', _122 => _122((i) => i.id === id), 'optionalAccess', _123 => _123.status]) === "completed")]), () => ( true)), "DEPENDENCIES_UNFINISHED");
+    item.launch.admittedAt = now;
+  } else if (command.type === "report-analysis") {
+    requireCoordinator(state, actor);
+    _chunk4KF7KUAIcjs.identity.call(void 0, command.operationId);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, 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);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([item, 'access', _124 => _124.control, 'optionalAccess', _125 => _125.id]) === command.controlId, "STALE_CONTROL_RECEIPT");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, ["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);
+    _chunk4KF7KUAIcjs.identity.call(void 0, command.editId);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, Number.isSafeInteger(command.leaseMs) && command.leaseMs >= 1e3 && command.leaseMs <= 3e5, "INVALID_EDIT_LEASE");
+    item.launch.editing = { id: command.editId, principal: _chunk4KF7KUAIcjs.principal.call(void 0, actor), expiresAt: now + command.leaseMs };
+    return;
+  }
+  if (command.type !== "save-edit" && command.type !== "end-edit") return;
+  assertDefinitionEditable(item, now, command.editId, actor);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _chunkKYNYPKKHcjs.taskEditing.call(void 0, item, now) && item.launch.editing.id === command.editId, "EDIT_LEASE_EXPIRED");
+  if (command.type === "save-edit") {
+    _chunk4KF7KUAIcjs.text.call(void 0, command.title);
+    _chunk4KF7KUAIcjs.text.call(void 0, command.responsibility);
+    _chunk4KF7KUAIcjs.text.call(void 0, 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(_nullishCoalesce(_optionalChain([state, 'access', _126 => _126.workflow, 'optionalAccess', _127 => _127.plans]), () => ( {})))) {
+    const definition = plan2.definitions[item.id];
+    if (!definition) continue;
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, Object.values(_nullishCoalesce(definition.inputs, () => ( {}))).every((binding) => _optionalChain([item, 'access', _128 => _128.planning, 'optionalAccess', _129 => _129.dependencies, 'access', _130 => _130.includes, 'call', _131 => _131(binding.fromItemId)])), "EXISTING_DEPENDENCY_REQUIRED");
+    definition.digest = _chunk6MN3H3YFcjs.sha256HexSync.call(void 0, 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) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !["completed", "cancelled", "review"].includes(item.status), "ITEM_COMPLETED");
+  _chunk4KF7KUAIcjs.identity.call(void 0, command.controlId);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, ["pause", "resume"].includes(command.action), "INVALID_CONTROL_ACTION");
+  if (_optionalChain([item, 'access', _132 => _132.control, 'optionalAccess', _133 => _133.id]) === command.controlId) {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, item.control.action === command.action, "IDEMPOTENCY_CONFLICT");
+    return;
+  }
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !item.control || !["requested", "unknown"].includes(item.control.state), "CONTROL_UNSETTLED");
+  const dispatch = Object.values(_nullishCoalesce(_optionalChain([state, 'access', _134 => _134.workflow, 'optionalAccess', _135 => _135.dispatches]), () => ( {}))).find((d) => d.itemId === item.id && ["prepared", "running", "unknown"].includes(d.outcome));
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, dispatch || _optionalChain([item, 'access', _136 => _136.launch, 'optionalAccess', _137 => _137.admittedAt]) === void 0, "TASK_CONTROL_UNSUPPORTED");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, command.action === "pause" || _optionalChain([item, 'access', _138 => _138.control, 'optionalAccess', _139 => _139.action]) === "pause", "TASK_NOT_PAUSED");
+  item.control = { id: command.controlId, dispatchId: _optionalChain([dispatch, 'optionalAccess', _140 => _140.id]), action: command.action, state: "requested" };
+}
+function issues(state, item, command, actor) {
+  requireCoordinator(state, actor);
+  if (command.type === "report-issue") {
+    const issue = command.issue;
+    _chunk4KF7KUAIcjs.identity.call(void 0, issue.id);
+    _chunk4KF7KUAIcjs.identity.call(void 0, issue.attemptId);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, !issue.resolvedBy && ["clarification", "error"].includes(issue.type), "INVALID_ISSUE");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([state, 'access', _141 => _141.workflow, 'optionalAccess', _142 => _142.dispatches, 'access', _143 => _143[issue.attemptId], 'optionalAccess', _144 => _144.itemId]) === item.id && _optionalChain([item, 'access', _145 => _145.owner, 'optionalAccess', _146 => _146.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) {
+      _chunk4KF7KUAIcjs.requireValue.call(void 0, item.issues.length < 200, "ISSUE_LIMIT");
+      item.issues.push(structuredClone(issue));
+    }
+  } else if (command.type === "resolve-issue") {
+    const issue = _optionalChain([item, 'access', _147 => _147.issues, 'optionalAccess', _148 => _148.find, 'call', _149 => _149((i) => i.id === command.issueId && i.attemptId === command.attemptId)]);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, issue, "ISSUE_NOT_FOUND");
+    _chunk4KF7KUAIcjs.identity.call(void 0, command.resolvedBy);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, !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(_nullishCoalesce(_optionalChain([state, 'access', _150 => _150.workflow, 'optionalAccess', _151 => _151.dispatches]), () => ( {}))).filter((d) => d.itemId === item.id).sort((a, b) => a.attempt - b.attempt)[0];
+  const admittedAt = _nullishCoalesce(_optionalChain([first, 'optionalAccess', _152 => _152.preparedAt]), () => ( _optionalChain([item, 'access', _153 => _153.owner, 'optionalAccess', _154 => _154.claimedAt])));
+  item.launch = { startAt: _chunkKYNYPKKHcjs.taskStartAt.call(void 0, item), ...admittedAt === void 0 ? {} : { admittedAt } };
+  item.revision++;
+  return true;
+}
+function setMode(item, mode) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, ["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) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, actor.kind === "human", "FORBIDDEN");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, command.mode !== void 0 || command.paused !== void 0, "INVALID_BOARD_CONTROL");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, command.mode === void 0 || ["automatic", "manual"].includes(command.mode), "INVALID_LAUNCH_MODE");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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) _chunk4KF7KUAIcjs.requireValue.call(void 0, !state.board.items.some((item) => policy2.controls[item.id] === _optionalChain([item, 'access', _155 => _155.control, 'optionalAccess', _156 => _156.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(_nullishCoalesce(_optionalChain([state, 'access', _157 => _157.workflow, 'optionalAccess', _158 => _158.dispatches]), () => ( {}))).some((d) => d.itemId === item.id && ["prepared", "running", "unknown"].includes(d.outcome));
+    const managed = policy2.controls[item.id] === _optionalChain([item, 'access', _159 => _159.control, 'optionalAccess', _160 => _160.id]);
+    if (policy2.paused ? !active || _optionalChain([item, 'access', _161 => _161.control, 'optionalAccess', _162 => _162.action]) === "pause" : !managed || _optionalChain([item, 'access', _163 => _163.control, 'optionalAccess', _164 => _164.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 = _chunk4KF7KUAIcjs.discoveryState.call(void 0, state), pending = _optionalChain([discovery, 'optionalAccess', _165 => _165.pending]);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, pending && pending.runId === batch.runId && pending.token === batch.leaseToken && pending.leaseUntil > now, "SCAN_LEASE_EXPIRED");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([pending, 'access', _166 => _166.request, 'optionalAccess', _167 => _167.command, 'access', _168 => _168.type]) === "apply-discovery" && JSON.stringify(pending.request.command.batch) === JSON.stringify(batch), "SCAN_BATCH_MISMATCH");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, batch.changes.length <= 50, "SCAN_CHANGE_LIMIT");
+  for (const change of batch.changes) {
+    _chunk4KF7KUAIcjs.identity.call(void 0, change.itemId);
+    validateSources(change.sources);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, 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);
+  }
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, (_nullishCoalesce(_optionalChain([batch, 'access', _169 => _169.records, 'optionalAccess', _170 => _170.length]), () => ( 0))) <= 20, "SCAN_RECORD_LIMIT");
+  for (const record of _nullishCoalesce(batch.records, () => ( []))) {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, record.sources.some((source) => source.role === "user"), "USER_EVIDENCE_REQUIRED");
+    const duplicate = _optionalChain([state, 'access', _171 => _171.records, 'optionalAccess', _172 => _172.some, 'call', _173 => _173((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) {
+  _chunk4KF7KUAIcjs.text.call(void 0, change.title);
+  _chunk4KF7KUAIcjs.text.call(void 0, change.responsibility);
+  _chunk4KF7KUAIcjs.text.call(void 0, change.acceptance);
+  const item = {
+    origin: { kind: "discovery", principal: _chunk4KF7KUAIcjs.principal.call(void 0, 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 + _chunkKYNYPKKHcjs.TASK_START_DELAY_MS };
+  item.planning = _nullishCoalesce(change.planning, () => ( { ...plan(item), kind: _nullishCoalesce(state.board.defaultWorkType, () => ( "task")) }));
+  const fingerprint = workFingerprint(item);
+  item.origin.fingerprint = fingerprint;
+  _chunk4KF7KUAIcjs.validateCandidates.call(void 0, state.board, item, _chunk4KF7KUAIcjs.executable.call(void 0, state.board, item));
+  if (_optionalChain([state, 'access', _174 => _174.archiveIndex, 'optionalAccess', _175 => _175.some, 'call', _176 => _176((old) => old.discoveryFingerprint === fingerprint)])) return void 0;
+  const existing = state.board.items.find((old) => workFingerprint(old) === fingerprint || _optionalChain([old, 'access', _177 => _177.origin, 'optionalAccess', _178 => _178.fingerprint]) === fingerprint);
+  if (existing) {
+    existing.revision++;
+    existing.updatedAt = now;
+    return existing;
+  }
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !state.board.items.some((old) => old.id === change.itemId) && !_optionalChain([state, 'access', _179 => _179.archiveIndex, 'optionalAccess', _180 => _180.some, 'call', _181 => _181((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) _chunk4KF7KUAIcjs.participant.call(void 0, 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);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, item, "ITEM_NOT_FOUND");
+  if (change.action === "update") {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, !change.planning, "SCAN_PLANNING_REQUIRES_REVIEW");
+    const ownDraft = item.status === "proposed" && _optionalChain([item, 'access', _182 => _182.origin, 'optionalAccess', _183 => _183.kind]) === "discovery" && _chunk4KF7KUAIcjs.principalKey.call(void 0, item.origin.principal) === _chunk4KF7KUAIcjs.principalKey.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor));
+    if (ownDraft) {
+      _chunk4KF7KUAIcjs.text.call(void 0, change.title);
+      _chunk4KF7KUAIcjs.text.call(void 0, change.responsibility);
+      _chunk4KF7KUAIcjs.text.call(void 0, change.acceptance);
+      item.title = change.title;
+      item.responsibility = change.responsibility;
+      item.acceptance = change.acceptance;
+    } else proposeAmendment(item, change, actor, now, runId);
+  } else _chunk4KF7KUAIcjs.requireValue.call(void 0, 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 = _nullishCoalesce(_optionalChain([item, 'access', _184 => _184.participants, 'access', _185 => _185.find, 'call', _186 => _186((p) => p.sessionId === source.sessionId), 'optionalAccess', _187 => _187.subscribed]), () => ( false));
+    _chunk4KF7KUAIcjs.participant.call(void 0, 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) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, settings && typeof settings.enabled === "boolean" && typeof settings.autoAccept === "boolean", "INVALID_AUTOMATION");
+  for (const ref of [settings.planner, settings.executor, ...settings.preparation ? [settings.preparation] : []]) {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, ref && typeof ref === "object", "INVALID_AUTOMATION_TARGET");
+    _chunk4KF7KUAIcjs.identity.call(void 0, ref.system);
+    _chunk4KF7KUAIcjs.identity.call(void 0, ref.id);
+    _chunk4KF7KUAIcjs.identity.call(void 0, _nullishCoalesce(ref.revision, () => ( "")));
+  }
+  validateOptions(settings.preparationOptions);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, settings.preparation || !Object.keys(_nullishCoalesce(settings.preparationOptions, () => ( {}))).length, "PREPARATION_REQUIRED");
+  const members = [..._nullishCoalesce(board.members, () => ( [])), ...(_nullishCoalesce(board.agents, () => ( []))).filter((agent) => !_optionalChain([board, 'access', _188 => _188.members, 'optionalAccess', _189 => _189.some, 'call', _190 => _190((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"]]) {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, principal2 && ["agent", "human", "service"].includes(principal2.kind), "INVALID_PRINCIPAL");
+    _chunk4KF7KUAIcjs.identity.call(void 0, principal2.id);
+    const existing = members.find((member) => member.kind === principal2.kind && member.id === principal2.id);
+    if (existing) existing.roles = [.../* @__PURE__ */ new Set([..._nullishCoalesce(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";
+  _chunk4KF7KUAIcjs.validateBoard.call(void 0, 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([..._nullishCoalesce(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;
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, options && typeof options === "object" && !Array.isArray(options) && Object.keys(options).length <= 16, "INVALID_PREPARATION_OPTIONS");
+  for (const [key, value] of Object.entries(options)) {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, /^[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);
+  _chunk4KF7KUAIcjs.identity.call(void 0, command.dispatchId);
+  const workflow = state.workflow, previous = workflow.dispatches[command.previousDispatchId];
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, previous && ["failed", "cancelled"].includes(previous.outcome), "EXECUTION_NOT_CONTINUABLE");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !workflow.dispatches[command.dispatchId], "DISPATCH_EXISTS");
+  const item = state.board.items.find((item2) => item2.id === previous.itemId), plan2 = workflow.plans[previous.planId];
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, item && ["backlog", "open"].includes(item.status) && !item.owner, "ITEM_NOT_CONTINUABLE");
+  const attempts = Object.values(workflow.dispatches).filter((row) => row.itemId === item.id);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, attempts.every((row) => row.attempt <= previous.attempt), "STALE_CONTINUATION");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !attempts.some((row) => ["prepared", "running", "unknown", "succeeded"].includes(row.outcome)), "EXECUTION_UNSETTLED");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([plan2, 'optionalAccess', _191 => _191.revision]) === previous.planRevision && _optionalChain([plan2, 'access', _192 => _192.definitions, 'access', _193 => _193[item.id], 'optionalAccess', _194 => _194.digest]) === previous.definitionDigest, "PLAN_CHANGED");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, command.instruction === void 0 || typeof command.instruction === "string" && command.instruction.trim().length > 0 && command.instruction.length <= 8e3, "INVALID_CONTINUATION_INSTRUCTION");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !item.blocked || item.blocked.reason === (_nullishCoalesce(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(_nullishCoalesce(_optionalChain([state, 'access', _195 => _195.workflow, 'optionalAccess', _196 => _196.dispatches]), () => ( {}))).some((dispatch) => ["prepared", "running", "unknown", "succeeded"].includes(dispatch.outcome))) {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, _chunkPSKQAFDFcjs.sameAutomationBinding.call(void 0, 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;
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !["edit-item", "plan-item", "review-amendment"].includes(command.type), "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+  if (plan2.sealed) _chunk4KF7KUAIcjs.requireValue.call(void 0, !["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) _chunk4KF7KUAIcjs.requireValue.call(void 0, !["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") {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, !_optionalChain([state, 'access', _197 => _197.board, 'access', _198 => _198.executionControl, 'optionalAccess', _199 => _199.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) {
+  _chunk4KF7KUAIcjs.identity.call(void 0, command.dispatchId);
+  const workflow = state.workflow;
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !workflow.dispatches[command.dispatchId], "DISPATCH_EXISTS");
+  refreshReady(state);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, workflow.ready.includes(command.itemId), "WORK_NOT_READY");
+  const plan2 = Object.values(workflow.plans).find((plan3) => plan3.itemIds.includes(command.itemId));
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !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" });
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !_chunkKYNYPKKHcjs.taskEditing.call(void 0, item, now), "EDIT_LEASE_ACTIVE");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !_optionalChain([state, 'access', _200 => _200.board, 'access', _201 => _201.executionControl, 'optionalAccess', _202 => _202.paused]), "BOARD_EXECUTION_PAUSED");
+  if (command.trigger === "automatic") _chunk4KF7KUAIcjs.requireValue.call(void 0, _chunkLSE6JG5Icjs.boardAllowsStart.call(void 0, state.board, item) && _chunkKYNYPKKHcjs.taskDue.call(void 0, item, now), "START_NOT_DUE");
+  item.launch ??= { startAt: _chunkKYNYPKKHcjs.taskStartAt.call(void 0, item) };
+  item.launch.admittedAt ??= now;
+  apply({ type: "claim", itemId: item.id, estimate: command.estimate });
+  const inputs = {};
+  for (const [name, binding] of Object.entries(_nullishCoalesce(plan2.definitions[item.id].inputs, () => ( {})))) {
+    const producer = Object.values(workflow.dispatches).reverse().find((dispatch) => dispatch.itemId === binding.fromItemId && dispatch.outcome === "accepted");
+    const output = _optionalChain([producer, 'optionalAccess', _203 => _203.outputs, 'optionalAccess', _204 => _204.find, 'call', _205 => _205((output2) => output2.name === binding.output)]);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, 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: _chunk4KF7KUAIcjs.principal.call(void 0, 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);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, command.fence === dispatch.fence && ["prepared", "running", "unknown"].includes(dispatch.outcome), "STALE_EXECUTION_RESULT");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, ["running", "unknown", "succeeded", "failed", "cancelled"].includes(command.outcome), "INVALID_EXECUTION_OUTCOME");
+  if (command.code !== void 0) _chunk4KF7KUAIcjs.requireValue.call(void 0, /^[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) {
+    _chunk4KF7KUAIcjs.identity.call(void 0, command.executionSessionId);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, !dispatch.executionSessionId || dispatch.executionSessionId === command.executionSessionId, "EXECUTION_SESSION_LOCKED");
+    dispatch.executionSessionId = command.executionSessionId;
+  }
+  if (command.controlCapabilities) {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, ["boundary", "none"].includes(command.controlCapabilities.pause) && typeof command.controlCapabilities.resume === "boolean", "INVALID_CONTROL_CAPABILITIES");
+    dispatch.controlCapabilities = structuredClone(command.controlCapabilities);
+  }
+  const outputs = _nullishCoalesce(command.outputs, () => ( []));
+  validateOutputs(outputs);
+  if (["running", "unknown"].includes(command.outcome)) item.owner.leaseUntil = Math.max(item.owner.leaseUntil, now + state.board.policy.leaseMs);
+  if (!_chunk4XF6LQSUcjs.executionObservationChanged.call(void 0, dispatch, command)) return false;
+  if (command.outcome === "succeeded") {
+    const required = state.workflow.plans[dispatch.planId].definitions[item.id].outputs;
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, 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: _nullishCoalesce(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);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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];
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, dispatch, "DISPATCH_NOT_FOUND");
+  const item = state.board.items.find((item2) => item2.id === dispatch.itemId), plan2 = state.workflow.plans[dispatch.planId];
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([plan2, 'optionalAccess', _206 => _206.revision]) === dispatch.planRevision && _optionalChain([item, 'optionalAccess', _207 => _207.owner, 'optionalAccess', _208 => _208.token]) === dispatch.fence && _optionalChain([plan2, 'access', _209 => _209.definitions, 'access', _210 => _210[dispatch.itemId], 'optionalAccess', _211 => _211.digest]) === dispatch.definitionDigest, "STALE_EXECUTION_RESULT");
+  return dispatch;
+}
+function validateOutputs(outputs) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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) _chunk4KF7KUAIcjs.requireValue.call(void 0, /^[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) => _optionalChain([all, 'access', _212 => _212.find, 'call', _213 => _213((item) => item.id === id), 'optionalAccess', _214 => _214.status]) === "completed")).map((plan2) => plan2.id);
+  state.workflow.ready = state.board.items.filter((item) => included.has(item.id) && _chunkPSKQAFDFcjs.executableWorkItem.call(void 0, state.board, item) && ["backlog", "open"].includes(item.status) && !item.owner && !item.blocked && _optionalChain([item, 'access', _215 => _215.control, 'optionalAccess', _216 => _216.action]) !== "pause" && (_nullishCoalesce(_optionalChain([item, 'access', _217 => _217.planning, 'optionalAccess', _218 => _218.dependencies]), () => ( []))).every((id) => _optionalChain([all, 'access', _219 => _219.find, 'call', _220 => _220((other) => other.id === id), 'optionalAccess', _221 => _221.status]) === "completed")).map((item) => item.id);
+}
+
+// src/transitions.ts
+function transition(state, item, command, actor, now, token) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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 {
+    _chunk4KF7KUAIcjs.owned.call(void 0, item, actor, command.token, now);
+    if (command.type === "submit") _chunk4KF7KUAIcjs.requireValue.call(void 0, 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 = _chunk4KF7KUAIcjs.principalKey.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor));
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !_chunkKYNYPKKHcjs.taskEditing.call(void 0, item, now), "EDIT_LEASE_ACTIVE");
+  _chunk4KF7KUAIcjs.eligible.call(void 0, board, item, actor);
+  assertReady(state, item);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, command.estimate || board.policy.requireEstimate === false, "ESTIMATE_REQUIRED");
+  if (command.estimate) _chunk4KF7KUAIcjs.validateEstimate.call(void 0, command.estimate);
+  const wip = board.items.filter((i) => i.status === "claimed" || i.status === "review");
+  if (command.type === "claim") _chunk4KF7KUAIcjs.requireValue.call(void 0, wip.length < limits(state).inProgress, "WIP_LIMIT");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, wip.filter((i) => i.id !== item.id && i.owner && _chunk4KF7KUAIcjs.assigneeKey.call(void 0, i.owner) === key).length < limits(state).perAssignee, _chunk4KF7KUAIcjs.principal.call(void 0, actor).kind === "agent" ? "AGENT_WIP_LIMIT" : "ASSIGNEE_WIP_LIMIT");
+  if (command.type === "claim") _chunk4KF7KUAIcjs.requireValue.call(void 0, item.status === "open" && !item.owner, "ALREADY_OWNED");
+  else {
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, item.status === "claimed" && item.transfer && _chunk4KF7KUAIcjs.principalKey.call(void 0, transferTarget(item.transfer)) === key, "TRANSFER_NOT_OFFERED");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, item.transfer.expiresAt > now && item.owner && item.owner.leaseUntil > now, "TRANSFER_EXPIRED");
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, _chunk4KF7KUAIcjs.assigneeKey.call(void 0, 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) _chunk4KF7KUAIcjs.participant.call(void 0, item.participants, actor.sessionId, actor.agentId, "owner", true, now);
+}
+function review(state, item, accept2, actor, now) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, item.status === "review", "NOT_IN_REVIEW");
+  const key = _chunk4KF7KUAIcjs.principalKey.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor));
+  const registered = actor.sessionId && item.participants.some((p) => p.sessionId === actor.sessionId && p.roles.includes("reviewer")) || _optionalChain([state, 'access', _222 => _222.board, 'access', _223 => _223.members, 'optionalAccess', _224 => _224.some, 'call', _225 => _225((m) => _chunk4KF7KUAIcjs.principalKey.call(void 0, m) === key && _optionalChain([m, 'access', _226 => _226.roles, 'optionalAccess', _227 => _227.includes, 'call', _228 => _228("reviewer")]))]);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, registered, "REVIEWER_REQUIRED");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !item.owner || _chunk4KF7KUAIcjs.assigneeKey.call(void 0, 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":
+      _chunk4KF7KUAIcjs.requireValue.call(void 0, Number.isFinite(command.workUnits) && command.workUnits >= item.workUnits, "INVALID_WORK_UNITS");
+      item.workUnits = command.workUnits;
+      item.progressAt = now;
+      if (command.estimate) {
+        _chunk4KF7KUAIcjs.validateEstimate.call(void 0, command.estimate);
+        item.estimate = command.estimate;
+      }
+      break;
+    case "request-transfer":
+      requestTransfer(board, item, command, now, token);
+      break;
+    case "submit":
+      _chunk4KF7KUAIcjs.text.call(void 0, 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) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, Boolean(command.target) !== Boolean(command.agentId), "TRANSFER_TARGET_REQUIRED");
+  const target = _nullishCoalesce(command.target, () => ( { kind: "agent", id: command.agentId })), key = _chunk4KF7KUAIcjs.principalKey.call(void 0, target);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _chunk4KF7KUAIcjs.candidates.call(void 0, board, item).some((p) => _chunk4KF7KUAIcjs.principalKey.call(void 0, p) === key), "AGENT_NOT_ELIGIBLE");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _chunk4KF7KUAIcjs.assigneeKey.call(void 0, item.owner) !== key, "SELF_TRANSFER");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !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 _nullishCoalesce(value.target, () => ( { kind: "agent", id: value.agentId }));
+}
+
+// src/reducer.ts
+function reduce(state, command, actor, operationId, now, token, workflowInternal = false) {
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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;
+    _chunk4KF7KUAIcjs.participant.call(void 0, list, command.sessionId, command.agentId, command.role, command.subscribed, now);
+    if (item) item.revision++;
+  } else if (command.type === "message") {
+    _chunk4KF7KUAIcjs.text.call(void 0, command.message);
+    command.recipientSessionIds.forEach(_chunk4KF7KUAIcjs.identity);
+    if (command.itemId) itemFor(board, command.itemId);
+    _chunk4KF7KUAIcjs.requireValue.call(void 0, 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 ? _optionalChain([state, 'access', _229 => _229.workflow, 'optionalAccess', _230 => _230.dispatches, 'access', _231 => _231[command.dispatchId], 'optionalAccess', _232 => _232.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;
+  _chunk4KF7KUAIcjs.identity.call(void 0, input.id);
+  _chunk4KF7KUAIcjs.text.call(void 0, input.title);
+  _chunk4KF7KUAIcjs.text.call(void 0, input.responsibility);
+  _chunk4KF7KUAIcjs.text.call(void 0, input.acceptance);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !board.items.some((i) => i.id === input.id) && !_optionalChain([state, 'access', _233 => _233.archiveIndex, 'optionalAccess', _234 => _234.some, 'call', _235 => _235((i) => i.id === input.id)]), "ITEM_EXISTS");
+  const item = { ...input, origin: { kind: "direct", principal: _chunk4KF7KUAIcjs.principal.call(void 0, actor) }, status: "backlog", revision: 1, createdAt: now, readyAt: now, updatedAt: now, workUnits: 0, participants: [] };
+  item.launch = { startAt: now + _chunkKYNYPKKHcjs.TASK_START_DELAY_MS };
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([command, 'access', _236 => _236.launch, 'optionalAccess', _237 => _237.mode]) === void 0 || ["automatic", "manual"].includes(command.launch.mode), "INVALID_LAUNCH_MODE");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, _optionalChain([command, 'access', _238 => _238.launch, 'optionalAccess', _239 => _239.paused]) === void 0 || typeof command.launch.paused === "boolean", "INVALID_TASK_PAUSE");
+  if (_optionalChain([command, 'access', _240 => _240.launch, 'optionalAccess', _241 => _241.mode])) item.launch.mode = command.launch.mode;
+  if (_optionalChain([command, 'access', _242 => _242.launch, 'optionalAccess', _243 => _243.paused])) item.control = { id: "initial-" + token, action: "pause", state: "paused" };
+  item.planning = _nullishCoalesce(command.planning, () => ( { ...plan(item), kind: _nullishCoalesce(board.defaultWorkType, () => ( "task")) }));
+  const references = _nullishCoalesce(item.externalRefs, () => ( []));
+  item.externalRefs = [];
+  for (const reference of references) attachReference(item, reference);
+  _chunk4KF7KUAIcjs.validateCandidates.call(void 0, board, item, _chunk4KF7KUAIcjs.executable.call(void 0, board, item));
+  validatePlan(state, item, item.planning);
+  if (item.planning.parentId) {
+    const parent = board.items.find((parent2) => parent2.id === item.planning.parentId);
+    if (_optionalChain([parent, 'access', _244 => _244.planning, 'optionalAccess', _245 => _245.execution]) !== "children") {
+      parent.planning = { ...plan(parent), execution: "children" };
+      parent.updatedAt = now;
+      parent.revision++;
+    }
+  }
+  if (actor.sessionId) _chunk4KF7KUAIcjs.participant.call(void 0, 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);
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, 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 = _nullishCoalesce(_optionalChain([state, 'access', _246 => _246.archiveWrites, 'optionalAccess', _247 => _247.flatMap, 'call', _248 => _248((write) => _nullishCoalesce(_optionalChain([write, 'access', _249 => _249.value, 'optionalAccess', _250 => _250.item, 'access', _251 => _251.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(_nullishCoalesce(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" ? _optionalChain([item, 'access', _252 => _252.transfer, 'optionalAccess', _253 => _253.id]) : reason === "backlog-review" ? item.updatedAt : _nullishCoalesce(_optionalChain([item, 'access', _254 => _254.owner, 'optionalAccess', _255 => _255.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 (_optionalChain([item, 'access', _256 => _256.planning, 'optionalAccess', _257 => _257.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 - (_nullishCoalesce(item.progressAt, () => ( item.owner.claimedAt))) >= p.progressTimeoutMs) result.push("no-progress");
+  if (now - item.owner.claimedAt >= Math.min(_nullishCoalesce(_optionalChain([item, 'access', _258 => _258.estimate, 'optionalAccess', _259 => _259.durationMs]), () => ( p.maxDurationMs)), p.maxDurationMs)) result.push("execution-timeout");
+  if ((_nullishCoalesce(_optionalChain([item, 'access', _260 => _260.estimate, 'optionalAccess', _261 => _261.complexity]), () => ( 0))) >= p.maxComplexity) result.push("complexity-threshold");
+  if (Math.max(item.workUnits, _nullishCoalesce(_optionalChain([item, 'access', _262 => _262.estimate, 'optionalAccess', _263 => _263.workUnits]), () => ( 0))) >= p.maxWorkUnits) result.push("work-threshold");
+  if ((_nullishCoalesce(_optionalChain([item, 'access', _264 => _264.estimate, 'optionalAccess', _265 => _265.durationMs]), () => ( 0))) >= p.maxDurationMs) result.push("duration-threshold");
+  return result;
+}
+function eventData(command, state) {
+  if (command.type === "set-board-control") return { code: "BOARD_" + (_optionalChain([state, 'access', _266 => _266.board, 'access', _267 => _267.executionControl, 'optionalAccess', _268 => _268.paused]) ? "PAUSE_REQUESTED" : _optionalChain([state, 'access', _269 => _269.board, 'access', _270 => _270.executionControl, 'optionalAccess', _271 => _271.mode, 'optionalAccess', _272 => _272.toUpperCase, 'call', _273 => _273()])) };
+  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: _optionalChain([state, 'access', _274 => _274.workflow, 'optionalAccess', _275 => _275.ready]), ..."dispatchId" in command ? { dispatchId: command.dispatchId } : { planId: command.plan.id }, ..."outcome" in command ? { reason: `execution-${command.outcome}`, code: command.code, status: _optionalChain([state, 'access', _276 => _276.board, 'access', _277 => _277.items, 'access', _278 => _278.find, 'call', _279 => _279((item) => item.id === _optionalChain([state, 'access', _280 => _280.workflow, 'optionalAccess', _281 => _281.dispatches, 'access', _282 => _282[command.dispatchId], 'optionalAccess', _283 => _283.itemId])), 'optionalAccess', _284 => _284.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: _optionalChain([Object, 'access', _285 => _285.values, 'call', _286 => _286(_nullishCoalesce(_optionalChain([state, 'access', _287 => _287.workflow, 'optionalAccess', _288 => _288.dispatches]), () => ( {}))), 'access', _289 => _289.find, 'call', _290 => _290((dispatch) => dispatch.itemId === command.itemId && dispatch.outcome === "succeeded"), 'optionalAccess', _291 => _291.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: _optionalChain([batch, 'access', _292 => _292.records, 'optionalAccess', _293 => _293.filter, 'call', _294 => _294((record) => _optionalChain([state, 'access', _295 => _295.records, 'optionalAccess', _296 => _296.some, 'call', _297 => _297((entry) => entry.id === record.id && entry.originRunId === batch.runId)])), 'access', _298 => _298.map, 'call', _299 => _299((record) => record.id)]),
+    ...state.board.items.some((item) => _optionalChain([item, 'access', _300 => _300.amendments, 'optionalAccess', _301 => _301.some, 'call', _302 => _302((proposal) => proposal.runId === batch.runId && proposal.status === "pending")])) ? { reason: "amendment-proposed" } : state.board.items.some((item) => item.status === "proposed" && _optionalChain([item, 'access', _303 => _303.origin, 'optionalAccess', _304 => _304.runId]) === batch.runId) ? { reason: "proposal-created" } : {}
+  };
+}
+function deleteBoard(state, actor, operationId, now) {
+  const owner = _chunk4KF7KUAIcjs.principal.call(void 0, actor), board = state.board;
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, owner.kind === "human" && _optionalChain([board, 'access', _305 => _305.members, 'optionalAccess', _306 => _306.some, 'call', _307 => _307((member) => member.kind === owner.kind && member.id === owner.id && _optionalChain([member, 'access', _308 => _308.roles, 'optionalAccess', _309 => _309.includes, 'call', _310 => _310("coordinator")]))]), "COORDINATOR_REQUIRED");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !board.items.some((item) => item.owner || item.transfer || item.status === "claimed"), "BOARD_EXECUTION_ACTIVE");
+  _chunk4KF7KUAIcjs.requireValue.call(void 0, !Object.values(_nullishCoalesce(_optionalChain([state, 'access', _311 => _311.workflow, 'optionalAccess', _312 => _312.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;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.summary = summary; exports.terminal = terminal; exports.catalog = catalog; exports.limits = limits; exports.proposeAmendment = proposeAmendment; exports.queryRecords = queryRecords; exports.recordSummary = recordSummary; exports.createBoardState = createBoardState; exports.boardKey = boardKey; exports.archiveKey = archiveKey; exports.rowKeys = rowKeys; exports.hydrate = hydrate; exports.encodeBoard = encodeBoard; exports.rowChanges = rowChanges; exports.receiptDigest = receiptDigest; exports.verifyReceipt = verifyReceipt; exports.encodeRow = encodeRow; exports.decodeRow = decodeRow; exports.indexedView = indexedView; exports.viewFromState = viewFromState; exports.boardCounterKey = boardCounterKey; exports.boardNumberKey = boardNumberKey; exports.counter = counter; exports.storedBoardNumber = storedBoardNumber; exports.patchBoardNumber = patchBoardNumber; exports.numberEntities = numberEntities; exports.allocateBoardNumber = allocateBoardNumber; exports.reduce = reduce; exports.related = related; exports.escalationReasons = escalationReasons;
+//# sourceMappingURL=chunk-L44TM4EE.cjs.map