@nestos/kanban 0.5.1 → 0.5.2

package/dist/{chunk-OHQTKGQN.js → chunk-XKDZHAUE.js}

@@ -19,27 +19,23 @@ import {
   validateCandidates,
   validateEstimate,
   workType
-} from "./chunk-ATUFFNLV.js";
-import {
-  KanbanError
-} from "./chunk-G6FCDLDF.js";
-import {
-  TASK_START_DELAY_MS,
-  taskDue,
-  taskEditing,
-  taskStartAt
-} from "./chunk-O4OGAAV4.js";
+} from "./chunk-3LEIHB7Y.js";
 import {
   executableWorkItem,
   sameAutomationBinding
-} from "./chunk-5XKOCKY2.js";
+} from "./chunk-X4UHZX6F.js";
 import {
+  KanbanError,
   randomUUID,
   sha256HexSync
-} from "./chunk-TB2RZGDV.js";
+} from "./chunk-M35X5PHO.js";
 import {
-  boardAllowsStart
-} from "./chunk-QTMTBEBA.js";
+  TASK_START_DELAY_MS,
+  boardAllowsStart,
+  taskDue,
+  taskEditing,
+  taskStartAt
+} from "./chunk-3JYLJPE5.js";
 
 // src/planning.ts
 function plan(item) {
@@ -47,6 +43,7 @@ function plan(item) {
 }
 function summary(item) {
   return {
+    deletedAt: item.deletedAt,
     launch: item.launch,
     analysis: item.analysis,
     control: item.control,
@@ -90,7 +87,7 @@ function validatePlan(state, item, value) {
   const all = catalog(state), parent = all.find((i) => i.id === value.parentId);
   if (value.parentId) {
     identity(value.parentId);
-    requireValue(parent && !parent.archivedAt && !terminal(parent) && !["claimed", "review"].includes(parent.status), "PARENT_UNAVAILABLE");
+    requireValue(parent && !parent.archivedAt && !parent.deletedAt && !terminal(parent) && parent.control?.action !== "cancel" && !["claimed", "review"].includes(parent.status), "PARENT_UNAVAILABLE");
     requireValue(parent.id !== item.id && workType(state.board, parent.planning.kind).rank < type.rank, "INVALID_PARENT_KIND");
   }
   requireValue(value.execution === "children" || !all.some((child) => child.planning.parentId === item.id), "CHILDREN_REQUIRE_AGGREGATION");
@@ -106,8 +103,11 @@ function validatePlan(state, item, value) {
   }
 }
 function assertReady(state, item) {
+  requireValue(!state.board.lifecycle, "BOARD_STOPPING");
+  requireValue(!state.board.executionControl?.paused, "BOARD_EXECUTION_PAUSED");
   requireValue(executable(state.board, item), "PLAN_NOT_EXECUTABLE");
   requireValue(!item.blocked, "ITEM_BLOCKED");
+  requireValue(!item.control || item.control.action === "resume" && item.control.state === "resumed", "TASK_CONTROL_PENDING");
   const all = catalog(state);
   requireValue(plan(item).dependencies.every((id) => all.find((i) => i.id === id)?.status === "completed"), "DEPENDENCIES_UNFINISHED");
 }
@@ -209,7 +209,7 @@ function reviewAmendment(board, command, actor, now) {
 
 // src/project-records.ts
 function isRecordCommand(command) {
-  return ["append-record", "review-record", "link-record"].includes(command.type);
+  return ["append-record", "review-record", "link-record", "request-record-cancellation", "cancel-record", "delete-record"].includes(command.type);
 }
 function applyRecord(state, command, actor, now, forceDraft = false) {
   if (command.type === "append-record") {
@@ -218,7 +218,23 @@ function applyRecord(state, command, actor, now, forceDraft = false) {
   }
   const record = state.records?.find((record2) => record2.id === command.recordId);
   requireValue(record, "RECORD_NOT_FOUND");
-  if (command.type === "link-record") {
+  requireValue(record.deletedAt === void 0, "RECORD_DELETED");
+  if (command.type === "request-record-cancellation" || command.type === "cancel-record" || command.type === "delete-record") {
+    requireReviewer(state.board, actor);
+    requireValue(principal(actor).kind === "human", "FORBIDDEN");
+    requireValue(record.kind === "decision", "DECISION_REQUIRED");
+    if (command.type !== "request-record-cancellation") requireValue(record.itemIds.every((id) => {
+      const item = state.board.items.find((i) => i.id === id) ?? state.archiveIndex?.find((i) => i.id === id);
+      return item && ["completed", "cancelled"].includes(item.status);
+    }), "RECORD_EXECUTION_UNSETTLED");
+    if (command.type === "request-record-cancellation") record.status = record.status === "cancelled" ? "cancelled" : "cancelling";
+    else if (command.type === "cancel-record") record.status = "cancelled";
+    else {
+      requireValue(["cancelled", "rejected", "superseded"].includes(record.status), "RECORD_CANCEL_REQUIRED");
+      record.deletedAt = now;
+    }
+  } else if (command.type === "link-record") {
+    requireValue(!["cancelling", "cancelled"].includes(record.status), "RECORD_CANCELLING");
     validateItems(state, [command.itemId]);
     if (!record.itemIds.includes(command.itemId)) {
       requireValue(record.itemIds.length < 100, "RECORD_LINK_LIMIT");
@@ -299,7 +315,7 @@ function queryRecords(state, query = {}, summaries = (state.records ?? []).map(r
   requireValue(Number.isSafeInteger(limit) && limit > 0 && limit <= 200, "INVALID_LIMIT");
   if (query.kind) requireValue(["log", "decision"].includes(query.kind), "INVALID_RECORD_KIND");
   if (query.itemId !== void 0) identity(query.itemId);
-  if (query.status) requireValue(["draft", "confirmed", "rejected", "superseded"].includes(query.status), "INVALID_RECORD_STATUS");
+  if (query.status) requireValue(["draft", "confirmed", "rejected", "superseded", "cancelling", "cancelled"].includes(query.status), "INVALID_RECORD_STATUS");
   const digest = sha256HexSync(JSON.stringify(filter));
   let offset = 0;
   if (cursor) {
@@ -314,7 +330,7 @@ function queryRecords(state, query = {}, summaries = (state.records ?? []).map(r
     offset = decoded.offset;
     requireValue(Number.isSafeInteger(offset) && offset >= 0, "INVALID_CURSOR");
   }
-  const matched = summaries.filter((record) => (!query.kind || query.kind === record.kind) && (!query.itemId || record.itemIds.includes(query.itemId)) && (!query.status || query.status === record.status)).sort((a, b) => b.createdAt - a.createdAt || a.id.localeCompare(b.id));
+  const matched = summaries.filter((record) => (query.includeDeleted || record.deletedAt === void 0) && (!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 })) } : {} };
 }
@@ -514,6 +530,93 @@ function allocateBoardNumber(raw, high) {
   return high + 1;
 }
 
+// src/workflow-plans.ts
+function requireCoordinator(state, actor) {
+  requireValue(state.board.members?.some((member) => principalKey(member) === principalKey(principal(actor)) && member.roles?.includes("coordinator")), "COORDINATOR_REQUIRED");
+}
+function publishPlan(state, plan2, actor, apply) {
+  requireCoordinator(state, actor);
+  requireValue(plan2 && typeof plan2 === "object", "INVALID_WORK_PLAN");
+  identity(plan2.id);
+  requireValue(plan2.schema === "kanban.plan/1" && typeof plan2.sealed === "boolean" && Array.isArray(plan2.items) && plan2.items.length > 0 && plan2.items.length <= 100, "INVALID_WORK_PLAN");
+  const workflow = state.workflow, previous = workflow.plans[plan2.id];
+  requireValue(Number.isSafeInteger(plan2.revision) && plan2.revision === (previous?.revision ?? 0) + 1, "PLAN_REVISION_CONFLICT");
+  requireValue(!Object.values(workflow.dispatches).some((dispatch) => dispatch.planId === plan2.id && ["prepared", "running", "unknown", "succeeded"].includes(dispatch.outcome)), "PLAN_EXECUTION_UNSETTLED");
+  if (plan2.decisionId) {
+    const decision = state.records?.find((record) => record.id === plan2.decisionId && record.kind === "decision" && record.status === "confirmed");
+    requireValue(decision, "DECISION_NOT_CONFIRMED");
+    if (decision.coordination) requireValue(principalKey(decision.coordination.manager) === principalKey(principal(actor)), "DECISION_MANAGER_REQUIRED");
+  }
+  if (plan2.rootItemId) {
+    const root = state.board.items.find((item) => item.id === plan2.rootItemId);
+    requireValue(root && !root.owner && ["backlog", "open"].includes(root.status), "PLAN_ROOT_UNAVAILABLE");
+    if (root.planning?.execution !== "children") apply({ type: "plan-item", itemId: root.id, planning: { ...plan(root), execution: "children" } });
+  }
+  const ordered = orderWork(plan2.items, state), definitions = {};
+  for (const item of ordered) {
+    const digest = sha256HexSync(JSON.stringify(item));
+    requireValue(!Object.values(workflow.plans).some((other) => other.id !== plan2.id && other.itemIds.includes(item.id)), "ITEM_IN_OTHER_PLAN");
+    const exists = state.board.items.some((old) => old.id === item.id) || state.archiveIndex?.some((old) => old.id === item.id);
+    if (exists && previous?.definitions[item.id]?.digest !== digest) {
+      requireValue(!previous?.definitions[item.id], "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+      adoptItem(state, item, apply);
+    }
+    if (!exists) apply({
+      type: "create-item",
+      item: { id: item.id, title: item.title, responsibility: item.responsibility, acceptance: item.acceptance, eligiblePrincipals: [item.assignee], externalRefs: item.externalRefs },
+      planning: { kind: item.workType ?? state.board.defaultWorkType ?? "task", priority: 2, dependencies: item.dependsOn, references: [], ...plan2.rootItemId ? { parentId: plan2.rootItemId } : {} }
+    });
+    definitions[item.id] = { digest, inputs: item.inputs, outputs: item.outputs ?? [] };
+  }
+  workflow.plans[plan2.id] = { schema: plan2.schema, id: plan2.id, revision: plan2.revision, decisionId: plan2.decisionId, rootItemId: plan2.rootItemId, sealed: plan2.sealed, itemIds: ordered.map((item) => item.id), definitions };
+}
+function adoptItem(state, definition, apply) {
+  const item = state.board.items.find((item2) => item2.id === definition.id);
+  requireValue(item && definition.expectedRevision === item.revision && ["backlog", "open"].includes(item.status) && !item.owner && !item.blocked && (!item.control || item.control.action === "resume" && item.control.state === "resumed"), "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+  requireValue(!definition.workType || definition.workType === item.planning?.kind, "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+  requireValue(!definition.externalRefs || definition.externalRefs.every((ref) => item.externalRefs?.some((existing) => JSON.stringify(existing) === JSON.stringify(ref))), "PLAN_RESOURCE_MISMATCH");
+  requireValue(item.title === definition.title && item.responsibility === definition.responsibility && item.acceptance === definition.acceptance, "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
+  requireValue(plan(item).dependencies.every((id) => definition.dependsOn.includes(id)), "EXISTING_DEPENDENCY_REQUIRED");
+  apply({ type: "plan-item", itemId: item.id, planning: { ...plan(item), dependencies: definition.dependsOn } });
+  item.eligiblePrincipals = [definition.assignee];
+  delete item.eligibleAgentIds;
+  validateCandidates(state.board, item, true);
+}
+function orderWork(items, state) {
+  for (const item of items) validateDefinition(item);
+  const ids = new Set(items.map((item) => item.id));
+  requireValue(ids.size === items.length, "DUPLICATE_PLAN_ITEM");
+  for (const item of items) {
+    identity(item.id);
+    requireValue(Array.isArray(item.dependsOn) && item.dependsOn.length <= 100 && new Set(item.dependsOn).size === item.dependsOn.length, "INVALID_DEPENDENCIES");
+    requireValue(Object.keys(item.inputs ?? {}).length <= 100 && Array.isArray(item.outputs ?? []) && (item.outputs ?? []).length <= 100 && new Set(item.outputs ?? []).size === (item.outputs ?? []).length, "PLAN_BINDING_LIMIT");
+    for (const name of [...Object.keys(item.inputs ?? {}), ...item.outputs ?? []]) requireValue(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(name), "INVALID_OUTPUT_NAME");
+    for (const binding of Object.values(item.inputs ?? {})) {
+      requireValue(binding && item.dependsOn.includes(binding.fromItemId) && typeof binding.output === "string", "INPUT_DEPENDENCY_REQUIRED");
+      const producer = items.find((other) => other.id === binding.fromItemId), existing = Object.values(state.workflow.dispatches).some((dispatch) => dispatch.itemId === binding.fromItemId && dispatch.outcome === "accepted" && dispatch.outputs?.some((output) => output.name === binding.output));
+      requireValue(producer ? producer.outputs?.includes(binding.output) : existing, "OUTPUT_NOT_DECLARED");
+    }
+    for (const dependency of item.dependsOn) requireValue(ids.has(dependency) || [...state.board.items, ...state.archiveIndex ?? []].some((old) => old.id === dependency), "DEPENDENCY_NOT_FOUND");
+  }
+  const ordered = [], remaining = [...items], done = /* @__PURE__ */ new Set();
+  while (remaining.length) {
+    const next = remaining.findIndex((item2) => item2.dependsOn.every((id) => !ids.has(id) || done.has(id)));
+    requireValue(next >= 0, "DEPENDENCY_CYCLE");
+    const [item] = remaining.splice(next, 1);
+    ordered.push(item);
+    done.add(item.id);
+  }
+  return ordered;
+}
+function validateDefinition(item) {
+  requireValue(item && typeof item === "object" && !Array.isArray(item), "INVALID_WORK_DEFINITION");
+  const assignee = item.assignee;
+  requireValue(assignee && ["agent", "human", "service"].includes(assignee.kind), "INVALID_PRINCIPAL");
+  identity(assignee.id);
+  if (item.inputs !== void 0) requireValue(item.inputs && typeof item.inputs === "object" && !Array.isArray(item.inputs), "INVALID_INPUT_BINDINGS");
+  if (item.outputs !== void 0) requireValue(Array.isArray(item.outputs) && item.outputs.every((name) => typeof name === "string"), "INVALID_OUTPUT_NAMES");
+}
+
 // src/archives.ts
 function archiveItems(state, ids, reason, now) {
   text(reason);
@@ -592,6 +695,7 @@ function operate(item, command, now, actor) {
   item.revision++;
 }
 function updatePlan(state, item, command, now) {
+  if (command.type === "close-plan") requireValue(item.control?.action !== "cancel", "TASK_CANCELLING");
   if (command.type === "cancel-item") requireValue(item.launch?.admittedAt === void 0, "TASK_CONTROL_REQUIRED");
   if (command.type === "publish-proposal") {
     requireValue(item.status === "proposed", "NOT_PROPOSED");
@@ -640,99 +744,13 @@ function attachReference(item, reference) {
   item.externalRefs.push(reference);
 }
 
-// src/workflow-plans.ts
-function requireCoordinator(state, actor) {
-  requireValue(state.board.members?.some((member) => principalKey(member) === principalKey(principal(actor)) && member.roles?.includes("coordinator")), "COORDINATOR_REQUIRED");
-}
-function publishPlan(state, plan2, actor, apply) {
-  requireCoordinator(state, actor);
-  requireValue(plan2 && typeof plan2 === "object", "INVALID_WORK_PLAN");
-  identity(plan2.id);
-  requireValue(plan2.schema === "kanban.plan/1" && typeof plan2.sealed === "boolean" && Array.isArray(plan2.items) && plan2.items.length > 0 && plan2.items.length <= 100, "INVALID_WORK_PLAN");
-  const workflow = state.workflow, previous = workflow.plans[plan2.id];
-  requireValue(Number.isSafeInteger(plan2.revision) && plan2.revision === (previous?.revision ?? 0) + 1, "PLAN_REVISION_CONFLICT");
-  requireValue(!Object.values(workflow.dispatches).some((dispatch) => dispatch.planId === plan2.id && ["prepared", "running", "unknown", "succeeded"].includes(dispatch.outcome)), "PLAN_EXECUTION_UNSETTLED");
-  if (plan2.decisionId) {
-    const decision = state.records?.find((record) => record.id === plan2.decisionId && record.kind === "decision" && record.status === "confirmed");
-    requireValue(decision, "DECISION_NOT_CONFIRMED");
-    if (decision.coordination) requireValue(principalKey(decision.coordination.manager) === principalKey(principal(actor)), "DECISION_MANAGER_REQUIRED");
-  }
-  if (plan2.rootItemId) {
-    const root = state.board.items.find((item) => item.id === plan2.rootItemId);
-    requireValue(root && !root.owner && ["backlog", "open"].includes(root.status), "PLAN_ROOT_UNAVAILABLE");
-    if (root.planning?.execution !== "children") apply({ type: "plan-item", itemId: root.id, planning: { ...plan(root), execution: "children" } });
-  }
-  const ordered = orderWork(plan2.items, state), definitions = {};
-  for (const item of ordered) {
-    const digest = sha256HexSync(JSON.stringify(item));
-    requireValue(!Object.values(workflow.plans).some((other) => other.id !== plan2.id && other.itemIds.includes(item.id)), "ITEM_IN_OTHER_PLAN");
-    const exists = state.board.items.some((old) => old.id === item.id) || state.archiveIndex?.some((old) => old.id === item.id);
-    if (exists && previous?.definitions[item.id]?.digest !== digest) {
-      requireValue(!previous?.definitions[item.id], "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
-      adoptItem(state, item, apply);
-    }
-    if (!exists) apply({
-      type: "create-item",
-      item: { id: item.id, title: item.title, responsibility: item.responsibility, acceptance: item.acceptance, eligiblePrincipals: [item.assignee], externalRefs: item.externalRefs },
-      planning: { kind: item.workType ?? state.board.defaultWorkType ?? "task", priority: 2, dependencies: item.dependsOn, references: [], ...plan2.rootItemId ? { parentId: plan2.rootItemId } : {} }
-    });
-    definitions[item.id] = { digest, inputs: item.inputs, outputs: item.outputs ?? [] };
-  }
-  workflow.plans[plan2.id] = { schema: plan2.schema, id: plan2.id, revision: plan2.revision, decisionId: plan2.decisionId, rootItemId: plan2.rootItemId, sealed: plan2.sealed, itemIds: ordered.map((item) => item.id), definitions };
-}
-function adoptItem(state, definition, apply) {
-  const item = state.board.items.find((item2) => item2.id === definition.id);
-  requireValue(item && definition.expectedRevision === item.revision && ["backlog", "open"].includes(item.status) && !item.owner && !item.blocked, "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
-  requireValue(!definition.workType || definition.workType === item.planning?.kind, "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
-  requireValue(!definition.externalRefs || definition.externalRefs.every((ref) => item.externalRefs?.some((existing) => JSON.stringify(existing) === JSON.stringify(ref))), "PLAN_RESOURCE_MISMATCH");
-  requireValue(item.title === definition.title && item.responsibility === definition.responsibility && item.acceptance === definition.acceptance, "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
-  requireValue(plan(item).dependencies.every((id) => definition.dependsOn.includes(id)), "EXISTING_DEPENDENCY_REQUIRED");
-  apply({ type: "plan-item", itemId: item.id, planning: { ...plan(item), dependencies: definition.dependsOn } });
-  item.eligiblePrincipals = [definition.assignee];
-  delete item.eligibleAgentIds;
-  validateCandidates(state.board, item, true);
-}
-function orderWork(items, state) {
-  for (const item of items) validateDefinition(item);
-  const ids = new Set(items.map((item) => item.id));
-  requireValue(ids.size === items.length, "DUPLICATE_PLAN_ITEM");
-  for (const item of items) {
-    identity(item.id);
-    requireValue(Array.isArray(item.dependsOn) && item.dependsOn.length <= 100 && new Set(item.dependsOn).size === item.dependsOn.length, "INVALID_DEPENDENCIES");
-    requireValue(Object.keys(item.inputs ?? {}).length <= 100 && Array.isArray(item.outputs ?? []) && (item.outputs ?? []).length <= 100 && new Set(item.outputs ?? []).size === (item.outputs ?? []).length, "PLAN_BINDING_LIMIT");
-    for (const name of [...Object.keys(item.inputs ?? {}), ...item.outputs ?? []]) requireValue(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(name), "INVALID_OUTPUT_NAME");
-    for (const binding of Object.values(item.inputs ?? {})) {
-      requireValue(binding && item.dependsOn.includes(binding.fromItemId) && typeof binding.output === "string", "INPUT_DEPENDENCY_REQUIRED");
-      const producer = items.find((other) => other.id === binding.fromItemId), existing = Object.values(state.workflow.dispatches).some((dispatch) => dispatch.itemId === binding.fromItemId && dispatch.outcome === "accepted" && dispatch.outputs?.some((output) => output.name === binding.output));
-      requireValue(producer ? producer.outputs?.includes(binding.output) : existing, "OUTPUT_NOT_DECLARED");
-    }
-    for (const dependency of item.dependsOn) requireValue(ids.has(dependency) || [...state.board.items, ...state.archiveIndex ?? []].some((old) => old.id === dependency), "DEPENDENCY_NOT_FOUND");
-  }
-  const ordered = [], remaining = [...items], done = /* @__PURE__ */ new Set();
-  while (remaining.length) {
-    const next = remaining.findIndex((item2) => item2.dependsOn.every((id) => !ids.has(id) || done.has(id)));
-    requireValue(next >= 0, "DEPENDENCY_CYCLE");
-    const [item] = remaining.splice(next, 1);
-    ordered.push(item);
-    done.add(item.id);
-  }
-  return ordered;
-}
-function validateDefinition(item) {
-  requireValue(item && typeof item === "object" && !Array.isArray(item), "INVALID_WORK_DEFINITION");
-  const assignee = item.assignee;
-  requireValue(assignee && ["agent", "human", "service"].includes(assignee.kind), "INVALID_PRINCIPAL");
-  identity(assignee.id);
-  if (item.inputs !== void 0) requireValue(item.inputs && typeof item.inputs === "object" && !Array.isArray(item.inputs), "INVALID_INPUT_BINDINGS");
-  if (item.outputs !== void 0) requireValue(Array.isArray(item.outputs) && item.outputs.every((name) => typeof name === "string"), "INVALID_OUTPUT_NAMES");
-}
-
 // src/task-commands.ts
 var types = ["set-launch-mode", "retry-analysis", "begin-edit", "end-edit", "save-edit", "request-run", "admit-item", "report-analysis", "request-control", "control-receipt", "report-issue", "resolve-issue"];
 function taskCommand(command) {
   return types.includes(command.type);
 }
 function assertDefinitionEditable(item, now, editId, actor) {
+  requireValue(item.control?.action !== "cancel", "TASK_CANCELLING");
   requireValue(["proposed", "backlog", "open"].includes(item.status) && !item.owner && item.launch?.admittedAt === void 0, "TASK_DEFINITION_FROZEN");
   if (taskEditing(item, now)) requireValue(item.launch.editing.id === editId && !!actor && principalKey(item.launch.editing.principal) === principalKey(principal(actor)), "EDIT_LEASE_ACTIVE");
 }
@@ -756,6 +774,7 @@ function applyTaskCommand(state, command, actor, now) {
     requireCoordinator(state, actor);
     assertDefinitionEditable(item, now);
     requireValue(boardAllowsStart(state.board, item), "BOARD_EXECUTION_PAUSED");
+    requireValue(!item.control || item.control.action === "resume" && item.control.state === "resumed", "TASK_CONTROL_PENDING");
     requireValue(command.trigger === "manual" ? item.launch.requestedAt !== void 0 : taskDue(item, now), "START_NOT_DUE");
     requireValue(!item.blocked && item.control?.action !== "pause", "ITEM_BLOCKED");
     requireValue(item.planning?.dependencies.every((id) => catalog(state).find((i) => i.id === id)?.status === "completed") ?? true, "DEPENDENCIES_UNFINISHED");
@@ -764,15 +783,13 @@ function applyTaskCommand(state, command, actor, now) {
     requireCoordinator(state, actor);
     identity(command.operationId);
     requireValue(command.status.itemId === item.id, "ANALYSIS_SCOPE_MISMATCH");
+    requireValue(item.control?.action !== "cancel" && !["completed", "cancelled"].includes(item.status), "TASK_CANCELLING");
     item.analysis = structuredClone(command.status);
-  } else if (command.type === "request-control") requestControl(state, item, command);
-  else if (command.type === "control-receipt") {
-    requireCoordinator(state, actor);
-    requireValue(item.control?.id === command.controlId, "STALE_CONTROL_RECEIPT");
-    requireValue(["accepted", "paused", "resumed", "failed", "unknown"].includes(command.state), "INVALID_CONTROL_STATE");
-    item.control.state = command.state;
-    item.control.code = command.code;
-  } else issues(state, item, command, actor);
+  } else if (command.type === "request-control") {
+    requestControl(state, item, command);
+    if (command.action === "cancel") cancelChildren(state, item, command.controlId);
+  } else if (command.type === "control-receipt") applyControlReceipt(state, item, command, actor, now);
+  else issues(state, item, command, actor);
   item.updatedAt = now;
   item.revision++;
 }
@@ -808,17 +825,18 @@ function edit(state, item, command, actor, now) {
   delete item.launch.editing;
 }
 function requestControl(state, item, command) {
-  requireValue(!["completed", "cancelled", "review"].includes(item.status), "ITEM_COMPLETED");
+  requireValue(!["completed", "cancelled"].includes(item.status), "ITEM_COMPLETED");
   identity(command.controlId);
-  requireValue(["pause", "resume"].includes(command.action), "INVALID_CONTROL_ACTION");
+  requireValue(["pause", "resume", "cancel"].includes(command.action), "INVALID_CONTROL_ACTION");
   if (item.control?.id === command.controlId) {
     requireValue(item.control.action === command.action, "IDEMPOTENCY_CONFLICT");
     return;
   }
-  requireValue(!item.control || !["requested", "unknown"].includes(item.control.state), "CONTROL_UNSETTLED");
-  const dispatch = Object.values(state.workflow?.dispatches ?? {}).find((d) => d.itemId === item.id && ["prepared", "running", "unknown"].includes(d.outcome));
-  requireValue(dispatch || item.launch?.admittedAt === void 0, "TASK_CONTROL_UNSUPPORTED");
-  requireValue(command.action === "pause" || item.control?.action === "pause", "TASK_NOT_PAUSED");
+  if (command.action === "cancel" && item.control?.action === "cancel" && item.control.state !== "failed") return;
+  requireValue(command.action === "cancel" || !item.control || !["requested", "unknown"].includes(item.control.state), "CONTROL_UNSETTLED");
+  const dispatch = Object.values(state.workflow?.dispatches ?? {}).filter((d) => d.itemId === item.id).sort((a, b) => b.attempt - a.attempt)[0];
+  requireValue(!item.owner || dispatch || command.action === "cancel", "TASK_CONTROL_UNSUPPORTED");
+  requireValue(command.action !== "resume" || item.control?.action === "pause", "TASK_NOT_PAUSED");
   item.control = { id: command.controlId, dispatchId: dispatch?.id, action: command.action, state: "requested" };
 }
 function issues(state, item, command, actor) {
@@ -856,6 +874,84 @@ function setMode(item, mode) {
   item.launch.mode = mode;
   delete item.launch.requestedAt;
 }
+function cancelChildren(state, parent, controlId) {
+  const ids = /* @__PURE__ */ new Set([parent.id]);
+  for (let pass = 0; pass < state.board.items.length; pass++) {
+    const children = state.board.items.filter((item) => item.planning?.parentId && ids.has(item.planning.parentId) && !ids.has(item.id));
+    if (!children.length) return;
+    for (const child of children) {
+      ids.add(child.id);
+      if (["completed", "cancelled"].includes(child.status) || child.control?.action === "cancel") continue;
+      requestControl(state, child, { type: "request-control", itemId: child.id, controlId: sha256HexSync(JSON.stringify([controlId, child.id])), action: "cancel" });
+      child.updatedAt = parent.updatedAt;
+      child.revision++;
+    }
+  }
+}
+function applyControlReceipt(state, item, command, actor, now) {
+  requireCoordinator(state, actor);
+  requireValue(item.control?.id === command.controlId, "STALE_CONTROL_RECEIPT");
+  requireValue(["accepted", "paused", "resumed", "cancelled", "failed", "unknown"].includes(command.state), "INVALID_CONTROL_STATE");
+  requireValue(command.code === void 0 || /^[A-Z][A-Z0-9_]{0,79}$/.test(command.code), "INVALID_ERROR_CODE");
+  if (command.state === "cancelled") {
+    requireValue(item.control.action === "cancel", "INVALID_CONTROL_STATE");
+    for (const dispatch of Object.values(state.workflow?.dispatches ?? {}).filter((d) => d.itemId === item.id && ["prepared", "running", "unknown", "succeeded"].includes(d.outcome))) {
+      requireValue(dispatch.id === item.control.dispatchId && item.owner?.token === dispatch.fence, "STALE_EXECUTION_RESULT");
+      dispatch.outcome = "cancelled";
+      dispatch.code = "USER_CANCELLED";
+    }
+    requireValue(!catalog(state).some((i) => i.planning.parentId === item.id && !["completed", "cancelled"].includes(i.status)), "CHILDREN_UNFINISHED");
+    item.status = "cancelled";
+    item.closedAt = now;
+    item.closureReason = "USER_CANCELLED";
+    delete item.owner;
+    delete item.transfer;
+    delete item.blocked;
+    delete item.launch.editing;
+  }
+  requireValue(item.control.state !== "cancelled" || command.state === "cancelled", "STALE_CONTROL_RECEIPT");
+  item.control.state = command.state;
+  item.control.code = command.code;
+}
+
+// src/board-stop.ts
+function stopBoard(state, command, actor, now) {
+  requireCoordinator(state, actor);
+  requireValue(actor.kind === "human", "FORBIDDEN");
+  identity(command.controlId);
+  if (command.type === "observe-board-stop") {
+    requireValue(state.board.lifecycle?.operationId === command.controlId, "STALE_CONTROL_RECEIPT");
+    requireValue(["waiting", "ready", "blocked"].includes(command.phase), "INVALID_CONTROL_STATE");
+    requireValue(command.code === void 0 || /^[A-Z][A-Z0-9_]{0,79}$/.test(command.code), "INVALID_ERROR_CODE");
+    state.board.lifecycle.phase = command.phase;
+    state.board.lifecycle.code = command.code;
+    return;
+  }
+  requireValue(["cancel", "delete"].includes(command.intent) && ["drain", "cancel"].includes(command.mode), "INVALID_BOARD_CONTROL");
+  const old = state.board.lifecycle;
+  if (old) {
+    requireValue(old.intent === "cancel" && command.intent === "delete" || old.operationId === command.controlId, "BOARD_STOP_PENDING");
+    if (old.operationId === command.controlId) return;
+  }
+  state.board.lifecycle = { operationId: command.controlId, intent: command.intent, mode: command.mode, phase: "waiting" };
+  state.board.executionControl = { ...state.board.executionControl, mode: "manual", paused: true, controls: {} };
+  if (state.board.automation) state.board.automation.enabled = false;
+  if (command.mode !== "cancel") return;
+  for (const item of state.board.items) if (!["completed", "cancelled"].includes(item.status)) applyTaskCommand(
+    state,
+    { type: "request-control", itemId: item.id, controlId: sha256HexSync(JSON.stringify([command.controlId, item.id])), action: "cancel" },
+    actor,
+    now
+  );
+}
+function protectStoppedBoard(state, command) {
+  if (!state.board.lifecycle) return;
+  if (command.type === "append-record" && command.record.kind === "decision") requireValue(false, "BOARD_STOPPING");
+  const fresh = ["create-item", "admit-item", "prepare-dispatch", "continue-execution", "publish-plan", "request-run", "apply-discovery", "begin-edit", "save-edit"];
+  requireValue(!fresh.includes(command.type), "BOARD_STOPPING");
+  if (command.type === "set-board-control") requireValue(command.paused !== false && command.mode !== "automatic", "BOARD_STOPPING");
+  if (command.type === "configure-automation") requireValue(!command.settings.enabled, "BOARD_STOPPING");
+}
 
 // src/board-control.ts
 function setBoardControl(state, command, actor, now, token) {
@@ -871,7 +967,7 @@ function setBoardControl(state, command, actor, now, token) {
   if (policy2.paused) policy2.controls = {};
   state.board.items.forEach((item, index) => {
     if (["completed", "cancelled", "review"].includes(item.status)) return;
-    const active = Object.values(state.workflow?.dispatches ?? {}).some((d) => d.itemId === item.id && ["prepared", "running", "unknown"].includes(d.outcome));
+    const active = item.analysis?.state === "analyzing" || item.launch?.admittedAt !== void 0 || Object.values(state.workflow?.dispatches ?? {}).some((d) => d.itemId === item.id && ["prepared", "running", "unknown"].includes(d.outcome));
     const managed = policy2.controls[item.id] === item.control?.id;
     if (policy2.paused ? !active || item.control?.action === "pause" : !managed || item.control?.action !== "pause") return;
     if (item.control && ["requested", "unknown"].includes(item.control.state)) return;
@@ -1064,7 +1160,7 @@ function protectWorkflowItem(state, command) {
   requireValue(!["edit-item", "plan-item", "review-amendment"].includes(command.type), "PLAN_ITEM_CHANGED_REQUIRES_NEW_ID");
   if (plan2.sealed) requireValue(!["claim", "submit", "review", "close-plan"].includes(command.type), "WORKFLOW_COMMAND_REQUIRED");
   const live = Object.values(state.workflow.dispatches).some((dispatch) => dispatch.itemId === command.itemId && ["prepared", "running", "unknown", "succeeded"].includes(dispatch.outcome));
-  if (live) requireValue(!["request-transfer", "accept-transfer", "release-item", "cancel-item"].includes(command.type), "EXECUTION_UNSETTLED");
+  if (live) requireValue(!["delete-item", "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: [] };
@@ -1082,6 +1178,8 @@ function applyWorkflow(state, command, actor, now, apply) {
 function prepare(state, command, actor, now, apply) {
   identity(command.dispatchId);
   const workflow = state.workflow;
+  const controlled = state.board.items.find((item2) => item2.id === command.itemId);
+  requireValue(!controlled?.control || controlled.control.action === "resume" && controlled.control.state === "resumed", "TASK_CONTROL_PENDING");
   requireValue(!workflow.dispatches[command.dispatchId], "DISPATCH_EXISTS");
   refreshReady(state);
   requireValue(workflow.ready.includes(command.itemId), "WORK_NOT_READY");
@@ -1147,6 +1245,7 @@ function observe(state, command, actor, now) {
 function accept(state, command, actor, apply) {
   requireCoordinator(state, actor);
   const dispatch = activeDispatch(state, command.dispatchId);
+  requireValue(state.board.items.find((item) => item.id === dispatch.itemId)?.control?.action !== "cancel", "TASK_CANCELLING");
   requireValue(dispatch.outcome === "succeeded", "EXECUTION_NOT_SUCCEEDED");
   apply({ type: "review", itemId: dispatch.itemId, accept: command.accept }, actor);
   dispatch.outcome = command.accept ? "accepted" : "rejected";
@@ -1171,7 +1270,7 @@ function refreshReady(state) {
   if (!state.workflow) return;
   const all = catalog(state), included = new Set(Object.values(state.workflow.plans).filter((plan2) => plan2.sealed).flatMap((plan2) => plan2.itemIds));
   state.workflow.completedPlans = Object.values(state.workflow.plans).filter((plan2) => plan2.sealed && plan2.itemIds.every((id) => all.find((item) => item.id === id)?.status === "completed")).map((plan2) => plan2.id);
-  state.workflow.ready = state.board.items.filter((item) => included.has(item.id) && executableWorkItem(state.board, item) && ["backlog", "open"].includes(item.status) && !item.owner && !item.blocked && item.control?.action !== "pause" && (item.planning?.dependencies ?? []).every((id) => all.find((other) => other.id === id)?.status === "completed")).map((item) => item.id);
+  state.workflow.ready = state.board.items.filter((item) => included.has(item.id) && executableWorkItem(state.board, item) && ["backlog", "open"].includes(item.status) && !item.owner && !item.blocked && (!item.control || item.control.action === "resume" && item.control.state === "resumed") && (item.planning?.dependencies ?? []).every((id) => all.find((other) => other.id === id)?.status === "completed")).map((item) => item.id);
 }
 
 // src/transitions.ts
@@ -1213,6 +1312,7 @@ function claim(state, item, command, actor, now, token) {
   if (actor.sessionId) participant(item.participants, actor.sessionId, actor.agentId, "owner", true, now);
 }
 function review(state, item, accept2, actor, now) {
+  requireValue(item.control?.action !== "cancel", "TASK_CANCELLING");
   requireValue(item.status === "review", "NOT_IN_REVIEW");
   const key = principalKey(principal(actor));
   const registered = actor.sessionId && item.participants.some((p) => p.sessionId === actor.sessionId && p.roles.includes("reviewer")) || state.board.members?.some((m) => principalKey(m) === key && m.roles?.includes("reviewer"));
@@ -1269,6 +1369,8 @@ function transferTarget(value) {
 function reduce(state, command, actor, operationId, now, token, workflowInternal = false) {
   requireValue(state.board.deletedAt === void 0, "BOARD_DELETED");
   numberEntities(state);
+  protectStoppedBoard(state, command);
+  if ("itemId" in command && command.itemId) requireValue(state.board.items.find((i) => i.id === command.itemId)?.deletedAt === void 0, "ITEM_DELETED");
   if (!workflowInternal) protectWorkflowItem(state, command);
   const board = state.board;
   if (command.type === "delete-board") return deleteBoard(state, actor, operationId, now);
@@ -1278,8 +1380,18 @@ function reduce(state, command, actor, operationId, now, token, workflowInternal
     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);
+  if (command.type === "request-board-stop" || command.type === "observe-board-stop") stopBoard(state, command, actor, now);
+  else if (command.type === "set-board-control") setBoardControl(state, command, actor, now, token);
+  else if (command.type === "delete-item") {
+    const item = itemFor(board, command.itemId);
+    requireValue(principal(actor).kind === "human", "FORBIDDEN");
+    requireValue(terminal(item), "ITEM_DELETE_REQUIRES_CLOSED");
+    delete item.owner;
+    delete item.transfer;
+    item.deletedAt = now;
+    item.updatedAt = now;
+    item.revision++;
+  } 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);
   });
@@ -1419,7 +1531,8 @@ function escalationReasons(board, item, now) {
   return result;
 }
 function eventData(command, state) {
-  if (command.type === "set-board-control") return { code: "BOARD_" + (state.board.executionControl?.paused ? "PAUSE_REQUESTED" : state.board.executionControl?.mode?.toUpperCase()) };
+  if (command.type === "request-board-stop" || command.type === "observe-board-stop") return { code: state.board.lifecycle?.code, reason: state.board.lifecycle?.intent, itemIds: state.board.items.filter((item) => item.control?.action === "cancel").map((item) => item.id) };
+  else if (command.type === "set-board-control") return { code: "BOARD_" + (state.board.executionControl?.paused ? "PAUSE_REQUESTED" : state.board.executionControl?.mode?.toUpperCase()) };
   if (command.type === "apply-discovery") return discoveryEvent(state, command.batch);
   if (command.type === "report-analysis") return { code: command.status.code, reason: "analysis-" + command.status.state };
   if (command.type === "control-receipt") return { code: command.code, reason: "control-" + command.state };
@@ -1453,8 +1566,9 @@ function discoveryEvent(state, batch) {
 function deleteBoard(state, actor, operationId, now) {
   const owner = principal(actor), board = state.board;
   requireValue(owner.kind === "human" && board.members?.some((member) => member.kind === owner.kind && member.id === owner.id && member.roles?.includes("coordinator")), "COORDINATOR_REQUIRED");
-  requireValue(!board.items.some((item) => item.owner || item.transfer || item.status === "claimed"), "BOARD_EXECUTION_ACTIVE");
+  requireValue(!board.items.some((item) => !terminal(item) && (item.owner || item.transfer || item.status === "claimed")), "BOARD_EXECUTION_ACTIVE");
   requireValue(!Object.values(state.workflow?.dispatches ?? {}).some((dispatch) => ["prepared", "running", "unknown", "succeeded"].includes(dispatch.outcome)), "BOARD_EXECUTION_UNSETTLED");
+  requireValue(!board.items.some((item) => item.control?.action === "cancel" && item.control.state !== "cancelled" && !terminal(item)), "BOARD_CONTROL_UNSETTLED");
   board.deletedAt = now;
   board.revision++;
   if (board.automation) board.automation.enabled = false;
@@ -1495,4 +1609,4 @@ export {
   related,
   escalationReasons
 };
-//# sourceMappingURL=chunk-OHQTKGQN.js.map
+//# sourceMappingURL=chunk-XKDZHAUE.js.map