@kitsy/coop-core 0.0.1

package/dist/index.cjs

@@ -0,0 +1,2097 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ArtifactType: () => ArtifactType,
+  CURRENT_SCHEMA_VERSION: () => CURRENT_SCHEMA_VERSION,
+  DeliveryStatus: () => DeliveryStatus,
+  ExecutorType: () => ExecutorType,
+  ITEM_STATUSES: () => ITEM_STATUSES,
+  ITEM_TYPES: () => ITEM_TYPES,
+  IdeaStatus: () => IdeaStatus,
+  RiskLevel: () => RiskLevel,
+  RunbookAction: () => RunbookAction,
+  TaskComplexity: () => TaskComplexity,
+  TaskDeterminism: () => TaskDeterminism,
+  TaskPriority: () => TaskPriority,
+  TaskStatus: () => TaskStatus,
+  TaskType: () => TaskType,
+  VALID_TASK_TRANSITIONS: () => VALID_TASK_TRANSITIONS,
+  VALID_TRANSITIONS: () => VALID_TRANSITIONS,
+  build_graph: () => build_graph,
+  check_blocked: () => check_blocked,
+  check_unblocked: () => check_unblocked,
+  completeItem: () => completeItem,
+  compute_all_readiness: () => compute_all_readiness,
+  compute_readiness: () => compute_readiness,
+  compute_readiness_with_corrections: () => compute_readiness_with_corrections,
+  createItem: () => createItem,
+  deleteItem: () => deleteItem,
+  detect_cycle: () => detect_cycle,
+  ensureCoopLayout: () => ensureCoopLayout,
+  extract_subgraph: () => extract_subgraph,
+  findRepoRoot: () => findRepoRoot,
+  find_external_dependencies: () => find_external_dependencies,
+  getItemById: () => getItemById,
+  loadState: () => loadState,
+  load_graph: () => load_graph,
+  parseDeliveryContent: () => parseDeliveryContent,
+  parseDeliveryFile: () => parseDeliveryFile,
+  parseFrontmatterContent: () => parseFrontmatterContent,
+  parseFrontmatterFile: () => parseFrontmatterFile,
+  parseIdeaContent: () => parseIdeaContent,
+  parseIdeaFile: () => parseIdeaFile,
+  parseTaskContent: () => parseTaskContent,
+  parseTaskFile: () => parseTaskFile,
+  parseYamlContent: () => parseYamlContent,
+  parseYamlFile: () => parseYamlFile,
+  partition_by_readiness: () => partition_by_readiness,
+  queryItems: () => queryItems,
+  read_schema_version: () => read_schema_version,
+  renderAgentPrompt: () => renderAgentPrompt,
+  stringifyFrontmatter: () => stringifyFrontmatter,
+  topological_sort: () => topological_sort,
+  transition: () => transition,
+  transitive_dependencies: () => transitive_dependencies,
+  transitive_dependents: () => transitive_dependents,
+  updateItem: () => updateItem,
+  validate: () => validate,
+  validateReferential: () => validateReferential,
+  validateRepo: () => validateRepo,
+  validateSemantic: () => validateSemantic,
+  validateStructural: () => validateStructural,
+  validateTransition: () => validateTransition,
+  validate_graph: () => validate_graph,
+  validate_transition: () => validate_transition,
+  writeTask: () => writeTask,
+  write_schema_version: () => write_schema_version
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/graph/dag.ts
+function existingDeps(graph, nodeId) {
+  const deps = graph.forward.get(nodeId) ?? /* @__PURE__ */ new Set();
+  return Array.from(deps).filter((depId) => graph.nodes.has(depId));
+}
+function detect_cycle(graph) {
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [];
+  const dfs = (nodeId) => {
+    visiting.add(nodeId);
+    stack.push(nodeId);
+    for (const depId of existingDeps(graph, nodeId)) {
+      if (!visited.has(depId)) {
+        if (visiting.has(depId)) {
+          const start = stack.lastIndexOf(depId);
+          if (start >= 0) {
+            return [...stack.slice(start), depId];
+          }
+          return [depId, depId];
+        }
+        const cycle = dfs(depId);
+        if (cycle) return cycle;
+      } else if (visiting.has(depId)) {
+        const start = stack.lastIndexOf(depId);
+        if (start >= 0) {
+          return [...stack.slice(start), depId];
+        }
+      }
+    }
+    stack.pop();
+    visiting.delete(nodeId);
+    visited.add(nodeId);
+    return null;
+  };
+  const nodeIds = Array.from(graph.nodes.keys()).sort((a, b) => a.localeCompare(b));
+  for (const nodeId of nodeIds) {
+    if (visited.has(nodeId)) continue;
+    const cycle = dfs(nodeId);
+    if (cycle) return cycle;
+  }
+  return null;
+}
+function topological_sort(graph) {
+  const indegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const nodeId of graph.nodes.keys()) {
+    indegree.set(nodeId, 0);
+    dependents.set(nodeId, /* @__PURE__ */ new Set());
+  }
+  for (const [nodeId, deps] of graph.forward.entries()) {
+    for (const depId of deps) {
+      if (!graph.nodes.has(depId)) continue;
+      indegree.set(nodeId, (indegree.get(nodeId) ?? 0) + 1);
+      dependents.get(depId)?.add(nodeId);
+    }
+  }
+  const queue = Array.from(indegree.entries()).filter(([, degree]) => degree === 0).map(([nodeId]) => nodeId).sort((a, b) => a.localeCompare(b));
+  const result = [];
+  while (queue.length > 0) {
+    const nodeId = queue.shift();
+    if (!nodeId) continue;
+    result.push(nodeId);
+    const blocked = Array.from(dependents.get(nodeId) ?? []);
+    for (const dependentId of blocked) {
+      const next = (indegree.get(dependentId) ?? 0) - 1;
+      indegree.set(dependentId, next);
+      if (next === 0) {
+        queue.push(dependentId);
+      }
+    }
+    queue.sort((a, b) => a.localeCompare(b));
+  }
+  if (result.length !== graph.nodes.size) {
+    const cycle = detect_cycle(graph);
+    const cycleText = cycle ? cycle.join(" -> ") : "unknown cycle";
+    throw new Error(`Dependency cycle detected: ${cycleText}`);
+  }
+  return result;
+}
+function transitive_dependencies(graph, taskId) {
+  const result = /* @__PURE__ */ new Set();
+  const stack = [...graph.forward.get(taskId) ?? /* @__PURE__ */ new Set()].filter((depId) => graph.nodes.has(depId));
+  while (stack.length > 0) {
+    const depId = stack.pop();
+    if (!depId || result.has(depId)) continue;
+    result.add(depId);
+    for (const next of graph.forward.get(depId) ?? /* @__PURE__ */ new Set()) {
+      if (graph.nodes.has(next) && !result.has(next)) {
+        stack.push(next);
+      }
+    }
+  }
+  return result;
+}
+function transitive_dependents(graph, taskId) {
+  const result = /* @__PURE__ */ new Set();
+  const stack = [...graph.reverse.get(taskId) ?? /* @__PURE__ */ new Set()].filter((depId) => graph.nodes.has(depId));
+  while (stack.length > 0) {
+    const dependentId = stack.pop();
+    if (!dependentId || result.has(dependentId)) continue;
+    result.add(dependentId);
+    for (const next of graph.reverse.get(dependentId) ?? /* @__PURE__ */ new Set()) {
+      if (graph.nodes.has(next) && !result.has(next)) {
+        stack.push(next);
+      }
+    }
+  }
+  return result;
+}
+function build_graph(tasks, context = {}) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (nodes.has(task.id)) {
+      throw new Error(`Duplicate task id '${task.id}' while building graph.`);
+    }
+    nodes.set(task.id, task);
+  }
+  const forward = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  for (const nodeId of nodes.keys()) {
+    forward.set(nodeId, /* @__PURE__ */ new Set());
+    reverse.set(nodeId, /* @__PURE__ */ new Set());
+  }
+  for (const task of tasks) {
+    const deps = new Set(task.depends_on ?? []);
+    forward.set(task.id, deps);
+    for (const depId of deps) {
+      if (!nodes.has(depId)) continue;
+      reverse.get(depId)?.add(task.id);
+    }
+  }
+  const graph = {
+    nodes,
+    forward,
+    reverse,
+    topological_order: [],
+    tracks: context.tracks ? new Map(context.tracks) : /* @__PURE__ */ new Map(),
+    resources: context.resources ? new Map(context.resources) : /* @__PURE__ */ new Map(),
+    deliveries: context.deliveries ? new Map(context.deliveries) : /* @__PURE__ */ new Map()
+  };
+  graph.topological_order = topological_sort(graph);
+  return graph;
+}
+
+// src/graph/loader.ts
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+
+// src/parser/delivery-parser.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+
+// src/models/enums.ts
+var TaskType = {
+  feature: "feature",
+  bug: "bug",
+  chore: "chore",
+  spike: "spike",
+  epic: "epic"
+};
+var TaskStatus = {
+  todo: "todo",
+  blocked: "blocked",
+  in_progress: "in_progress",
+  in_review: "in_review",
+  done: "done",
+  canceled: "canceled"
+};
+var TaskPriority = {
+  p0: "p0",
+  p1: "p1",
+  p2: "p2",
+  p3: "p3"
+};
+var TaskComplexity = {
+  trivial: "trivial",
+  small: "small",
+  medium: "medium",
+  large: "large",
+  unknown: "unknown"
+};
+var TaskDeterminism = {
+  high: "high",
+  medium: "medium",
+  low: "low",
+  experimental: "experimental"
+};
+var IdeaStatus = {
+  captured: "captured",
+  exploring: "exploring",
+  promoted: "promoted",
+  parked: "parked",
+  rejected: "rejected"
+};
+var DeliveryStatus = {
+  planning: "planning",
+  committed: "committed",
+  in_progress: "in_progress",
+  delivered: "delivered",
+  canceled: "canceled"
+};
+var ExecutorType = {
+  human: "human",
+  ai: "ai",
+  ci: "ci",
+  hybrid: "hybrid"
+};
+var RunbookAction = {
+  generate: "generate",
+  run: "run",
+  review: "review",
+  test: "test",
+  deploy: "deploy"
+};
+var ArtifactType = {
+  pr: "pr",
+  migration: "migration",
+  deployment: "deployment",
+  document: "document",
+  config: "config"
+};
+var RiskLevel = {
+  low: "low",
+  medium: "medium",
+  high: "high",
+  critical: "critical"
+};
+
+// src/parser/frontmatter.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_yaml = __toESM(require("yaml"), 1);
+function normalizeInput(content) {
+  return content.startsWith("\uFEFF") ? content.slice(1) : content;
+}
+function splitFrontmatter(content, source) {
+  const normalized = normalizeInput(content);
+  const lines = normalized.split(/\r?\n/);
+  if (lines[0] !== "---") {
+    throw new Error(`${source}: missing frontmatter opening delimiter '---'.`);
+  }
+  let closingIndex = -1;
+  for (let i = 1; i < lines.length; i += 1) {
+    if (lines[i] === "---") {
+      closingIndex = i;
+      break;
+    }
+  }
+  if (closingIndex === -1) {
+    throw new Error(`${source}: missing frontmatter closing delimiter '---'.`);
+  }
+  const yamlBlock = lines.slice(1, closingIndex).join("\n");
+  const body = lines.slice(closingIndex + 1).join("\n");
+  return { yamlBlock, body };
+}
+function parseYamlObject(yamlBlock, source) {
+  let parsed;
+  try {
+    parsed = import_yaml.default.parse(yamlBlock);
+  } catch (error6) {
+    const message = error6 instanceof Error ? error6.message : String(error6);
+    throw new Error(`${source}: invalid YAML frontmatter: ${message}`);
+  }
+  if (parsed == null) {
+    return {};
+  }
+  if (typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${source}: frontmatter must parse to a YAML mapping object.`);
+  }
+  return parsed;
+}
+function parseFrontmatterContent(content, source = "<content>") {
+  const { yamlBlock, body } = splitFrontmatter(content, source);
+  const frontmatter = parseYamlObject(yamlBlock, source);
+  return { frontmatter, body };
+}
+function parseFrontmatterFile(filePath) {
+  const content = import_node_fs.default.readFileSync(filePath, "utf8");
+  return parseFrontmatterContent(content, filePath);
+}
+function stringifyFrontmatter(frontmatter, body = "") {
+  const yamlText = import_yaml.default.stringify(frontmatter).trimEnd();
+  if (body.length > 0) {
+    return `---
+${yamlText}
+---
+${body}`;
+  }
+  return `---
+${yamlText}
+---
+`;
+}
+
+// src/parser/yaml-parser.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_yaml2 = __toESM(require("yaml"), 1);
+function parseYamlContent(content, source = "<content>") {
+  let parsed;
+  try {
+    parsed = import_yaml2.default.parse(content);
+  } catch (error6) {
+    const message = error6 instanceof Error ? error6.message : String(error6);
+    throw new Error(`${source}: invalid YAML: ${message}`);
+  }
+  if (parsed == null) {
+    return {};
+  }
+  if (typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${source}: YAML content must parse to a mapping object.`);
+  }
+  return parsed;
+}
+function parseYamlFile(filePath) {
+  const content = import_node_fs2.default.readFileSync(filePath, "utf8");
+  return parseYamlContent(content, filePath);
+}
+
+// src/parser/delivery-parser.ts
+function asStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => String(entry));
+}
+function parseDeliveryFromRaw(raw, source) {
+  const id = raw.id;
+  const name = raw.name;
+  const status = raw.status;
+  if (typeof id !== "string" || !id.trim()) throw new Error(`${source}: missing or invalid required field 'id'.`);
+  if (typeof name !== "string" || !name.trim()) throw new Error(`${source}: missing or invalid required field 'name'.`);
+  if (typeof status !== "string" || !Object.values(DeliveryStatus).includes(status)) {
+    throw new Error(`${source}: invalid delivery status '${String(status)}'.`);
+  }
+  const scopeRaw = raw.scope;
+  const scopeRecord = typeof scopeRaw === "object" && scopeRaw !== null ? scopeRaw : {};
+  return {
+    id,
+    name,
+    status,
+    target_date: typeof raw.target_date === "string" ? raw.target_date : null,
+    started_date: typeof raw.started_date === "string" ? raw.started_date : null,
+    delivered_date: typeof raw.delivered_date === "string" ? raw.delivered_date : null,
+    budget: typeof raw.budget === "object" && raw.budget !== null ? raw.budget : {},
+    capacity_profiles: asStringArray(raw.capacity_profiles),
+    scope: {
+      include: asStringArray(scopeRecord.include),
+      exclude: asStringArray(scopeRecord.exclude)
+    },
+    risks: Array.isArray(raw.risks) ? raw.risks : void 0,
+    governance: typeof raw.governance === "object" && raw.governance !== null ? raw.governance : void 0
+  };
+}
+function parseDeliveryContentRaw(content, source) {
+  const trimmed = content.trimStart();
+  if (trimmed.startsWith("---")) {
+    return parseFrontmatterContent(content, source);
+  }
+  return {
+    frontmatter: parseYamlContent(content, source),
+    body: ""
+  };
+}
+function parseDeliveryContent(content, source = "<content>") {
+  const { frontmatter, body } = parseDeliveryContentRaw(content, source);
+  return {
+    delivery: parseDeliveryFromRaw(frontmatter, source),
+    body,
+    raw: frontmatter
+  };
+}
+function parseDeliveryFile(filePath) {
+  const content = import_node_fs3.default.readFileSync(filePath, "utf8");
+  return parseDeliveryContent(content, filePath);
+}
+
+// src/parser/task-parser.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var REQUIRED_LAYER_A_FIELDS = ["id", "title", "type", "status", "created", "updated"];
+function readStringField(raw, field, source) {
+  const value = raw[field];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${source}: missing or invalid required field '${field}'.`);
+  }
+  return value;
+}
+function validateLayerA(raw, source) {
+  for (const field of REQUIRED_LAYER_A_FIELDS) {
+    readStringField(raw, field, source);
+  }
+  const type = readStringField(raw, "type", source);
+  if (!Object.values(TaskType).includes(type)) {
+    throw new Error(`${source}: invalid task type '${type}'.`);
+  }
+  const status = readStringField(raw, "status", source);
+  if (!Object.values(TaskStatus).includes(status)) {
+    throw new Error(`${source}: invalid task status '${status}'.`);
+  }
+}
+function parseTaskContent(content, source = "<content>") {
+  const { frontmatter, body } = parseFrontmatterContent(content, source);
+  validateLayerA(frontmatter, source);
+  return {
+    task: frontmatter,
+    body,
+    raw: frontmatter
+  };
+}
+function parseTaskFile(filePath) {
+  const content = import_node_fs4.default.readFileSync(filePath, "utf8");
+  return parseTaskContent(content, filePath);
+}
+
+// src/graph/loader.ts
+function walkFiles(dirPath, extensions) {
+  if (!import_node_fs5.default.existsSync(dirPath)) return [];
+  const out = [];
+  const entries = import_node_fs5.default.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = import_node_path.default.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...walkFiles(fullPath, extensions));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const ext = import_node_path.default.extname(entry.name).toLowerCase();
+    if (extensions.has(ext)) {
+      out.push(fullPath);
+    }
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+function loadTasks(tasksDir) {
+  const files = walkFiles(tasksDir, /* @__PURE__ */ new Set([".md"]));
+  const tasks = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const filePath of files) {
+    const parsed = parseTaskFile(filePath);
+    if (seen.has(parsed.task.id)) {
+      throw new Error(`Duplicate task id '${parsed.task.id}' found at ${filePath}.`);
+    }
+    seen.add(parsed.task.id);
+    tasks.push(parsed.task);
+  }
+  return tasks;
+}
+function loadTracks(tracksDir) {
+  const files = walkFiles(tracksDir, /* @__PURE__ */ new Set([".yml", ".yaml"]));
+  const tracks = /* @__PURE__ */ new Map();
+  for (const filePath of files) {
+    const data = parseYamlFile(filePath);
+    if (!data.id) continue;
+    tracks.set(data.id, data);
+  }
+  return tracks;
+}
+function loadResources(resourcesDir) {
+  const files = walkFiles(resourcesDir, /* @__PURE__ */ new Set([".yml", ".yaml"]));
+  const resources = /* @__PURE__ */ new Map();
+  for (const filePath of files) {
+    const data = parseYamlFile(filePath);
+    if (!data.id) continue;
+    resources.set(data.id, data);
+  }
+  return resources;
+}
+function loadDeliveries(deliveriesDir) {
+  const files = walkFiles(deliveriesDir, /* @__PURE__ */ new Set([".yml", ".yaml", ".md"]));
+  const deliveries = /* @__PURE__ */ new Map();
+  for (const filePath of files) {
+    const parsed = parseDeliveryFile(filePath);
+    deliveries.set(parsed.delivery.id, parsed.delivery);
+  }
+  return deliveries;
+}
+function load_graph(coopDir) {
+  const tasks = loadTasks(import_node_path.default.join(coopDir, "tasks"));
+  const tracks = loadTracks(import_node_path.default.join(coopDir, "tracks"));
+  const resources = loadResources(import_node_path.default.join(coopDir, "resources"));
+  const deliveries = loadDeliveries(import_node_path.default.join(coopDir, "deliveries"));
+  return build_graph(tasks, {
+    tracks,
+    resources,
+    deliveries
+  });
+}
+
+// src/graph/subgraph.ts
+function extract_subgraph(graph, taskIds) {
+  const selected = new Set(taskIds.filter((taskId) => graph.nodes.has(taskId)));
+  const nodes = /* @__PURE__ */ new Map();
+  for (const taskId of selected) {
+    const task = graph.nodes.get(taskId);
+    if (task) nodes.set(taskId, task);
+  }
+  const forward = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  for (const taskId of selected) {
+    forward.set(taskId, /* @__PURE__ */ new Set());
+    reverse.set(taskId, /* @__PURE__ */ new Set());
+  }
+  for (const taskId of selected) {
+    const deps = graph.forward.get(taskId) ?? /* @__PURE__ */ new Set();
+    const internalDeps = new Set(Array.from(deps).filter((depId) => selected.has(depId)));
+    forward.set(taskId, internalDeps);
+    for (const depId of internalDeps) {
+      reverse.get(depId)?.add(taskId);
+    }
+  }
+  const subgraph = {
+    nodes,
+    forward,
+    reverse,
+    topological_order: [],
+    tracks: new Map(graph.tracks),
+    resources: new Map(graph.resources),
+    deliveries: new Map(graph.deliveries)
+  };
+  subgraph.topological_order = topological_sort(subgraph);
+  return subgraph;
+}
+function find_external_dependencies(subgraph, fullGraph) {
+  const external = /* @__PURE__ */ new Set();
+  for (const taskId of subgraph.nodes.keys()) {
+    const deps = fullGraph.forward.get(taskId) ?? /* @__PURE__ */ new Set();
+    for (const depId of deps) {
+      if (!subgraph.nodes.has(depId) && fullGraph.nodes.has(depId)) {
+        external.add(depId);
+      }
+    }
+  }
+  return Array.from(external).sort((a, b) => a.localeCompare(b));
+}
+
+// src/graph/validator.ts
+function error(invariant, message, task_ids) {
+  return {
+    level: "error",
+    invariant,
+    message,
+    task_ids
+  };
+}
+function buildUndirectedAdjacency(graph) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const nodeId of graph.nodes.keys()) {
+    adjacency.set(nodeId, /* @__PURE__ */ new Set());
+  }
+  for (const [nodeId, deps] of graph.forward.entries()) {
+    for (const depId of deps) {
+      if (!graph.nodes.has(depId)) continue;
+      adjacency.get(nodeId)?.add(depId);
+      adjacency.get(depId)?.add(nodeId);
+    }
+  }
+  return adjacency;
+}
+function connectedComponents(graph) {
+  const adjacency = buildUndirectedAdjacency(graph);
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  for (const nodeId of graph.nodes.keys()) {
+    if (visited.has(nodeId)) continue;
+    const component = [];
+    const stack = [nodeId];
+    visited.add(nodeId);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (!current) continue;
+      component.push(current);
+      for (const next of adjacency.get(current) ?? /* @__PURE__ */ new Set()) {
+        if (visited.has(next)) continue;
+        visited.add(next);
+        stack.push(next);
+      }
+    }
+    components.push(component);
+  }
+  return components;
+}
+function checkTerminalConvergence(graph) {
+  const issues = [];
+  const components = connectedComponents(graph);
+  for (const component of components) {
+    const hasLeaf = component.some((nodeId) => (graph.reverse.get(nodeId)?.size ?? 0) === 0);
+    if (!hasLeaf) {
+      issues.push(
+        error(
+          "terminal_convergence",
+          `Connected component lacks a leaf task (zero dependents): ${component.join(", ")}.`,
+          component
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validate_graph(graph) {
+  const issues = [];
+  const cycle = detect_cycle(graph);
+  if (cycle) {
+    issues.push(error("acyclicity", `Dependency cycle detected: ${cycle.join(" -> ")}.`, cycle));
+  }
+  for (const [taskId, deps] of graph.forward.entries()) {
+    for (const depId of deps) {
+      if (!graph.nodes.has(depId)) {
+        issues.push(
+          error(
+            "referential_integrity",
+            `Task '${taskId}' references missing dependency '${depId}'.`,
+            [taskId, depId]
+          )
+        );
+      }
+    }
+  }
+  issues.push(...checkTerminalConvergence(graph));
+  for (const [taskId, task] of graph.nodes.entries()) {
+    if (task.status !== "done") continue;
+    const deps = graph.forward.get(taskId) ?? /* @__PURE__ */ new Set();
+    const unresolved = Array.from(deps).filter((depId) => {
+      const depTask = graph.nodes.get(depId);
+      if (!depTask) return false;
+      return depTask.status !== "done";
+    });
+    if (unresolved.length > 0) {
+      issues.push(
+        error(
+          "status_consistency",
+          `Task '${taskId}' is done but has dependencies not done: ${unresolved.join(", ")}.`,
+          [taskId, ...unresolved]
+        )
+      );
+    }
+  }
+  return issues;
+}
+
+// src/parser/idea-parser.ts
+var import_node_fs6 = __toESM(require("fs"), 1);
+function asStringArray2(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => String(entry));
+}
+function parseIdeaFromRaw(raw, source) {
+  const id = raw.id;
+  const title = raw.title;
+  const created = raw.created;
+  const author = raw.author;
+  const status = raw.status;
+  const sourceField = raw.source;
+  if (typeof id !== "string" || !id.trim()) throw new Error(`${source}: missing or invalid required field 'id'.`);
+  if (typeof title !== "string" || !title.trim()) throw new Error(`${source}: missing or invalid required field 'title'.`);
+  if (typeof created !== "string" || !created.trim()) {
+    throw new Error(`${source}: missing or invalid required field 'created'.`);
+  }
+  if (typeof author !== "string" || !author.trim()) {
+    throw new Error(`${source}: missing or invalid required field 'author'.`);
+  }
+  if (typeof sourceField !== "string" || !sourceField.trim()) {
+    throw new Error(`${source}: missing or invalid required field 'source'.`);
+  }
+  if (typeof status !== "string" || !Object.values(IdeaStatus).includes(status)) {
+    throw new Error(`${source}: invalid idea status '${String(status)}'.`);
+  }
+  return {
+    id,
+    title,
+    created,
+    author,
+    status,
+    tags: asStringArray2(raw.tags),
+    source: sourceField,
+    linked_tasks: asStringArray2(raw.linked_tasks)
+  };
+}
+function parseIdeaContent(content, source = "<content>") {
+  const { frontmatter, body } = parseFrontmatterContent(content, source);
+  return {
+    idea: parseIdeaFromRaw(frontmatter, source),
+    body,
+    raw: frontmatter
+  };
+}
+function parseIdeaFile(filePath) {
+  const content = import_node_fs6.default.readFileSync(filePath, "utf8");
+  return parseIdeaContent(content, filePath);
+}
+
+// src/parser/task-writer.ts
+var import_node_fs7 = __toESM(require("fs"), 1);
+var TASK_FIELD_ORDER = [
+  "id",
+  "title",
+  "type",
+  "status",
+  "created",
+  "updated",
+  "priority",
+  "track",
+  "assignee",
+  "depends_on",
+  "tags",
+  "delivery",
+  "complexity",
+  "determinism",
+  "estimate",
+  "resources",
+  "execution",
+  "artifacts",
+  "governance",
+  "risk",
+  "metrics",
+  "enterprise"
+];
+var ORDERED_TASK_FIELDS = new Set(TASK_FIELD_ORDER);
+function buildOrderedFrontmatter(task, raw) {
+  const taskRecord = task;
+  const ordered = {};
+  for (const key of TASK_FIELD_ORDER) {
+    const fromTask = taskRecord[key];
+    if (fromTask !== void 0) {
+      ordered[key] = fromTask;
+      continue;
+    }
+    if (raw && Object.prototype.hasOwnProperty.call(raw, key)) {
+      const fromRaw = raw[key];
+      if (fromRaw !== void 0) {
+        ordered[key] = fromRaw;
+      }
+    }
+  }
+  if (!raw) {
+    return ordered;
+  }
+  for (const key of Object.keys(raw)) {
+    if (ORDERED_TASK_FIELDS.has(key)) {
+      continue;
+    }
+    ordered[key] = raw[key];
+  }
+  return ordered;
+}
+function writeTask(task, options = {}) {
+  const frontmatter = buildOrderedFrontmatter(task, options.raw);
+  const output = stringifyFrontmatter(frontmatter, options.body ?? "");
+  if (options.filePath) {
+    import_node_fs7.default.writeFileSync(options.filePath, output, "utf8");
+  }
+  return output;
+}
+
+// src/planning/readiness.ts
+function isResolvedDependencyStatus(status) {
+  return status === "done" || status === "canceled";
+}
+function compute_readiness(task, graph) {
+  if (task.status === "done" || task.status === "canceled") {
+    return "done";
+  }
+  if (task.status === "in_review") {
+    return "waiting_review";
+  }
+  if (task.status === "in_progress") {
+    return "in_progress";
+  }
+  for (const depId of task.depends_on ?? []) {
+    const dep = graph.nodes.get(depId);
+    if (!dep || !isResolvedDependencyStatus(dep.status)) {
+      return "blocked";
+    }
+  }
+  return "ready";
+}
+function compute_all_readiness(graph) {
+  const readiness = /* @__PURE__ */ new Map();
+  for (const [taskId, task] of graph.nodes.entries()) {
+    readiness.set(taskId, compute_readiness(task, graph));
+  }
+  return readiness;
+}
+function partition_by_readiness(graph) {
+  const partitions = {
+    ready: [],
+    blocked: [],
+    in_progress: [],
+    waiting_review: [],
+    done: []
+  };
+  for (const task of graph.nodes.values()) {
+    const state = compute_readiness(task, graph);
+    partitions[state].push(task);
+  }
+  return partitions;
+}
+function compute_readiness_with_corrections(graph) {
+  const readiness = /* @__PURE__ */ new Map();
+  const corrections = [];
+  const warnings = [];
+  const partitions = {
+    ready: [],
+    blocked: [],
+    in_progress: [],
+    waiting_review: [],
+    done: []
+  };
+  for (const [taskId, task] of graph.nodes.entries()) {
+    const state = compute_readiness(task, graph);
+    readiness.set(taskId, state);
+    partitions[state].push(task);
+    if (task.status === "blocked" && state === "ready") {
+      corrections.push({
+        type: "task.transitioned",
+        task_id: taskId,
+        from: "blocked",
+        to: "todo",
+        reason: "All dependencies are resolved."
+      });
+    }
+    if (task.status === "todo" && state === "blocked") {
+      const unresolved = (task.depends_on ?? []).filter((depId) => {
+        const depTask = graph.nodes.get(depId);
+        return !depTask || !isResolvedDependencyStatus(depTask.status);
+      });
+      warnings.push({
+        code: "todo_with_unresolved_dependencies",
+        task_id: taskId,
+        message: `Task is todo but has unresolved dependencies: ${unresolved.join(", ")}.`
+      });
+    }
+  }
+  return {
+    readiness,
+    partitions,
+    corrections,
+    warnings
+  };
+}
+
+// src/schema/version.ts
+var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var CURRENT_SCHEMA_VERSION = 2;
+function schemaVersionFile(coopDir) {
+  return import_node_path2.default.join(coopDir, "schema-version");
+}
+function read_schema_version(coopDir) {
+  const filePath = schemaVersionFile(coopDir);
+  if (!import_node_fs8.default.existsSync(filePath)) {
+    throw new Error(`Missing schema-version file at ${filePath}.`);
+  }
+  const raw = import_node_fs8.default.readFileSync(filePath, "utf8").trim();
+  if (!raw) {
+    throw new Error(`Schema version file is empty at ${filePath}.`);
+  }
+  const version = Number(raw);
+  if (!Number.isInteger(version) || version <= 0) {
+    throw new Error(`Invalid schema version '${raw}' in ${filePath}.`);
+  }
+  return version;
+}
+function write_schema_version(coopDir, version) {
+  if (!Number.isInteger(version) || version <= 0) {
+    throw new Error(`Schema version must be a positive integer. Received: ${String(version)}.`);
+  }
+  const filePath = schemaVersionFile(coopDir);
+  import_node_fs8.default.writeFileSync(filePath, `${version}
+`, "utf8");
+}
+
+// src/state/auto-transitions.ts
+function toStatusMap(value) {
+  if (!value) return /* @__PURE__ */ new Map();
+  if (value instanceof Map) return new Map(value);
+  return new Map(Object.entries(value));
+}
+function unresolvedDependencies(task, dependencyStatuses) {
+  const statuses = toStatusMap(dependencyStatuses);
+  return (task.depends_on ?? []).filter((depId) => {
+    const status = statuses.get(depId);
+    return status !== "done" && status !== "canceled";
+  });
+}
+function check_blocked(task, dependencyStatuses) {
+  if (task.status === "done" || task.status === "canceled" || task.status === "blocked") {
+    return { should_transition: false };
+  }
+  const unresolved = unresolvedDependencies(task, dependencyStatuses);
+  if (unresolved.length === 0) {
+    return { should_transition: false };
+  }
+  return {
+    should_transition: true,
+    target_status: "blocked",
+    event: {
+      type: "task.transitioned",
+      automated: true,
+      task_id: task.id,
+      from: task.status,
+      to: "blocked",
+      reason: `Unresolved dependencies detected: ${unresolved.join(", ")}.`
+    }
+  };
+}
+function check_unblocked(task, dependencyStatuses) {
+  if (task.status !== "blocked") {
+    return { should_transition: false };
+  }
+  const unresolved = unresolvedDependencies(task, dependencyStatuses);
+  if (unresolved.length > 0) {
+    return { should_transition: false };
+  }
+  return {
+    should_transition: true,
+    target_status: "todo",
+    event: {
+      type: "task.transitioned",
+      automated: true,
+      task_id: task.id,
+      from: "blocked",
+      to: "todo",
+      reason: "All dependencies are resolved."
+    }
+  };
+}
+
+// src/state/machine.ts
+var VALID_TASK_TRANSITIONS = /* @__PURE__ */ new Map([
+  ["todo", /* @__PURE__ */ new Set(["in_progress", "blocked", "canceled"])],
+  ["blocked", /* @__PURE__ */ new Set(["todo"])],
+  ["in_progress", /* @__PURE__ */ new Set(["in_review", "blocked", "todo", "canceled"])],
+  ["in_review", /* @__PURE__ */ new Set(["done", "todo"])],
+  ["done", /* @__PURE__ */ new Set()],
+  ["canceled", /* @__PURE__ */ new Set(["todo"])]
+]);
+function toStatusMap2(value) {
+  if (!value) return /* @__PURE__ */ new Map();
+  if (value instanceof Map) return new Map(value);
+  return new Map(Object.entries(value));
+}
+function toIsoDate(now) {
+  if (typeof now === "string") {
+    return now;
+  }
+  const date = now instanceof Date ? now : /* @__PURE__ */ new Date();
+  return date.toISOString().slice(0, 10);
+}
+function validateGovernanceAndDeps(task, targetStatus, context) {
+  if (task.status === "in_review" && targetStatus === "done" && task.governance?.approval_required) {
+    const reviewer = task.governance.reviewer;
+    if (!reviewer || context.actor !== reviewer) {
+      return "Approval-required transition in_review -> done must be performed by the configured reviewer.";
+    }
+  }
+  if (task.status === "blocked" && targetStatus === "todo") {
+    const depStatuses = toStatusMap2(context.dependencyStatuses);
+    const unresolved = (task.depends_on ?? []).filter((depId) => {
+      const status = depStatuses.get(depId);
+      return status !== "done" && status !== "canceled";
+    });
+    if (unresolved.length > 0) {
+      return `blocked -> todo requires all dependencies resolved. Pending: ${unresolved.join(", ")}.`;
+    }
+  }
+  return null;
+}
+function transition(task, targetStatus, context = {}) {
+  const allowed = VALID_TASK_TRANSITIONS.get(task.status) ?? /* @__PURE__ */ new Set();
+  if (!allowed.has(targetStatus)) {
+    return {
+      success: false,
+      task,
+      error: `Invalid transition ${task.status} -> ${targetStatus}. Allowed: ${Array.from(allowed).join(", ") || "none"}.`
+    };
+  }
+  const governanceError = validateGovernanceAndDeps(task, targetStatus, context);
+  if (governanceError) {
+    return {
+      success: false,
+      task,
+      error: governanceError
+    };
+  }
+  return {
+    success: true,
+    task: {
+      ...task,
+      status: targetStatus,
+      updated: toIsoDate(context.now)
+    }
+  };
+}
+
+// src/validator/referential.ts
+function error2(field, rule, message) {
+  return { level: "error", field, rule, message };
+}
+function warning(field, rule, message) {
+  return { level: "warning", field, rule, message };
+}
+function toDependencyMap(input) {
+  if (!input) {
+    return /* @__PURE__ */ new Map();
+  }
+  if (input instanceof Map) {
+    return new Map(input);
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(input)) {
+    map.set(key, Array.isArray(value) ? value : []);
+  }
+  return map;
+}
+function hasCycle(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Set();
+  const dfs = (node) => {
+    if (active.has(node)) return true;
+    if (visited.has(node)) return false;
+    visited.add(node);
+    active.add(node);
+    const deps = graph.get(node) ?? [];
+    for (const dep of deps) {
+      if (dfs(dep)) return true;
+    }
+    active.delete(node);
+    return false;
+  };
+  for (const node of graph.keys()) {
+    if (dfs(node)) return true;
+  }
+  return false;
+}
+function validateReferential(task, context = {}) {
+  const issues = [];
+  const existingIds = context.existingIds ?? /* @__PURE__ */ new Set();
+  const currentTaskId = context.currentTaskId ?? null;
+  if (task.id && existingIds.has(task.id) && (currentTaskId === null || currentTaskId !== task.id)) {
+    issues.push(error2("id", "ref.id_unique", `Task id '${task.id}' must be unique.`));
+  }
+  const dependsOn = task.depends_on ?? [];
+  for (const depId of dependsOn) {
+    if (!existingIds.has(depId)) {
+      issues.push(
+        error2(
+          "depends_on",
+          "ref.depends_on_exists",
+          `Dependency '${depId}' does not reference an existing task.`
+        )
+      );
+    }
+  }
+  const graph = toDependencyMap(context.dependencyMap);
+  if (task.id) {
+    graph.set(task.id, dependsOn);
+  }
+  if (graph.size > 0 && hasCycle(graph)) {
+    issues.push(error2("depends_on", "ref.no_cycles", "Dependency graph contains a cycle."));
+  }
+  if (task.track && task.track !== "unassigned" && context.tracks && !context.tracks.has(task.track)) {
+    issues.push(
+      warning("track", "ref.track_exists", `Track '${task.track}' does not match a known track (or 'unassigned').`)
+    );
+  }
+  if (task.delivery && context.deliveries && !context.deliveries.has(task.delivery)) {
+    issues.push(
+      warning("delivery", "ref.delivery_exists", `Delivery '${task.delivery}' does not match a known delivery.`)
+    );
+  }
+  if (task.assignee) {
+    const knownAssignee = context.assignees && context.assignees.has(task.assignee) || context.agents && context.agents.has(task.assignee);
+    if (!knownAssignee) {
+      issues.push(
+        warning(
+          "assignee",
+          "ref.assignee_known",
+          `Assignee '${task.assignee}' does not match a known member or agent.`
+        )
+      );
+    }
+  }
+  if (task.execution?.agent && context.agents && !context.agents.has(task.execution.agent)) {
+    issues.push(
+      warning(
+        "execution.agent",
+        "ref.execution_agent_known",
+        `Execution agent '${task.execution.agent}' does not match a known agent.`
+      )
+    );
+  }
+  return issues;
+}
+
+// src/validator/semantic.ts
+function error3(field, rule, message) {
+  return { level: "error", field, rule, message };
+}
+function warning2(field, rule, message) {
+  return { level: "warning", field, rule, message };
+}
+function asMap(value) {
+  if (!value) {
+    return /* @__PURE__ */ new Map();
+  }
+  if (value instanceof Map) {
+    return new Map(value);
+  }
+  return new Map(Object.entries(value));
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function validateSemantic(task, context = {}) {
+  const issues = [];
+  const estimate = task.estimate;
+  if (estimate) {
+    const hasOptimistic = isNumber(estimate.optimistic_hours);
+    const hasExpected = isNumber(estimate.expected_hours);
+    const hasPessimistic = isNumber(estimate.pessimistic_hours);
+    const count = Number(hasOptimistic) + Number(hasExpected) + Number(hasPessimistic);
+    if (count !== 3) {
+      issues.push(
+        error3(
+          "estimate",
+          "sem.estimate_all_three_or_none",
+          "Estimate must include optimistic_hours, expected_hours, and pessimistic_hours together."
+        )
+      );
+    } else if (estimate.optimistic_hours > estimate.expected_hours || estimate.expected_hours > estimate.pessimistic_hours) {
+      issues.push(
+        error3(
+          "estimate",
+          "sem.estimate_order",
+          "Estimate values must satisfy optimistic <= expected <= pessimistic."
+        )
+      );
+    }
+  }
+  if (task.resources) {
+    const numericFields = [
+      "human_hours",
+      "ai_tokens",
+      "compute_gpu_hours",
+      "cost_usd"
+    ];
+    for (const field of numericFields) {
+      const value = task.resources[field];
+      if (value !== void 0 && (!isNumber(value) || value < 0)) {
+        issues.push(
+          error3("resources", "sem.resources_non_negative", `Resource field '${field}' must be non-negative.`)
+        );
+      }
+    }
+  }
+  const taskStatuses = asMap(context.taskStatuses);
+  if (task.status === "done" && (task.depends_on?.length ?? 0) > 0) {
+    const unresolved = (task.depends_on ?? []).filter((depId) => taskStatuses.get(depId) !== "done");
+    if (unresolved.length > 0) {
+      issues.push(
+        warning2(
+          "status",
+          "sem.done_with_pending_dependencies",
+          `Task is done but has pending dependencies: ${unresolved.join(", ")}.`
+        )
+      );
+    }
+  }
+  if (task.status === "in_progress" && task.track) {
+    const trackWip = asMap(context.trackWip);
+    const stats = trackWip.get(task.track);
+    if (stats && stats.limit >= 0 && stats.inProgress > stats.limit) {
+      issues.push(
+        warning2(
+          "track",
+          "sem.track_wip_exceeded",
+          `Track '${task.track}' WIP limit exceeded (${stats.inProgress}/${stats.limit}).`
+        )
+      );
+    }
+  }
+  const deliveryByTaskId = asMap(context.deliveryByTaskId);
+  const scopedDelivery = deliveryByTaskId.get(task.id);
+  if (scopedDelivery && task.delivery !== scopedDelivery) {
+    issues.push(
+      warning2(
+        "delivery",
+        "sem.delivery_scope_mismatch",
+        `Task is scoped to delivery '${scopedDelivery}' but has delivery='${task.delivery ?? "null"}'.`
+      )
+    );
+  }
+  if (task.complexity === "unknown") {
+    const linkedSpikeTaskIds = context.linkedSpikeTaskIds ?? /* @__PURE__ */ new Set();
+    if (!linkedSpikeTaskIds.has(task.id)) {
+      issues.push(
+        warning2(
+          "complexity",
+          "sem.complexity_unknown_without_spike",
+          "Task has complexity=unknown without a linked spike task."
+        )
+      );
+    }
+  }
+  return issues;
+}
+
+// src/validator/structural.ts
+var import_node_path3 = __toESM(require("path"), 1);
+var ID_PATTERN = /^[A-Z]+-\d+$/;
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function error4(field, rule, message) {
+  return { level: "error", field, rule, message };
+}
+function isIsoDate(value) {
+  if (!ISO_DATE_RE.test(value)) {
+    return false;
+  }
+  const date = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  if (Number.isNaN(date.valueOf())) {
+    return false;
+  }
+  return date.toISOString().slice(0, 10) === value;
+}
+function validateStructural(task, context = {}) {
+  const errors = [];
+  const required = ["id", "title", "type", "status", "created", "updated"];
+  for (const field of required) {
+    const value = task[field];
+    if (typeof value !== "string" || value.trim().length === 0) {
+      errors.push(
+        error4(String(field), "struct.required_layer_a", `Field '${String(field)}' must be a non-empty string.`)
+      );
+    }
+  }
+  if (typeof task.id === "string" && task.id.trim().length > 0 && !ID_PATTERN.test(task.id)) {
+    errors.push(error4("id", "struct.id_pattern", `Task id '${task.id}' must match ${ID_PATTERN}.`));
+  }
+  if (typeof task.type === "string" && !Object.values(TaskType).includes(task.type)) {
+    errors.push(error4("type", "struct.type_enum", `Invalid task type '${task.type}'.`));
+  }
+  if (typeof task.status === "string" && !Object.values(TaskStatus).includes(task.status)) {
+    errors.push(error4("status", "struct.status_enum", `Invalid task status '${task.status}'.`));
+  }
+  if (typeof task.created === "string" && !isIsoDate(task.created)) {
+    errors.push(error4("created", "struct.created_iso_date", `Field 'created' must be an ISO date (YYYY-MM-DD).`));
+  }
+  if (typeof task.updated === "string" && !isIsoDate(task.updated)) {
+    errors.push(error4("updated", "struct.updated_iso_date", `Field 'updated' must be an ISO date (YYYY-MM-DD).`));
+  }
+  if (context.filePath) {
+    const expected = import_node_path3.default.basename(context.filePath, import_node_path3.default.extname(context.filePath));
+    if (typeof task.id === "string" && task.id !== expected) {
+      errors.push(
+        error4("id", "struct.id_matches_filename", `Task id '${task.id}' must match filename '${expected}'.`)
+      );
+    }
+  }
+  return errors;
+}
+
+// src/validator/transition.ts
+var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
+  ["todo", /* @__PURE__ */ new Set(["in_progress", "blocked", "canceled"])],
+  ["blocked", /* @__PURE__ */ new Set(["todo"])],
+  ["in_progress", /* @__PURE__ */ new Set(["in_review", "blocked", "todo", "canceled"])],
+  ["in_review", /* @__PURE__ */ new Set(["done", "todo"])],
+  ["done", /* @__PURE__ */ new Set()],
+  ["canceled", /* @__PURE__ */ new Set(["todo"])]
+]);
+function error5(field, rule, message) {
+  return { level: "error", field, rule, message };
+}
+function asMap2(value) {
+  if (!value) {
+    return /* @__PURE__ */ new Map();
+  }
+  if (value instanceof Map) {
+    return new Map(value);
+  }
+  return new Map(Object.entries(value));
+}
+function validate_transition(fromStatus, toStatus) {
+  const allowed = VALID_TRANSITIONS.get(fromStatus);
+  return Boolean(allowed?.has(toStatus));
+}
+function validateTransition(task, toStatus, context = {}) {
+  const issues = [];
+  const fromStatus = task.status;
+  if (!validate_transition(fromStatus, toStatus)) {
+    const allowed = Array.from(VALID_TRANSITIONS.get(fromStatus) ?? []);
+    issues.push(
+      error5(
+        "status",
+        "transition.valid_path",
+        `Invalid transition ${fromStatus} -> ${toStatus}. Allowed: ${allowed.join(", ") || "none"}.`
+      )
+    );
+    return issues;
+  }
+  if (fromStatus === "in_review" && toStatus === "done" && task.governance?.approval_required) {
+    const reviewer = task.governance.reviewer;
+    if (!reviewer || context.actor !== reviewer) {
+      issues.push(
+        error5(
+          "governance.reviewer",
+          "transition.approval_required_reviewer",
+          "Approval-required transition in_review -> done must be performed by the configured reviewer."
+        )
+      );
+    }
+  }
+  if (fromStatus === "blocked" && toStatus === "todo") {
+    const dependencyStatuses = asMap2(context.dependencyStatuses);
+    const unresolved = (task.depends_on ?? []).filter((depId) => dependencyStatuses.get(depId) !== "done");
+    if (unresolved.length > 0) {
+      issues.push(
+        error5(
+          "depends_on",
+          "transition.blocked_to_todo_dependencies_done",
+          `blocked -> todo requires all dependencies done. Pending: ${unresolved.join(", ")}.`
+        )
+      );
+    }
+  }
+  return issues;
+}
+
+// src/validator/index.ts
+function validate(task, context = {}) {
+  const issues = [
+    ...validateStructural(task, context),
+    ...validateReferential(task, context),
+    ...validateSemantic(task, context)
+  ];
+  const errors = issues.filter((issue) => issue.level === "error");
+  const warnings = issues.filter((issue) => issue.level === "warning");
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    issues
+  };
+}
+
+// src/core.ts
+var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+
+// src/types.ts
+var ITEM_TYPES = ["epic", "story", "task", "bug", "spike"];
+var ITEM_STATUSES = ["todo", "in_progress", "blocked", "done"];
+
+// src/core.ts
+var ITEM_ID_RE = /^[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)+(?:\.\d+)?$/;
+var ITEM_DIRS = {
+  epic: "epics",
+  story: "stories",
+  task: "tasks",
+  bug: "bugs",
+  spike: "spikes"
+};
+var COOP_DIR = ".coop";
+var DEFAULT_CONFIG = {
+  spec_version: 1,
+  id_prefix: "COOP",
+  id_strategy: "text"
+};
+function toIdKey(value) {
+  return value.trim().toUpperCase();
+}
+function repoRootByPackage(cwd) {
+  let current = import_node_path4.default.resolve(cwd);
+  let lastWorkspaceRoot = null;
+  while (true) {
+    const packageJson = import_node_path4.default.join(current, "package.json");
+    const workspaceYaml = import_node_path4.default.join(current, "pnpm-workspace.yaml");
+    if (import_node_fs9.default.existsSync(packageJson) && import_node_fs9.default.existsSync(workspaceYaml)) {
+      lastWorkspaceRoot = current;
+      const hasCoop = import_node_fs9.default.existsSync(import_node_path4.default.join(current, COOP_DIR, "config.yml"));
+      if (hasCoop) return current;
+    }
+    const parent = import_node_path4.default.dirname(current);
+    if (parent === current) return lastWorkspaceRoot;
+    current = parent;
+  }
+}
+function findRepoRoot(cwd = process.cwd()) {
+  return repoRootByPackage(cwd);
+}
+function configPathFor(rootDir, workspaceDir) {
+  return import_node_path4.default.join(rootDir, workspaceDir, "config.yml");
+}
+function backlogPathFor(rootDir, workspaceDir) {
+  return import_node_path4.default.join(rootDir, workspaceDir, "backlog");
+}
+function releasesPathFor(rootDir, workspaceDir) {
+  return import_node_path4.default.join(rootDir, workspaceDir, "releases");
+}
+function detectWorkspaceDir(rootDir) {
+  if (import_node_fs9.default.existsSync(configPathFor(rootDir, COOP_DIR))) return COOP_DIR;
+  if (import_node_fs9.default.existsSync(import_node_path4.default.join(rootDir, COOP_DIR))) return COOP_DIR;
+  return null;
+}
+function preferredWorkspaceDir(rootDir) {
+  return detectWorkspaceDir(rootDir) ?? COOP_DIR;
+}
+function missingConfigError(rootDir) {
+  const coopConfig = import_node_path4.default.relative(rootDir, configPathFor(rootDir, COOP_DIR));
+  return new Error(`COOP config missing at ${coopConfig}. Run: coop init`);
+}
+function parseConfig(raw) {
+  const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).filter((line) => !line.startsWith("#"));
+  const map = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const ix = line.indexOf(":");
+    if (ix <= 0) continue;
+    map.set(line.slice(0, ix).trim(), line.slice(ix + 1).trim());
+  }
+  const spec = Number(map.get("spec_version") ?? DEFAULT_CONFIG.spec_version);
+  const idPrefix = map.get("id_prefix") ?? DEFAULT_CONFIG.id_prefix;
+  const strategy = String(map.get("id_strategy") ?? DEFAULT_CONFIG.id_strategy ?? "text").trim().toLowerCase();
+  const rawNextId = map.get("next_id");
+  const nextId = rawNextId != null ? Number(rawNextId) : void 0;
+  if (!Number.isInteger(spec) || spec <= 0) throw new Error("config.yml must define a numeric spec_version.");
+  if (nextId != null && (!Number.isInteger(nextId) || nextId <= 0)) {
+    throw new Error("config.yml next_id must be a positive integer when present.");
+  }
+  if (!/^[A-Za-z][A-Za-z0-9-]*$/.test(idPrefix)) {
+    throw new Error("config.yml must define id_prefix using letters, numbers, or '-'.");
+  }
+  if (strategy !== "text" && strategy !== "counter") {
+    throw new Error("config.yml id_strategy must be either 'text' or 'counter'.");
+  }
+  return {
+    spec_version: spec,
+    id_prefix: idPrefix,
+    id_strategy: strategy,
+    ...nextId != null ? { next_id: nextId } : {}
+  };
+}
+function configToString(config) {
+  const lines = [
+    `spec_version: ${config.spec_version}`,
+    `id_prefix: ${config.id_prefix}`,
+    `id_strategy: ${config.id_strategy ?? "text"}`
+  ];
+  if (config.next_id != null) {
+    lines.push(`next_id: ${config.next_id}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function toPortablePath(value) {
+  return value.split(import_node_path4.default.sep).join("/");
+}
+function ensureReleasesDir(rootDir, workspaceDir) {
+  import_node_fs9.default.mkdirSync(releasesPathFor(rootDir, workspaceDir), { recursive: true });
+}
+function releaseHeader(date) {
+  return `## ${date}`;
+}
+function releaseEntryLine(item, previousStatus, nextStatus) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return [
+    `- [${nextStatus.toUpperCase()}] ${item.id} (${item.type})`,
+    `  - Title: ${item.title}`,
+    `  - Status: ${previousStatus} -> ${nextStatus}`,
+    `  - File: ${toPortablePath(item.filePath)}`,
+    `  - Updated: ${timestamp}`
+  ].join("\n");
+}
+function hasReleaseEntry(content, id) {
+  return new RegExp(`^\\- \\[[A-Z_]+\\]\\s+${id}\\b`, "m").test(content);
+}
+function appendReleaseEntry(rootDir, workspaceDir, item, previousStatus, nextStatus) {
+  ensureReleasesDir(rootDir, workspaceDir);
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10);
+  const releasePath = import_node_path4.default.join(releasesPathFor(rootDir, workspaceDir), `${date}.md`);
+  const heading = "# COOP Release Notes";
+  const dayHeader = releaseHeader(date);
+  const entry = releaseEntryLine(item, previousStatus, nextStatus);
+  if (!import_node_fs9.default.existsSync(releasePath)) {
+    import_node_fs9.default.writeFileSync(
+      releasePath,
+      [
+        `${heading}
+`,
+        `${dayHeader}
+`,
+        `${entry}
+`,
+        ""
+      ].join("\n"),
+      "utf8"
+    );
+    return toPortablePath(import_node_path4.default.relative(rootDir, releasePath));
+  }
+  const existing = import_node_fs9.default.readFileSync(releasePath, "utf8");
+  if (hasReleaseEntry(existing, item.id)) return toPortablePath(import_node_path4.default.relative(rootDir, releasePath));
+  let nextContent = existing;
+  if (!existing.includes(`## ${date}`)) {
+    if (!nextContent.endsWith("\n")) nextContent += "\n";
+    nextContent += `${dayHeader}
+`;
+  }
+  if (!nextContent.endsWith("\n")) nextContent += "\n";
+  nextContent += `${entry}
+`;
+  import_node_fs9.default.writeFileSync(releasePath, `${nextContent}
+`, "utf8");
+  return toPortablePath(import_node_path4.default.relative(rootDir, releasePath));
+}
+function completeItem(rootDir, id) {
+  const state = loadState(rootDir);
+  const existing = getItemById(state, id);
+  if (!existing) throw new Error(`Item ${id} not found.`);
+  if (existing.status === "done") {
+    return {
+      item: existing,
+      previousStatus: existing.status,
+      alreadyComplete: true
+    };
+  }
+  const updated = updateItem(rootDir, id, { status: "done" });
+  const releaseFile = appendReleaseEntry(rootDir, state.workspaceDir, updated, existing.status, updated.status);
+  return {
+    item: updated,
+    previousStatus: existing.status,
+    releaseFile,
+    alreadyComplete: false
+  };
+}
+function normalizePriority(value) {
+  if (typeof value !== "string") return "p2";
+  const trimmed = value.trim().toLowerCase();
+  return trimmed.length ? trimmed : "p2";
+}
+function normalizeLabels(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.map((entry) => String(entry).trim()).filter(Boolean);
+  if (typeof value === "string") return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return [];
+}
+function normalizeArray(value) {
+  return normalizeLabels(value);
+}
+function normalizeAgent(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const source = value;
+  const out = {};
+  if (typeof source.goal === "string" && source.goal.trim()) out.goal = source.goal.trim();
+  if (Array.isArray(source.context_paths)) out.context_paths = source.context_paths;
+  if (source.commands && typeof source.commands === "object") out.commands = source.commands;
+  if (Array.isArray(source.constraints)) out.constraints = source.constraints;
+  if (Array.isArray(source.risks)) out.risks = source.risks;
+  if (Array.isArray(source.prompt_hints)) out.prompt_hints = source.prompt_hints;
+  return Object.keys(out).length ? out : void 0;
+}
+function validateAndNormalize(data, sourceFile) {
+  const id = String(data.id ?? "").trim();
+  const type = String(data.type ?? "").trim();
+  const title = String(data.title ?? "").trim();
+  const status = String(data.status ?? "todo").trim().toLowerCase();
+  const created = String(data.created ?? "").trim() || (/* @__PURE__ */ new Date()).toISOString();
+  const updated = String(data.updated ?? "").trim() || (/* @__PURE__ */ new Date()).toISOString();
+  if (!ITEM_ID_RE.test(id)) throw new Error(`Invalid or missing id in ${sourceFile}`);
+  if (!ITEM_TYPES.includes(type)) throw new Error(`Invalid item type in ${sourceFile}: ${String(data.type)}`);
+  if (!title) throw new Error(`Missing item title in ${sourceFile}`);
+  if (!ITEM_STATUSES.includes(status)) throw new Error(`Invalid status in ${sourceFile}: ${String(data.status)}`);
+  return {
+    id,
+    type,
+    title,
+    status,
+    created,
+    updated,
+    priority: normalizePriority(data.priority),
+    points: typeof data.points === "number" ? data.points : void 0,
+    owner: typeof data.owner === "string" ? data.owner.trim() || void 0 : void 0,
+    labels: normalizeLabels(data.labels),
+    links: data.links ? data.links : void 0,
+    depends_on: normalizeArray(data.depends_on),
+    acceptance: normalizeArray(data.acceptance),
+    agent: normalizeAgent(data.agent),
+    parent_id: typeof data.parent_id === "string" ? data.parent_id.trim() || void 0 : void 0
+  };
+}
+function parseItem(filePath, rootDir) {
+  const raw = import_node_fs9.default.readFileSync(filePath, "utf8");
+  const parsed = (0, import_gray_matter.default)(raw);
+  const data = validateAndNormalize(parsed.data, import_node_path4.default.relative(rootDir, filePath));
+  return {
+    ...data,
+    body: parsed.content || "",
+    filePath: import_node_path4.default.relative(rootDir, filePath)
+  };
+}
+function walk(dir) {
+  const out = [];
+  if (!import_node_fs9.default.existsSync(dir)) return out;
+  const entries = import_node_fs9.default.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const file = import_node_path4.default.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walk(file));
+    if (entry.isFile() && file.endsWith(".md")) out.push(file);
+  }
+  return out;
+}
+function itemPath(type, id, rootDir, workspaceDir) {
+  return import_node_path4.default.join(backlogPathFor(rootDir, workspaceDir), ITEM_DIRS[type], `${id}.md`);
+}
+function normalizeFrontmatterValue(value) {
+  if (value == null) return void 0;
+  if (Array.isArray(value)) {
+    const normalized = value.map((entry) => typeof entry === "string" ? entry.trim() : entry).filter((entry) => entry != null && entry !== "");
+    return normalized.length ? normalized : void 0;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : void 0;
+  }
+  if (typeof value === "object") {
+    const object = value;
+    const out = {};
+    for (const [key, entry] of Object.entries(object)) {
+      const normalized = normalizeFrontmatterValue(entry);
+      if (normalized !== void 0) {
+        out[key] = normalized;
+      }
+    }
+    return Object.keys(out).length ? out : void 0;
+  }
+  return value;
+}
+function serialize(item, body = "") {
+  const source = {
+    id: item.id,
+    type: item.type,
+    title: item.title,
+    status: item.status,
+    created: item.created,
+    updated: item.updated,
+    priority: item.priority,
+    points: item.points,
+    owner: item.owner,
+    labels: item.labels,
+    links: item.links,
+    depends_on: item.depends_on,
+    acceptance: item.acceptance,
+    agent: item.agent,
+    parent_id: item.parent_id
+  };
+  const frontmatter = {};
+  for (const [key, value] of Object.entries(source)) {
+    const normalized = normalizeFrontmatterValue(value);
+    if (normalized !== void 0) {
+      frontmatter[key] = normalized;
+    }
+  }
+  return import_gray_matter.default.stringify(body || "", frontmatter);
+}
+function sortPriorityValue(priority) {
+  const value = (priority || "p2").toLowerCase();
+  if (value === "p0") return 0;
+  if (value === "p1") return 1;
+  if (value === "p2") return 2;
+  if (value === "p3") return 3;
+  if (value === "p4") return 4;
+  return 99;
+}
+function slugForId(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+}
+function shortIdToken() {
+  const stamp = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 8);
+  return `${stamp}${rand}`.slice(-8);
+}
+function nextGeneratedId(config, title, existing) {
+  const strategy = config.id_strategy ?? "text";
+  const prefix = slugForId(config.id_prefix) || "coop";
+  if (strategy === "counter") {
+    const next = config.next_id ?? 1;
+    return `${prefix}-${String(next).padStart(3, "0")}`;
+  }
+  const titleSlug = slugForId(title) || "item";
+  const base = `${prefix}-${titleSlug}`;
+  if (!existing.has(toIdKey(base))) return base;
+  for (let i = 0; i < 64; i += 1) {
+    const candidate = `${base}-${shortIdToken()}`;
+    if (!existing.has(toIdKey(candidate))) return candidate;
+  }
+  throw new Error(`Unable to generate unique id for title "${title}". Provide --id explicitly.`);
+}
+function ensureCoopLayout(rootDir) {
+  const workspaceDir = preferredWorkspaceDir(rootDir);
+  const root = import_node_path4.default.join(rootDir, workspaceDir);
+  import_node_fs9.default.mkdirSync(root, { recursive: true });
+  import_node_fs9.default.mkdirSync(import_node_path4.default.join(root, "releases"), { recursive: true });
+  import_node_fs9.default.mkdirSync(import_node_path4.default.join(root, "plans"), { recursive: true });
+  import_node_fs9.default.mkdirSync(import_node_path4.default.join(root, "views"), { recursive: true });
+  import_node_fs9.default.mkdirSync(import_node_path4.default.join(root, "templates"), { recursive: true });
+  for (const dir of Object.values(ITEM_DIRS)) {
+    import_node_fs9.default.mkdirSync(import_node_path4.default.join(root, "backlog", dir), { recursive: true });
+  }
+  const configFile = import_node_path4.default.join(root, "config.yml");
+  if (!import_node_fs9.default.existsSync(configFile)) {
+    import_node_fs9.default.writeFileSync(configFile, configToString(DEFAULT_CONFIG), "utf8");
+  }
+}
+function loadState(rootDir) {
+  const workspaceDir = detectWorkspaceDir(rootDir);
+  if (!workspaceDir) throw missingConfigError(rootDir);
+  const configPath = configPathFor(rootDir, workspaceDir);
+  if (!import_node_fs9.default.existsSync(configPath)) throw missingConfigError(rootDir);
+  const config = parseConfig(import_node_fs9.default.readFileSync(configPath, "utf8"));
+  const items = [];
+  const itemsById = /* @__PURE__ */ new Map();
+  for (const type of ITEM_TYPES) {
+    const dir = import_node_path4.default.join(backlogPathFor(rootDir, workspaceDir), ITEM_DIRS[type]);
+    const files = walk(dir);
+    for (const file of files) {
+      const item = parseItem(file, rootDir);
+      const key = toIdKey(item.id);
+      if (itemsById.has(key)) {
+        throw new Error(`Duplicate item id ${item.id} found while reading ${file}.`);
+      }
+      items.push(item);
+      itemsById.set(key, item);
+    }
+  }
+  return { rootDir, workspaceDir, config, items, itemsById };
+}
+function queryItems(state, filter) {
+  const status = filter.status?.toLowerCase();
+  const owner = filter.owner?.toLowerCase();
+  const label = filter.label?.toLowerCase();
+  const typeFilter = filter.type;
+  const search = filter.search?.toLowerCase();
+  return state.items.filter((item) => {
+    if (status && item.status !== status) return false;
+    if (owner && (item.owner || "").toLowerCase() !== owner) return false;
+    if (label && !(item.labels ?? []).map((entry) => entry.toLowerCase()).includes(label)) return false;
+    if (typeFilter) {
+      const set = new Set(
+        Array.isArray(typeFilter) ? typeFilter : String(typeFilter).split(",").map((entry) => entry.trim().toLowerCase())
+      );
+      const want = item.type.toLowerCase();
+      if (!set.has(want)) return false;
+    }
+    if (search) {
+      const haystack = `${item.id} ${item.title} ${item.body} ${item.labels?.join(" ")} ${item.owner || ""}`.toLowerCase();
+      if (!haystack.includes(search)) return false;
+    }
+    return true;
+  }).sort((a, b) => {
+    const p = sortPriorityValue(a.priority) - sortPriorityValue(b.priority);
+    if (p !== 0) return p;
+    if (a.type !== b.type) return a.type.localeCompare(b.type);
+    return a.id.localeCompare(b.id);
+  });
+}
+function getItemById(state, id) {
+  return state.itemsById.get(toIdKey(id)) ?? null;
+}
+function createItem(rootDir, params) {
+  const state = loadState(rootDir);
+  const { config } = state;
+  if (!ITEM_TYPES.includes(params.type)) {
+    throw new Error(`Unknown type ${params.type}.`);
+  }
+  if (!params.title?.trim()) {
+    throw new Error("Item title is required.");
+  }
+  const status = params.status || "todo";
+  if (!ITEM_STATUSES.includes(status)) {
+    throw new Error(`Unknown status ${status}.`);
+  }
+  const nextId = params.id ? params.id.trim() : nextGeneratedId(config, params.title, state.itemsById);
+  if (!ITEM_ID_RE.test(nextId)) {
+    throw new Error(`Invalid id ${nextId}.`);
+  }
+  if (state.itemsById.has(toIdKey(nextId))) {
+    throw new Error(`Item ${nextId} already exists.`);
+  }
+  const item = {
+    id: nextId,
+    type: params.type,
+    title: params.title,
+    status,
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    updated: (/* @__PURE__ */ new Date()).toISOString(),
+    priority: normalizePriority(params.priority || "p2"),
+    points: params.points,
+    owner: params.owner,
+    labels: params.labels ?? [],
+    links: params.links,
+    depends_on: params.depends_on ?? [],
+    acceptance: params.acceptance ?? [],
+    agent: params.agent,
+    parent_id: params.parent_id
+  };
+  const itemPathName = itemPath(params.type, item.id, rootDir, state.workspaceDir);
+  import_node_fs9.default.writeFileSync(itemPathName, serialize(item, params.body || ""), "utf8");
+  if ((config.id_strategy ?? "text") === "counter") {
+    const numericMatch = /-(\d+)$/.exec(item.id);
+    if (numericMatch) {
+      const numericValue = Number(numericMatch[1]);
+      if (Number.isInteger(numericValue) && numericValue >= (config.next_id ?? 1)) {
+        config.next_id = numericValue + 1;
+        import_node_fs9.default.writeFileSync(configPathFor(rootDir, state.workspaceDir), configToString(config), "utf8");
+      }
+    }
+  }
+  return {
+    ...item,
+    body: params.body || "",
+    filePath: import_node_path4.default.relative(rootDir, itemPathName)
+  };
+}
+function updateItem(rootDir, id, patch) {
+  const state = loadState(rootDir);
+  const existing = getItemById(state, id);
+  if (!existing) throw new Error(`Item ${id} not found.`);
+  const next = {
+    ...existing,
+    title: patch.title || existing.title,
+    status: patch.status || existing.status,
+    type: patch.type || existing.type,
+    priority: normalizePriority(patch.priority || existing.priority),
+    points: patch.points !== void 0 ? patch.points : existing.points,
+    owner: patch.owner !== void 0 ? patch.owner : existing.owner,
+    labels: patch.labels ?? existing.labels,
+    links: patch.links ?? existing.links,
+    depends_on: patch.depends_on ?? existing.depends_on,
+    acceptance: patch.acceptance ?? existing.acceptance,
+    agent: patch.agent ? patch.agent : existing.agent,
+    created: existing.created,
+    updated: (/* @__PURE__ */ new Date()).toISOString(),
+    parent_id: existing.parent_id
+  };
+  if (!ITEM_TYPES.includes(next.type)) throw new Error(`Unknown type ${next.type}.`);
+  if (!ITEM_STATUSES.includes(next.status)) throw new Error(`Unknown status ${next.status}.`);
+  const filePath = import_node_path4.default.join(rootDir, existing.filePath);
+  import_node_fs9.default.writeFileSync(filePath, serialize(next, patch.body || existing.body), "utf8");
+  return {
+    ...next,
+    body: patch.body || existing.body,
+    filePath: existing.filePath
+  };
+}
+function deleteItem(rootDir, id) {
+  const state = loadState(rootDir);
+  const existing = getItemById(state, id);
+  if (!existing) throw new Error(`Item ${id} not found.`);
+  const existingKey = toIdKey(existing.id);
+  const children = state.items.filter((item) => item.parent_id && toIdKey(item.parent_id) === existingKey);
+  if (children.length > 0) {
+    throw new Error(`Cannot delete ${existing.id} because it has ${children.length} child item(s). Remove children first.`);
+  }
+  import_node_fs9.default.unlinkSync(import_node_path4.default.join(rootDir, existing.filePath));
+  return existing;
+}
+function renderAgentPrompt(item) {
+  const lines = [
+    `Task ${item.id}: ${item.title}`,
+    `Type: ${item.type}`,
+    `Priority: ${item.priority || "p2"}`,
+    `Status: ${item.status}`,
+    "",
+    "Acceptance:",
+    ...(item.acceptance?.length ? item.acceptance : ["No explicit acceptance criteria"]).map((entry) => `- ${entry}`),
+    "",
+    "Agent context:",
+    ...(() => {
+      const agent = item.agent;
+      if (!agent) return ["- No agent data present."];
+      const context = [
+        `- Goal: ${agent.goal || "Not set"}`,
+        `- Context paths: ${(agent.context_paths || []).join(", ") || "None"}`,
+        `- Constraints: ${(agent.constraints || []).join(", ") || "None"}`,
+        `- Risks: ${(agent.risks || []).join(", ") || "None"}`
+      ];
+      if (agent.commands) {
+        context.push("- Commands:");
+        for (const [name, command] of Object.entries(agent.commands)) {
+          if (!command) continue;
+          context.push(`  - ${name}: ${command}`);
+        }
+      }
+      return context;
+    })()
+  ];
+  return lines.join("\n");
+}
+function validateRepo(rootDir) {
+  const errors = [];
+  const warnings = [];
+  const workspaceDir = detectWorkspaceDir(rootDir);
+  if (!workspaceDir || !import_node_fs9.default.existsSync(configPathFor(rootDir, workspaceDir))) {
+    errors.push("Missing .coop/config.yml. Run coop init first.");
+    return { valid: false, errors, warnings };
+  }
+  let state;
+  try {
+    state = loadState(rootDir);
+  } catch (error6) {
+    errors.push(`Cannot read backlog: ${error6 instanceof Error ? error6.message : String(error6)}`);
+    return { valid: false, errors, warnings };
+  }
+  for (const item of state.items) {
+    if (!ITEM_ID_RE.test(item.id)) errors.push(`Invalid id ${item.id}`);
+    if (!ITEM_TYPES.includes(item.type)) errors.push(`Invalid type ${item.type} in ${item.id}`);
+    if (!ITEM_STATUSES.includes(item.status)) errors.push(`Invalid status ${item.status} in ${item.id}`);
+    if (!item.title.trim()) errors.push(`Missing title in ${item.id}`);
+    for (const dep of item.depends_on ?? []) {
+      if (!state.itemsById.has(toIdKey(dep))) {
+        errors.push(`Item ${item.id} depends_on missing target ${dep}`);
+      }
+    }
+    if (item.parent_id && !state.itemsById.has(toIdKey(item.parent_id))) {
+      warnings.push(`Item ${item.id} has unresolved parent_id ${item.parent_id}`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArtifactType,
+  CURRENT_SCHEMA_VERSION,
+  DeliveryStatus,
+  ExecutorType,
+  ITEM_STATUSES,
+  ITEM_TYPES,
+  IdeaStatus,
+  RiskLevel,
+  RunbookAction,
+  TaskComplexity,
+  TaskDeterminism,
+  TaskPriority,
+  TaskStatus,
+  TaskType,
+  VALID_TASK_TRANSITIONS,
+  VALID_TRANSITIONS,
+  build_graph,
+  check_blocked,
+  check_unblocked,
+  completeItem,
+  compute_all_readiness,
+  compute_readiness,
+  compute_readiness_with_corrections,
+  createItem,
+  deleteItem,
+  detect_cycle,
+  ensureCoopLayout,
+  extract_subgraph,
+  findRepoRoot,
+  find_external_dependencies,
+  getItemById,
+  loadState,
+  load_graph,
+  parseDeliveryContent,
+  parseDeliveryFile,
+  parseFrontmatterContent,
+  parseFrontmatterFile,
+  parseIdeaContent,
+  parseIdeaFile,
+  parseTaskContent,
+  parseTaskFile,
+  parseYamlContent,
+  parseYamlFile,
+  partition_by_readiness,
+  queryItems,
+  read_schema_version,
+  renderAgentPrompt,
+  stringifyFrontmatter,
+  topological_sort,
+  transition,
+  transitive_dependencies,
+  transitive_dependents,
+  updateItem,
+  validate,
+  validateReferential,
+  validateRepo,
+  validateSemantic,
+  validateStructural,
+  validateTransition,
+  validate_graph,
+  validate_transition,
+  writeTask,
+  write_schema_version
+});