@kitsy/coop-core 0.0.1 → 2.0.0

package/dist/index.cjs

@@ -31,13 +31,20 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ArtifactType: () => ArtifactType,
+  COOP_EVENT_TYPES: () => COOP_EVENT_TYPES,
   CURRENT_SCHEMA_VERSION: () => CURRENT_SCHEMA_VERSION,
+  CoopEventEmitter: () => CoopEventEmitter,
+  DEFAULT_SCORE_WEIGHTS: () => DEFAULT_SCORE_WEIGHTS,
   DeliveryStatus: () => DeliveryStatus,
   ExecutorType: () => ExecutorType,
   ITEM_STATUSES: () => ITEM_STATUSES,
   ITEM_TYPES: () => ITEM_TYPES,
   IdeaStatus: () => IdeaStatus,
+  IndexManager: () => IndexManager,
+  MIGRATIONS: () => MIGRATIONS,
   RiskLevel: () => RiskLevel,
+  RunStatus: () => RunStatus,
+  RunStepStatus: () => RunStepStatus,
   RunbookAction: () => RunbookAction,
   TaskComplexity: () => TaskComplexity,
   TaskDeterminism: () => TaskDeterminism,
@@ -46,23 +53,63 @@ __export(index_exports, {
   TaskType: () => TaskType,
   VALID_TASK_TRANSITIONS: () => VALID_TASK_TRANSITIONS,
   VALID_TRANSITIONS: () => VALID_TRANSITIONS,
+  allocate: () => allocate,
+  allocate_ai: () => allocate_ai,
+  allocate_ai_tokens: () => allocate_ai_tokens,
+  analyze_feasibility: () => analyze_feasibility,
+  analyze_what_if: () => analyze_what_if,
+  build_capacity_ledger: () => build_capacity_ledger,
   build_graph: () => build_graph,
   check_blocked: () => check_blocked,
+  check_permission: () => check_permission,
   check_unblocked: () => check_unblocked,
+  check_wip: () => check_wip,
   completeItem: () => completeItem,
+  complexity_penalty: () => complexity_penalty,
   compute_all_readiness: () => compute_all_readiness,
+  compute_critical_path: () => compute_critical_path,
   compute_readiness: () => compute_readiness,
   compute_readiness_with_corrections: () => compute_readiness_with_corrections,
+  compute_score: () => compute_score,
+  compute_velocity: () => compute_velocity,
+  coop_project_config_path: () => coop_project_config_path,
+  coop_project_root: () => coop_project_root,
+  coop_projects_dir: () => coop_projects_dir,
+  coop_workspace_config_path: () => coop_workspace_config_path,
+  coop_workspace_dir: () => coop_workspace_dir,
   createItem: () => createItem,
+  create_seeded_rng: () => create_seeded_rng,
+  critical_path_weight: () => critical_path_weight,
   deleteItem: () => deleteItem,
+  dependency_unlock_weight: () => dependency_unlock_weight,
   detect_cycle: () => detect_cycle,
+  detect_delivery_risks: () => detect_delivery_risks,
+  determinism_weight: () => determinism_weight,
+  effective_weekly_hours: () => effective_weekly_hours,
+  effort_or_default: () => effort_or_default,
   ensureCoopLayout: () => ensureCoopLayout,
+  ensure_workspace_layout: () => ensure_workspace_layout,
+  executor_fit_weight: () => executor_fit_weight,
+  external_dependencies_for_task: () => external_dependencies_for_task,
   extract_subgraph: () => extract_subgraph,
   findRepoRoot: () => findRepoRoot,
   find_external_dependencies: () => find_external_dependencies,
   getItemById: () => getItemById,
+  get_remaining_tokens: () => get_remaining_tokens,
+  get_user_role: () => get_user_role,
+  has_legacy_project_layout: () => has_legacy_project_layout,
+  has_v2_projects_layout: () => has_v2_projects_layout,
+  is_external_dependency: () => is_external_dependency,
+  is_project_initialized: () => is_project_initialized,
+  list_projects: () => list_projects,
   loadState: () => loadState,
+  load_auth_config: () => load_auth_config,
+  load_completed_runs: () => load_completed_runs,
   load_graph: () => load_graph,
+  load_plugins: () => load_plugins,
+  migrate_repository: () => migrate_repository,
+  migrate_task: () => migrate_task,
+  monte_carlo_forecast: () => monte_carlo_forecast,
   parseDeliveryContent: () => parseDeliveryContent,
   parseDeliveryFile: () => parseDeliveryFile,
   parseFrontmatterContent: () => parseFrontmatterContent,
@@ -73,16 +120,38 @@ __export(index_exports, {
   parseTaskFile: () => parseTaskFile,
   parseYamlContent: () => parseYamlContent,
   parseYamlFile: () => parseYamlFile,
+  parse_external_dependency: () => parse_external_dependency,
   partition_by_readiness: () => partition_by_readiness,
+  pert_hours: () => pert_hours,
+  pert_stddev: () => pert_stddev,
+  priority_weight: () => priority_weight,
   queryItems: () => queryItems,
+  read_project_config: () => read_project_config,
   read_schema_version: () => read_schema_version,
+  read_workspace_config: () => read_workspace_config,
   renderAgentPrompt: () => renderAgentPrompt,
+  repo_default_project_id: () => repo_default_project_id,
+  repo_default_project_name: () => repo_default_project_name,
+  resolve_external_dependencies: () => resolve_external_dependencies,
+  resolve_project: () => resolve_project,
+  risk_penalty: () => risk_penalty,
+  run_hook: () => run_hook,
+  run_monte_carlo_chunk: () => run_monte_carlo_chunk,
+  run_plugins_for_event: () => run_plugins_for_event,
+  sample_pert_beta: () => sample_pert_beta,
+  sample_task_hours: () => sample_task_hours,
+  schedule_next: () => schedule_next,
+  simulate_schedule: () => simulate_schedule,
   stringifyFrontmatter: () => stringifyFrontmatter,
+  stringifyYamlContent: () => stringifyYamlContent,
+  task_effort_hours: () => task_effort_hours,
   topological_sort: () => topological_sort,
   transition: () => transition,
   transitive_dependencies: () => transitive_dependencies,
   transitive_dependents: () => transitive_dependents,
+  type_weight: () => type_weight,
   updateItem: () => updateItem,
+  urgency_weight: () => urgency_weight,
   validate: () => validate,
   validateReferential: () => validateReferential,
   validateRepo: () => validateRepo,
@@ -92,10 +161,166 @@ __export(index_exports, {
   validate_graph: () => validate_graph,
   validate_transition: () => validate_transition,
   writeTask: () => writeTask,
-  write_schema_version: () => write_schema_version
+  writeYamlFile: () => writeYamlFile,
+  write_schema_version: () => write_schema_version,
+  write_workspace_config: () => write_workspace_config
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/planning/estimation.ts
+var COMPLEXITY_FALLBACK_HOURS = {
+  trivial: 1,
+  small: 4,
+  medium: 12,
+  large: 32,
+  unknown: Number.NaN
+};
+function validateEstimateValue(value, field) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`estimate.${field} must be a positive number.`);
+  }
+}
+function complexity_fallback_hours(complexity) {
+  if (!complexity) {
+    throw new Error("Task effort cannot be computed: missing complexity and estimate.");
+  }
+  if (complexity === "unknown") {
+    throw new Error("Task effort cannot be computed: complexity is 'unknown' and estimate is missing.");
+  }
+  return COMPLEXITY_FALLBACK_HOURS[complexity];
+}
+function pert_hours(estimate) {
+  validateEstimateValue(estimate.optimistic_hours, "optimistic_hours");
+  validateEstimateValue(estimate.expected_hours, "expected_hours");
+  validateEstimateValue(estimate.pessimistic_hours, "pessimistic_hours");
+  return (estimate.optimistic_hours + 4 * estimate.expected_hours + estimate.pessimistic_hours) / 6;
+}
+function pert_stddev(estimate) {
+  validateEstimateValue(estimate.optimistic_hours, "optimistic_hours");
+  validateEstimateValue(estimate.pessimistic_hours, "pessimistic_hours");
+  return (estimate.pessimistic_hours - estimate.optimistic_hours) / 6;
+}
+function task_effort_hours(task) {
+  const humanHours = task.resources?.human_hours;
+  if (typeof humanHours === "number" && Number.isFinite(humanHours)) {
+    if (humanHours < 0) {
+      throw new Error("resources.human_hours must be >= 0.");
+    }
+    return humanHours;
+  }
+  if (task.estimate) {
+    return pert_hours(task.estimate);
+  }
+  return complexity_fallback_hours(task.complexity);
+}
+function effort_or_default(task, config) {
+  const humanHours = task.resources?.human_hours;
+  if (typeof humanHours === "number" && Number.isFinite(humanHours)) {
+    if (humanHours < 0) {
+      throw new Error("resources.human_hours must be >= 0.");
+    }
+    return humanHours;
+  }
+  if (task.estimate) {
+    return pert_hours(task.estimate);
+  }
+  const defaultComplexity = config.defaults?.task?.complexity;
+  return complexity_fallback_hours(task.complexity ?? defaultComplexity);
+}
+
+// src/graph/external.ts
+var EXTERNAL_PREFIX = "external:";
+function is_external_dependency(value) {
+  return value.trim().toLowerCase().startsWith(EXTERNAL_PREFIX);
+}
+function parse_external_dependency(value) {
+  const normalized = value.trim();
+  if (!is_external_dependency(normalized)) {
+    return null;
+  }
+  const rest = normalized.slice(EXTERNAL_PREFIX.length);
+  const separator = rest.indexOf("/");
+  if (separator <= 0 || separator === rest.length - 1) {
+    return null;
+  }
+  const repo = rest.slice(0, separator).trim();
+  const taskId = rest.slice(separator + 1).trim();
+  if (!repo || !taskId) {
+    return null;
+  }
+  return {
+    raw: normalized,
+    repo,
+    task_id: taskId
+  };
+}
+function external_dependencies_for_task(graph, taskId) {
+  return [...graph.external_dependencies?.get(taskId) ?? []];
+}
+function joinUrl(baseUrl, pathName) {
+  return `${baseUrl.replace(/\/+$/g, "")}${pathName.startsWith("/") ? pathName : `/${pathName}`}`;
+}
+function resolvedStatus(taskStatus) {
+  if (!taskStatus) return "unknown";
+  if (taskStatus === "done" || taskStatus === "canceled") return "resolved";
+  return "blocked";
+}
+async function resolve_external_dependencies(graph, options) {
+  const fetchImpl = options.fetch_impl ?? fetch;
+  const resolutions = /* @__PURE__ */ new Map();
+  const externalMap = graph.external_dependencies ?? /* @__PURE__ */ new Map();
+  for (const [taskId, deps] of externalMap.entries()) {
+    const results = [];
+    for (const dep of deps) {
+      const remote = options.remotes[dep.repo];
+      if (!remote?.base_url) {
+        results.push({
+          dependency: dep,
+          status: "unknown",
+          warning: `No API base URL configured for external repo '${dep.repo}'.`
+        });
+        continue;
+      }
+      try {
+        const response = await fetchImpl(joinUrl(remote.base_url, `/api/tasks/${encodeURIComponent(dep.task_id)}`));
+        if (response.status === 404) {
+          results.push({
+            dependency: dep,
+            status: "missing",
+            warning: `External task '${dep.raw}' was not found at ${remote.base_url}.`
+          });
+          continue;
+        }
+        if (!response.ok) {
+          results.push({
+            dependency: dep,
+            status: "unreachable",
+            warning: `External task '${dep.raw}' returned HTTP ${response.status}.`
+          });
+          continue;
+        }
+        const payload = await response.json();
+        const taskRecord = payload && typeof payload === "object" && payload.task && typeof payload.task === "object" ? payload.task : payload;
+        const taskStatus = typeof taskRecord.status === "string" ? taskRecord.status : null;
+        results.push({
+          dependency: dep,
+          status: resolvedStatus(taskStatus),
+          task_status: taskStatus,
+          warning: resolvedStatus(taskStatus) === "resolved" ? void 0 : `External task '${dep.raw}' is ${taskStatus ?? "unknown"}.`
+        });
+      } catch {
+        results.push({
+          dependency: dep,
+          status: "unreachable",
+          warning: `External task '${dep.raw}' could not be reached.`
+        });
+      }
+    }
+    resolutions.set(taskId, results);
+  }
+  return resolutions;
+}
+
 // src/graph/dag.ts
 function existingDeps(graph, nodeId) {
   const deps = graph.forward.get(nodeId) ?? /* @__PURE__ */ new Set();
@@ -216,13 +441,25 @@ function build_graph(tasks, context = {}) {
   }
   const forward = /* @__PURE__ */ new Map();
   const reverse = /* @__PURE__ */ new Map();
+  const externalDependencies = /* @__PURE__ */ new Map();
   for (const nodeId of nodes.keys()) {
     forward.set(nodeId, /* @__PURE__ */ new Set());
     reverse.set(nodeId, /* @__PURE__ */ new Set());
+    externalDependencies.set(nodeId, []);
   }
   for (const task of tasks) {
-    const deps = new Set(task.depends_on ?? []);
+    const deps = /* @__PURE__ */ new Set();
+    const externalDeps = [];
+    for (const depId of task.depends_on ?? []) {
+      const external = parse_external_dependency(depId);
+      if (external) {
+        externalDeps.push(external);
+        continue;
+      }
+      deps.add(depId);
+    }
     forward.set(task.id, deps);
+    externalDependencies.set(task.id, externalDeps);
     for (const depId of deps) {
       if (!nodes.has(depId)) continue;
       reverse.get(depId)?.add(task.id);
@@ -235,16 +472,266 @@ function build_graph(tasks, context = {}) {
     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()
+    deliveries: context.deliveries ? new Map(context.deliveries) : /* @__PURE__ */ new Map(),
+    external_dependencies: externalDependencies
   };
   graph.topological_order = topological_sort(graph);
   return graph;
 }
 
-// src/graph/loader.ts
+// 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),
+    external_dependencies: new Map(
+      Array.from(selected).map((taskId) => [taskId, external_dependencies_for_task(graph, taskId)])
+    )
+  };
+  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);
+      }
+    }
+    for (const dep of external_dependencies_for_task(fullGraph, taskId)) {
+      external.add(dep.raw);
+    }
+  }
+  return Array.from(external).sort((a, b) => a.localeCompare(b));
+}
+
+// src/graph/critical-path.ts
+var DEFAULT_CONFIG = {
+  version: 2,
+  project: {
+    name: "COOP",
+    id: "coop"
+  },
+  defaults: {
+    task: {
+      complexity: "medium"
+    }
+  }
+};
+var EPSILON = 1e-9;
+function durationHours(task) {
+  return effort_or_default(task, DEFAULT_CONFIG);
+}
+function rootsOf(graph) {
+  const roots = [];
+  for (const id of graph.nodes.keys()) {
+    if ((graph.forward.get(id)?.size ?? 0) === 0) {
+      roots.push(id);
+    }
+  }
+  return roots;
+}
+function leavesOf(graph) {
+  const leaves = [];
+  for (const id of graph.nodes.keys()) {
+    if ((graph.reverse.get(id)?.size ?? 0) === 0) {
+      leaves.push(id);
+    }
+  }
+  return leaves;
+}
+function compute_critical_path(delivery, graph) {
+  const include = new Set(delivery.scope.include ?? []);
+  for (const excluded of delivery.scope.exclude ?? []) {
+    include.delete(excluded);
+  }
+  const subgraph = extract_subgraph(graph, [...include]);
+  if (subgraph.nodes.size === 0) {
+    return {
+      critical_path: [],
+      project_duration_hours: 0,
+      per_task: []
+    };
+  }
+  const roots = new Set(rootsOf(subgraph));
+  const leaves = new Set(leavesOf(subgraph));
+  const es = /* @__PURE__ */ new Map();
+  const ef = /* @__PURE__ */ new Map();
+  const ls = /* @__PURE__ */ new Map();
+  const lf = /* @__PURE__ */ new Map();
+  const durations = /* @__PURE__ */ new Map();
+  for (const taskId of subgraph.topological_order) {
+    const task = subgraph.nodes.get(taskId);
+    if (!task) continue;
+    const duration = durationHours(task);
+    durations.set(taskId, duration);
+    let earliestStart = 0;
+    if (!roots.has(taskId)) {
+      const deps = [...subgraph.forward.get(taskId) ?? /* @__PURE__ */ new Set()];
+      earliestStart = deps.length === 0 ? 0 : Math.max(...deps.map((depId) => ef.get(depId) ?? 0));
+    }
+    es.set(taskId, earliestStart);
+    ef.set(taskId, earliestStart + duration);
+  }
+  const project_duration_hours = Math.max(...[...leaves].map((id) => ef.get(id) ?? 0));
+  const reverseTopo = [...subgraph.topological_order].reverse();
+  for (const taskId of reverseTopo) {
+    const duration = durations.get(taskId) ?? 0;
+    let latestFinish = project_duration_hours;
+    if (!leaves.has(taskId)) {
+      const successors = [...subgraph.reverse.get(taskId) ?? /* @__PURE__ */ new Set()];
+      latestFinish = successors.length === 0 ? project_duration_hours : Math.min(...successors.map((id) => ls.get(id) ?? project_duration_hours));
+    }
+    lf.set(taskId, latestFinish);
+    ls.set(taskId, latestFinish - duration);
+  }
+  const per_task = [];
+  for (const id of subgraph.nodes.keys()) {
+    const ES = es.get(id) ?? 0;
+    const EF = ef.get(id) ?? 0;
+    const LS = ls.get(id) ?? 0;
+    const LF = lf.get(id) ?? 0;
+    const slack = LS - ES;
+    per_task.push({
+      id,
+      ES,
+      EF,
+      LS,
+      LF,
+      slack,
+      on_critical_path: Math.abs(slack) <= EPSILON
+    });
+  }
+  per_task.sort((a, b) => {
+    if (a.ES !== b.ES) return a.ES - b.ES;
+    return a.id.localeCompare(b.id);
+  });
+  const critical_path = per_task.filter((task) => task.on_critical_path).map((task) => task.id);
+  return {
+    critical_path,
+    project_duration_hours,
+    per_task
+  };
+}
+
+// src/index/index-manager.ts
 var import_node_fs5 = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
 
+// 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/parser/delivery-parser.ts
 var import_node_fs3 = __toESM(require("fs"), 1);
 
@@ -412,6 +899,12 @@ function parseYamlFile(filePath) {
   const content = import_node_fs2.default.readFileSync(filePath, "utf8");
   return parseYamlContent(content, filePath);
 }
+function stringifyYamlContent(content) {
+  return import_yaml2.default.stringify(content);
+}
+function writeYamlFile(filePath, content) {
+  import_node_fs2.default.writeFileSync(filePath, stringifyYamlContent(content), "utf8");
+}
 
 // src/parser/delivery-parser.ts
 function asStringArray(value) {
@@ -508,7 +1001,7 @@ function parseTaskFile(filePath) {
   return parseTaskContent(content, filePath);
 }
 
-// src/graph/loader.ts
+// src/index/index-manager.ts
 function walkFiles(dirPath, extensions) {
   if (!import_node_fs5.default.existsSync(dirPath)) return [];
   const out = [];
@@ -527,106 +1020,447 @@ function walkFiles(dirPath, extensions) {
   }
   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();
+function toPosixPath(input) {
+  return input.replace(/\\/g, "/");
+}
+function fromRecordMap(value) {
+  return new Map(Object.entries(value));
+}
+function toRecordMap(value) {
+  return Object.fromEntries(value.entries());
+}
+function round2(value) {
+  return Number(value.toFixed(2));
+}
+function parseTaskCollection(files, baseDir) {
+  const tasks = /* @__PURE__ */ new Map();
+  const fileToId = {};
   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}.`);
+    const parsed = parseTaskFile(filePath).task;
+    if (tasks.has(parsed.id)) {
+      throw new Error(`Duplicate task id '${parsed.id}' found at ${filePath}.`);
     }
-    seen.add(parsed.task.id);
-    tasks.push(parsed.task);
+    tasks.set(parsed.id, parsed);
+    fileToId[toPosixPath(import_node_path.default.relative(baseDir, filePath))] = parsed.id;
   }
-  return tasks;
+  return { tasks, fileToId };
 }
-function loadTracks(tracksDir) {
-  const files = walkFiles(tracksDir, /* @__PURE__ */ new Set([".yml", ".yaml"]));
+function parseTrackCollection(files, baseDir) {
   const tracks = /* @__PURE__ */ new Map();
+  const fileToId = {};
   for (const filePath of files) {
-    const data = parseYamlFile(filePath);
-    if (!data.id) continue;
-    tracks.set(data.id, data);
+    const parsed = parseYamlFile(filePath);
+    if (!parsed.id) continue;
+    tracks.set(parsed.id, parsed);
+    fileToId[toPosixPath(import_node_path.default.relative(baseDir, filePath))] = parsed.id;
   }
-  return tracks;
+  return { tracks, fileToId };
 }
-function loadResources(resourcesDir) {
-  const files = walkFiles(resourcesDir, /* @__PURE__ */ new Set([".yml", ".yaml"]));
+function parseResourceCollection(files, baseDir) {
   const resources = /* @__PURE__ */ new Map();
+  const fileToId = {};
   for (const filePath of files) {
-    const data = parseYamlFile(filePath);
-    if (!data.id) continue;
-    resources.set(data.id, data);
+    const parsed = parseYamlFile(filePath);
+    if (!parsed.id) continue;
+    resources.set(parsed.id, parsed);
+    fileToId[toPosixPath(import_node_path.default.relative(baseDir, filePath))] = parsed.id;
   }
-  return resources;
+  return { resources, fileToId };
 }
-function loadDeliveries(deliveriesDir) {
-  const files = walkFiles(deliveriesDir, /* @__PURE__ */ new Set([".yml", ".yaml", ".md"]));
+function parseDeliveryCollection(files, baseDir) {
   const deliveries = /* @__PURE__ */ new Map();
+  const fileToId = {};
   for (const filePath of files) {
-    const parsed = parseDeliveryFile(filePath);
-    deliveries.set(parsed.delivery.id, parsed.delivery);
+    const parsed = parseDeliveryFile(filePath).delivery;
+    deliveries.set(parsed.id, parsed);
+    fileToId[toPosixPath(import_node_path.default.relative(baseDir, filePath))] = parsed.id;
   }
-  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
-  });
+  return { deliveries, fileToId };
 }
-
-// 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);
+var IndexManager = class {
+  coopDir;
+  indexDir;
+  graphPath;
+  tasksPath;
+  capacityPath;
+  constructor(coopDir) {
+    this.coopDir = import_node_path.default.resolve(coopDir);
+    this.indexDir = import_node_path.default.join(this.coopDir, ".index");
+    this.graphPath = import_node_path.default.join(this.indexDir, "graph.json");
+    this.tasksPath = import_node_path.default.join(this.indexDir, "tasks.json");
+    this.capacityPath = import_node_path.default.join(this.indexDir, "capacity.json");
+  }
+  is_stale() {
+    return this.status().stale;
+  }
+  status() {
+    const scan = this.scanSources();
+    if (!import_node_fs5.default.existsSync(this.graphPath)) {
+      return {
+        exists: false,
+        stale: true,
+        graph_path: this.graphPath,
+        source_max_mtime_ms: scan.sourceMaxMtimeMs,
+        changed_files: Object.keys(scan.sourceFiles).sort((a, b) => a.localeCompare(b)),
+        reason: "graph index missing"
+      };
     }
-  }
-  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);
+    const indexed = this.readGraphIndexFile();
+    if (!indexed) {
+      return {
+        exists: true,
+        stale: true,
+        graph_path: this.graphPath,
+        source_max_mtime_ms: scan.sourceMaxMtimeMs,
+        changed_files: Object.keys(scan.sourceFiles).sort((a, b) => a.localeCompare(b)),
+        reason: "graph index unreadable"
+      };
+    }
+    const changed = /* @__PURE__ */ new Set();
+    for (const [relativePath, mtime] of Object.entries(scan.sourceFiles)) {
+      const indexedMtime = indexed.source_files[relativePath];
+      if (indexedMtime === void 0 || indexedMtime !== mtime) {
+        changed.add(relativePath);
       }
     }
-  }
-  return Array.from(external).sort((a, b) => a.localeCompare(b));
+    for (const relativePath of Object.keys(indexed.source_files)) {
+      if (scan.sourceFiles[relativePath] === void 0) {
+        changed.add(relativePath);
+      }
+    }
+    return {
+      exists: true,
+      stale: changed.size > 0 || indexed.version !== 1,
+      graph_path: this.graphPath,
+      source_max_mtime_ms: scan.sourceMaxMtimeMs,
+      changed_files: Array.from(changed).sort((a, b) => a.localeCompare(b)),
+      generated_at: indexed.generated_at,
+      reason: indexed.version === 1 ? void 0 : "index version mismatch"
+    };
+  }
+  load_indexed_graph() {
+    const indexed = this.readGraphIndexFile();
+    if (!indexed) return null;
+    try {
+      return this.deserializeGraph(indexed.graph);
+    } catch {
+      return null;
+    }
+  }
+  build_full_index() {
+    const scan = this.scanSources();
+    const taskData = parseTaskCollection(scan.taskFiles, this.coopDir);
+    const trackData = parseTrackCollection(scan.trackFiles, this.coopDir);
+    const resourceData = parseResourceCollection(scan.resourceFiles, this.coopDir);
+    const deliveryData = parseDeliveryCollection(scan.deliveryFiles, this.coopDir);
+    const graph = build_graph(Array.from(taskData.tasks.values()), {
+      tracks: trackData.tracks,
+      resources: resourceData.resources,
+      deliveries: deliveryData.deliveries
+    });
+    this.writeIndexFiles(
+      graph,
+      scan,
+      {
+        tasks: taskData.fileToId,
+        tracks: trackData.fileToId,
+        resources: resourceData.fileToId,
+        deliveries: deliveryData.fileToId
+      }
+    );
+    return graph;
+  }
+  update_incremental(changedFiles) {
+    const indexed = this.readGraphIndexFile();
+    if (!indexed) {
+      return this.build_full_index();
+    }
+    const scan = this.scanSources();
+    const changed = changedFiles.length > 0 ? changedFiles : this.status().changed_files;
+    const normalized = new Set(
+      changed.map((entry) => this.normalizeChangedFile(entry)).filter((entry) => Boolean(entry))
+    );
+    if (normalized.size === 0) {
+      const fromIndex = this.load_indexed_graph();
+      return fromIndex ?? this.build_full_index();
+    }
+    const taskMap = fromRecordMap(indexed.graph.nodes);
+    const trackMap = fromRecordMap(indexed.graph.tracks);
+    const resourceMap = fromRecordMap(indexed.graph.resources);
+    const deliveryMap = fromRecordMap(indexed.graph.deliveries);
+    const fileMaps = {
+      tasks: { ...indexed.files.tasks },
+      tracks: { ...indexed.files.tracks },
+      resources: { ...indexed.files.resources },
+      deliveries: { ...indexed.files.deliveries }
+    };
+    for (const relativePath of normalized) {
+      const kind = this.fileKind(relativePath);
+      if (!kind) {
+        return this.build_full_index();
+      }
+      const absolutePath = import_node_path.default.join(this.coopDir, relativePath);
+      const exists = import_node_fs5.default.existsSync(absolutePath);
+      if (!exists) {
+        const oldId = fileMaps[kind][relativePath];
+        if (!oldId) {
+          return this.build_full_index();
+        }
+        delete fileMaps[kind][relativePath];
+        if (kind === "tasks") taskMap.delete(oldId);
+        if (kind === "tracks") trackMap.delete(oldId);
+        if (kind === "resources") resourceMap.delete(oldId);
+        if (kind === "deliveries") deliveryMap.delete(oldId);
+        continue;
+      }
+      try {
+        if (kind === "tasks") {
+          const oldId2 = fileMaps.tasks[relativePath];
+          if (oldId2) taskMap.delete(oldId2);
+          const parsed2 = parseTaskFile(absolutePath).task;
+          taskMap.set(parsed2.id, parsed2);
+          fileMaps.tasks[relativePath] = parsed2.id;
+          continue;
+        }
+        if (kind === "tracks") {
+          const oldId2 = fileMaps.tracks[relativePath];
+          if (oldId2) trackMap.delete(oldId2);
+          const parsed2 = parseYamlFile(absolutePath);
+          if (parsed2.id) {
+            trackMap.set(parsed2.id, parsed2);
+            fileMaps.tracks[relativePath] = parsed2.id;
+          }
+          continue;
+        }
+        if (kind === "resources") {
+          const oldId2 = fileMaps.resources[relativePath];
+          if (oldId2) resourceMap.delete(oldId2);
+          const parsed2 = parseYamlFile(absolutePath);
+          if (parsed2.id) {
+            resourceMap.set(parsed2.id, parsed2);
+            fileMaps.resources[relativePath] = parsed2.id;
+          }
+          continue;
+        }
+        const oldId = fileMaps.deliveries[relativePath];
+        if (oldId) deliveryMap.delete(oldId);
+        const parsed = parseDeliveryFile(absolutePath).delivery;
+        deliveryMap.set(parsed.id, parsed);
+        fileMaps.deliveries[relativePath] = parsed.id;
+      } catch {
+        return this.build_full_index();
+      }
+    }
+    const graph = build_graph(Array.from(taskMap.values()), {
+      tracks: trackMap,
+      resources: resourceMap,
+      deliveries: deliveryMap
+    });
+    this.writeIndexFiles(graph, scan, fileMaps);
+    return graph;
+  }
+  ensureIndexDir() {
+    import_node_fs5.default.mkdirSync(this.indexDir, { recursive: true });
+  }
+  writeIndexFiles(graph, scan, fileMaps) {
+    this.ensureIndexDir();
+    const graphIndex = {
+      version: 1,
+      generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      source_max_mtime_ms: scan.sourceMaxMtimeMs,
+      source_files: scan.sourceFiles,
+      files: fileMaps,
+      graph: this.serializeGraph(graph)
+    };
+    import_node_fs5.default.writeFileSync(this.graphPath, `${JSON.stringify(graphIndex, null, 2)}
+`, "utf8");
+    import_node_fs5.default.writeFileSync(this.tasksPath, `${JSON.stringify(this.computeTaskIndexRows(graph), null, 2)}
+`, "utf8");
+    import_node_fs5.default.writeFileSync(
+      this.capacityPath,
+      `${JSON.stringify(this.computeCapacitySnapshot(graph.resources), null, 2)}
+`,
+      "utf8"
+    );
+  }
+  readGraphIndexFile() {
+    if (!import_node_fs5.default.existsSync(this.graphPath)) return null;
+    try {
+      const parsed = JSON.parse(import_node_fs5.default.readFileSync(this.graphPath, "utf8"));
+      if (!parsed || typeof parsed !== "object") return null;
+      if (!parsed.graph || typeof parsed.graph !== "object") return null;
+      if (!parsed.source_files || typeof parsed.source_files !== "object") return null;
+      if (!parsed.files || typeof parsed.files !== "object") return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  serializeGraph(graph) {
+    return {
+      nodes: toRecordMap(graph.nodes),
+      forward: Object.fromEntries(
+        Array.from(graph.forward.entries()).map(([id, deps]) => [id, Array.from(deps).sort((a, b) => a.localeCompare(b))])
+      ),
+      reverse: Object.fromEntries(
+        Array.from(graph.reverse.entries()).map(([id, deps]) => [id, Array.from(deps).sort((a, b) => a.localeCompare(b))])
+      ),
+      topological_order: [...graph.topological_order],
+      tracks: toRecordMap(graph.tracks),
+      resources: toRecordMap(graph.resources),
+      deliveries: toRecordMap(graph.deliveries),
+      external_dependencies: Object.fromEntries(
+        Array.from(graph.external_dependencies?.entries() ?? []).map(([id, deps]) => [id, deps])
+      )
+    };
+  }
+  deserializeGraph(data) {
+    return {
+      nodes: fromRecordMap(data.nodes ?? {}),
+      forward: new Map(
+        Object.entries(data.forward ?? {}).map(([id, deps]) => [id, new Set(deps ?? [])])
+      ),
+      reverse: new Map(
+        Object.entries(data.reverse ?? {}).map(([id, deps]) => [id, new Set(deps ?? [])])
+      ),
+      topological_order: Array.isArray(data.topological_order) ? [...data.topological_order] : [],
+      tracks: fromRecordMap(data.tracks ?? {}),
+      resources: fromRecordMap(data.resources ?? {}),
+      deliveries: fromRecordMap(data.deliveries ?? {}),
+      external_dependencies: new Map(Object.entries(data.external_dependencies ?? {}))
+    };
+  }
+  scanSources() {
+    const taskFiles = walkFiles(import_node_path.default.join(this.coopDir, "tasks"), /* @__PURE__ */ new Set([".md"]));
+    const trackFiles = walkFiles(import_node_path.default.join(this.coopDir, "tracks"), /* @__PURE__ */ new Set([".yml", ".yaml"]));
+    const resourceFiles = walkFiles(import_node_path.default.join(this.coopDir, "resources"), /* @__PURE__ */ new Set([".yml", ".yaml"]));
+    const deliveryFiles = walkFiles(import_node_path.default.join(this.coopDir, "deliveries"), /* @__PURE__ */ new Set([".yml", ".yaml", ".md"]));
+    const sourceFiles = {};
+    let sourceMaxMtimeMs = 0;
+    const allFiles = [...taskFiles, ...trackFiles, ...resourceFiles, ...deliveryFiles];
+    for (const filePath of allFiles) {
+      const stat = import_node_fs5.default.statSync(filePath);
+      const relative = toPosixPath(import_node_path.default.relative(this.coopDir, filePath));
+      sourceFiles[relative] = stat.mtimeMs;
+      if (stat.mtimeMs > sourceMaxMtimeMs) {
+        sourceMaxMtimeMs = stat.mtimeMs;
+      }
+    }
+    return {
+      taskFiles,
+      trackFiles,
+      resourceFiles,
+      deliveryFiles,
+      sourceFiles,
+      sourceMaxMtimeMs
+    };
+  }
+  normalizeChangedFile(value) {
+    if (!value || !value.trim()) return null;
+    const normalized = import_node_path.default.normalize(value.trim());
+    const absolute = import_node_path.default.isAbsolute(normalized) ? normalized : import_node_path.default.resolve(this.coopDir, normalized);
+    const relative = import_node_path.default.relative(this.coopDir, absolute);
+    if (relative.startsWith("..")) return null;
+    return toPosixPath(relative);
+  }
+  fileKind(relativePath) {
+    if (relativePath.startsWith("tasks/")) return "tasks";
+    if (relativePath.startsWith("tracks/")) return "tracks";
+    if (relativePath.startsWith("resources/")) return "resources";
+    if (relativePath.startsWith("deliveries/")) return "deliveries";
+    return null;
+  }
+  computeTaskIndexRows(graph) {
+    const depth = /* @__PURE__ */ new Map();
+    for (const id of graph.topological_order) {
+      const deps = Array.from(graph.forward.get(id) ?? /* @__PURE__ */ new Set()).filter((dep) => graph.nodes.has(dep));
+      if (deps.length === 0) {
+        depth.set(id, 0);
+        continue;
+      }
+      const maxDepDepth = Math.max(...deps.map((dep) => depth.get(dep) ?? 0));
+      depth.set(id, maxDepDepth + 1);
+    }
+    const rows = {};
+    for (const [id, task] of graph.nodes.entries()) {
+      const estimate = task.estimate;
+      let pertHours;
+      let pertStddev;
+      if (estimate && typeof estimate.optimistic_hours === "number" && typeof estimate.expected_hours === "number" && typeof estimate.pessimistic_hours === "number") {
+        pertHours = round2((estimate.optimistic_hours + 4 * estimate.expected_hours + estimate.pessimistic_hours) / 6);
+        pertStddev = round2((estimate.pessimistic_hours - estimate.optimistic_hours) / 6);
+      }
+      const blocks = Array.from(graph.reverse.get(id) ?? /* @__PURE__ */ new Set()).sort((a, b) => a.localeCompare(b));
+      const row = {
+        id,
+        status: task.status,
+        priority: task.priority ?? null,
+        track: task.track ?? null,
+        blocks,
+        readiness: compute_readiness(task, graph),
+        depth: depth.get(id) ?? 0
+      };
+      if (pertHours !== void 0) row.pert_hours = pertHours;
+      if (pertStddev !== void 0) row.pert_stddev = pertStddev;
+      rows[id] = row;
+    }
+    return rows;
+  }
+  computeCapacitySnapshot(resources) {
+    const profiles = {};
+    for (const [id, profile] of resources.entries()) {
+      if (profile.type === "human") {
+        const members = profile.members ?? [];
+        const baseHours = members.reduce((sum, member) => sum + (member.hours_per_week ?? 0), 0);
+        const meetings = profile.overhead?.meetings_percent ?? 0;
+        const context = profile.overhead?.context_switch_percent ?? 0;
+        const overheadPercent = meetings + context;
+        const effectiveHours = baseHours * Math.max(0, 1 - overheadPercent / 100);
+        profiles[id] = {
+          id,
+          type: profile.type,
+          members: members.length,
+          total_weekly_hours: round2(baseHours),
+          effective_weekly_hours: round2(effectiveHours),
+          overhead_percent: round2(overheadPercent)
+        };
+        continue;
+      }
+      if (profile.type === "ai") {
+        profiles[id] = {
+          id,
+          type: profile.type,
+          agents: profile.agents.length,
+          effective_capacity: profile.effective_capacity ?? null
+        };
+        continue;
+      }
+      profiles[id] = {
+        id,
+        type: profile.type,
+        nodes: profile.nodes.length,
+        effective_capacity: profile.effective_capacity ?? null
+      };
+    }
+    return {
+      generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      profiles
+    };
+  }
+};
+
+// src/graph/loader.ts
+function load_graph(coopDir) {
+  const index = new IndexManager(coopDir);
+  const status = index.status();
+  if (status.exists && !status.stale) {
+    const cached = index.load_indexed_graph();
+    if (cached) return cached;
+  }
+  if (!status.exists) {
+    return index.build_full_index();
+  }
+  return index.update_incremental(status.changed_files);
 }
 
 // src/graph/validator.ts
@@ -692,10 +1526,17 @@ function checkTerminalConvergence(graph) {
   }
   return issues;
 }
-function validate_graph(graph) {
+function validate_graph(graph, context = {}) {
   const issues = [];
   const cycle = detect_cycle(graph);
   if (cycle) {
+    context.eventEmitter?.emit({
+      type: "graph.cycle_detected",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: {
+        cycle
+      }
+    });
     issues.push(error("acyclicity", `Dependency cycle detected: ${cycle.join(" -> ")}.`, cycle));
   }
   for (const [taskId, deps] of graph.forward.entries()) {
@@ -733,8 +1574,540 @@ function validate_graph(graph) {
   return issues;
 }
 
-// src/parser/idea-parser.ts
+// src/events/emitter.ts
+var CoopEventEmitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  on(eventType, handler) {
+    const existing = this.handlers.get(eventType) ?? /* @__PURE__ */ new Set();
+    existing.add(handler);
+    this.handlers.set(eventType, existing);
+    return () => {
+      const bucket = this.handlers.get(eventType);
+      if (!bucket) return;
+      bucket.delete(handler);
+      if (bucket.size === 0) {
+        this.handlers.delete(eventType);
+      }
+    };
+  }
+  emit(event) {
+    const listeners = this.handlers.get(event.type);
+    if (!listeners || listeners.size === 0) return;
+    for (const listener of listeners) {
+      listener(event);
+    }
+  }
+};
+
+// src/events/events.ts
+var COOP_EVENT_TYPES = [
+  "task.created",
+  "task.transitioned",
+  "task.assigned",
+  "delivery.committed",
+  "delivery.at_risk",
+  "run.started",
+  "run.completed",
+  "run.failed",
+  "graph.cycle_detected"
+];
+
+// src/events/hook-runner.ts
+var import_node_child_process = require("child_process");
+var import_node_path2 = __toESM(require("path"), 1);
+function commandFor(hookPath) {
+  const ext = import_node_path2.default.extname(hookPath).toLowerCase();
+  if (ext === ".js" || ext === ".mjs" || ext === ".cjs") {
+    return {
+      command: process.execPath,
+      args: [hookPath]
+    };
+  }
+  return {
+    command: hookPath,
+    args: []
+  };
+}
+function run_hook(hookPath, event, timeoutMs = 1e4) {
+  return new Promise((resolve) => {
+    const payload = JSON.stringify(event);
+    const runner = commandFor(hookPath);
+    const child = (0, import_node_child_process.spawn)(runner.command, runner.args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: runner.command === hookPath,
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      settle({
+        exitCode: null,
+        stdout,
+        stderr: `${stderr}${stderr ? "\n" : ""}Hook timed out after ${timeoutMs}ms.`,
+        timedOut: true
+      });
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error6) => {
+      clearTimeout(timeout);
+      settle({
+        exitCode: -1,
+        stdout,
+        stderr: `${stderr}${stderr ? "\n" : ""}${error6.message}`,
+        timedOut: false
+      });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timeout);
+      settle({
+        exitCode: timedOut ? null : code,
+        stdout,
+        stderr,
+        timedOut
+      });
+    });
+    child.stdin.write(payload, "utf8");
+    child.stdin.end();
+  });
+}
+
+// src/auth/auth.ts
+var DEFAULT_AUTH_CONFIG = {
+  enabled: false,
+  roles: {
+    admin: { permissions: ["all"] },
+    lead: {
+      permissions: ["create_task", "transition_task", "create_delivery", "plan_delivery", "assign_task"]
+    },
+    contributor: { permissions: ["transition_own_task", "comment"] },
+    viewer: { permissions: ["read"] }
+  },
+  assignments: {},
+  policies: [
+    { action: "delete_task", requires: ["admin"] },
+    { action: "commit_delivery", requires: ["admin", "lead"] },
+    { action: "override_blocked", requires: ["admin", "lead"] }
+  ]
+};
+function normalizeRole(value) {
+  if (typeof value !== "string") return null;
+  if (value === "admin" || value === "lead" || value === "contributor" || value === "viewer") return value;
+  return null;
+}
+function asPermissions(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((entry) => String(entry)).filter((entry) => {
+    return entry === "all" || entry === "read" || entry === "comment" || entry === "create_task" || entry === "transition_task" || entry === "transition_own_task" || entry === "create_delivery" || entry === "plan_delivery" || entry === "assign_task" || entry === "delete_task" || entry === "commit_delivery" || entry === "override_blocked";
+  });
+}
+function normalizeUser(value) {
+  return value.trim().toLowerCase();
+}
+function loadPolicies(raw) {
+  if (!Array.isArray(raw)) return [...DEFAULT_AUTH_CONFIG.policies];
+  const out = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const record = entry;
+    const action = typeof record.action === "string" ? record.action : "";
+    if (action !== "delete_task" && action !== "commit_delivery" && action !== "override_blocked" && action !== "transition_task" && action !== "create_delivery") {
+      continue;
+    }
+    const requiresRaw = record.requires;
+    const requiresList = Array.isArray(requiresRaw) ? requiresRaw : [requiresRaw];
+    const requires = requiresList.map((role) => normalizeRole(role)).filter((role) => Boolean(role));
+    if (requires.length === 0) continue;
+    out.push({ action, requires });
+  }
+  return out.length > 0 ? out : [...DEFAULT_AUTH_CONFIG.policies];
+}
+function load_auth_config(config) {
+  const source = config && typeof config === "object" ? config : {};
+  const rawAuth = source.authorization && typeof source.authorization === "object" ? source.authorization : {};
+  const enabled = Boolean(rawAuth.enabled ?? false);
+  const rawRoles = rawAuth.roles && typeof rawAuth.roles === "object" ? rawAuth.roles : {};
+  const roles = {
+    admin: { permissions: [...DEFAULT_AUTH_CONFIG.roles.admin.permissions] },
+    lead: { permissions: [...DEFAULT_AUTH_CONFIG.roles.lead.permissions] },
+    contributor: { permissions: [...DEFAULT_AUTH_CONFIG.roles.contributor.permissions] },
+    viewer: { permissions: [...DEFAULT_AUTH_CONFIG.roles.viewer.permissions] }
+  };
+  for (const role of Object.keys(roles)) {
+    const roleConfig = rawRoles[role];
+    if (!roleConfig || typeof roleConfig !== "object") continue;
+    const permissions = asPermissions(roleConfig.permissions);
+    if (permissions.length > 0) {
+      roles[role].permissions = permissions;
+    }
+  }
+  const rawAssignments = rawAuth.assignments && typeof rawAuth.assignments === "object" ? rawAuth.assignments : {};
+  const assignments = {};
+  for (const [user, roleRaw] of Object.entries(rawAssignments)) {
+    const role = normalizeRole(roleRaw);
+    if (!role) continue;
+    assignments[normalizeUser(user)] = role;
+  }
+  const policies = loadPolicies(rawAuth.policies);
+  return {
+    enabled,
+    roles,
+    assignments,
+    policies
+  };
+}
+function get_user_role(user, config) {
+  const key = normalizeUser(user);
+  return config.assignments[key] ?? "viewer";
+}
+function hasRolePolicyOverride(role, action, config) {
+  const policy = config.policies.find((entry) => entry.action === action);
+  if (!policy) return true;
+  return policy.requires.includes(role);
+}
+function check_permission(user, action, context) {
+  const { config } = context;
+  if (!config.enabled) return true;
+  const role = get_user_role(user, config);
+  const rolePermissions = new Set(config.roles[role]?.permissions ?? []);
+  let allowed = rolePermissions.has("all") || rolePermissions.has(action);
+  if (!allowed && action === "transition_task" && rolePermissions.has("transition_own_task")) {
+    const owner = context.taskOwner?.trim() ?? "";
+    allowed = owner.length > 0 && normalizeUser(owner) === normalizeUser(user);
+  }
+  if (!allowed) return false;
+  return hasRolePolicyOverride(role, action, config);
+}
+
+// src/plugins/plugin-loader.ts
 var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var EVENT_TYPES = new Set(COOP_EVENT_TYPES);
+var PLUGIN_ID_PATTERN = /^[a-z0-9]+(?:[-_][a-z0-9]+)*$/i;
+function pluginDir(coopDir) {
+  return import_node_path3.default.join(coopDir, "plugins");
+}
+function listPluginFiles(coopDir) {
+  const dir = pluginDir(coopDir);
+  if (!import_node_fs6.default.existsSync(dir)) return [];
+  const entries = import_node_fs6.default.readdirSync(dir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && /\.(yml|yaml)$/i.test(entry.name)).map((entry) => import_node_path3.default.join(dir, entry.name)).sort((a, b) => a.localeCompare(b));
+}
+function asString(value, field, source) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${source}: ${field} must be a non-empty string.`);
+  }
+  return value.trim();
+}
+function asStringMap(value, field, source) {
+  if (value === void 0) return {};
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${source}: ${field} must be a mapping of string values.`);
+  }
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry !== "string") {
+      throw new Error(`${source}: ${field}.${key} must be a string.`);
+    }
+    out[key] = entry;
+  }
+  return out;
+}
+function parseAction(raw, source) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`${source}: trigger action must be a mapping object.`);
+  }
+  const record = raw;
+  const actionType = asString(record.type, "action.type", source).toLowerCase();
+  if (actionType === "webhook") {
+    const url = asString(record.url, "action.url", source);
+    const template = record.template === void 0 ? void 0 : asString(record.template, "action.template", source);
+    const headers = asStringMap(record.headers, "action.headers", source);
+    return { type: "webhook", url, template, headers };
+  }
+  if (actionType === "console") {
+    const template = asString(record.template, "action.template", source);
+    return { type: "console", template };
+  }
+  if (actionType === "github_pr") {
+    const operation = asString(record.operation, "action.operation", source).toLowerCase();
+    if (operation !== "create_or_update" && operation !== "merge") {
+      throw new Error(`${source}: unsupported action.operation '${operation}' for github_pr.`);
+    }
+    const branch = record.branch === void 0 ? void 0 : asString(record.branch, "action.branch", source);
+    const baseBranch = record.base_branch === void 0 ? void 0 : asString(record.base_branch, "action.base_branch", source);
+    const draft = record.draft === void 0 ? void 0 : Boolean(record.draft);
+    return {
+      type: "github_pr",
+      operation,
+      branch,
+      base_branch: baseBranch,
+      draft
+    };
+  }
+  throw new Error(`${source}: unsupported action.type '${actionType}'.`);
+}
+function parseTrigger(raw, source, index) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`${source}: triggers[${index}] must be a mapping object.`);
+  }
+  const record = raw;
+  const event = asString(record.event, `triggers[${index}].event`, source);
+  if (!EVENT_TYPES.has(event)) {
+    throw new Error(`${source}: unsupported event '${event}' in triggers[${index}].`);
+  }
+  const filterRaw = record.filter;
+  if (filterRaw !== void 0 && (!filterRaw || typeof filterRaw !== "object" || Array.isArray(filterRaw))) {
+    throw new Error(`${source}: triggers[${index}].filter must be a mapping object.`);
+  }
+  const action = parseAction(record.action, `${source} triggers[${index}]`);
+  return {
+    event,
+    filter: filterRaw,
+    action
+  };
+}
+function parseSecrets(value, source) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    throw new Error(`${source}: secrets must be a list of environment variable names.`);
+  }
+  return value.map((entry, index) => asString(entry, `secrets[${index}]`, source));
+}
+function parsePlugin(filePath) {
+  const source = import_node_path3.default.relative(import_node_path3.default.dirname(import_node_path3.default.dirname(filePath)), filePath);
+  const raw = parseYamlFile(filePath);
+  const id = asString(raw.id, "id", source);
+  if (!PLUGIN_ID_PATTERN.test(id)) {
+    throw new Error(`${source}: id '${id}' contains invalid characters.`);
+  }
+  const name = asString(raw.name, "name", source);
+  const version = asString(raw.version, "version", source);
+  if (!Array.isArray(raw.triggers) || raw.triggers.length === 0) {
+    throw new Error(`${source}: triggers must be a non-empty list.`);
+  }
+  const triggers = raw.triggers.map((entry, index) => parseTrigger(entry, source, index));
+  const secrets = parseSecrets(raw.secrets, source);
+  return {
+    id,
+    name,
+    version,
+    triggers,
+    secrets,
+    file_path: filePath
+  };
+}
+function load_plugins(coopDir) {
+  const files = listPluginFiles(coopDir);
+  const plugins = files.map((filePath) => parsePlugin(filePath));
+  const seen = /* @__PURE__ */ new Set();
+  for (const plugin of plugins) {
+    if (seen.has(plugin.id)) {
+      throw new Error(`Duplicate plugin id '${plugin.id}'.`);
+    }
+    seen.add(plugin.id);
+  }
+  return plugins;
+}
+
+// src/plugins/plugin-runner.ts
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function resolvePathValue(input, pathExpr) {
+  const tokens = pathExpr.split(".").map((entry) => entry.trim()).filter(Boolean);
+  if (tokens.length === 0) return void 0;
+  let cursor = input;
+  for (const token of tokens) {
+    if (!isObject(cursor)) return void 0;
+    cursor = cursor[token];
+  }
+  return cursor;
+}
+function renderTemplate(template, context) {
+  return template.replace(/{{\s*([^}]+?)\s*}}/g, (_, expr) => {
+    const value = resolvePathValue(context, expr);
+    if (value === null || value === void 0) return "";
+    if (typeof value === "object") return JSON.stringify(value);
+    return String(value);
+  });
+}
+function resolveSecrets(template, env, plugin) {
+  return template.replace(/\$\{([A-Z0-9_]+)\}/g, (_, secretName) => {
+    if (!plugin.secrets.includes(secretName)) {
+      throw new Error(`Plugin '${plugin.id}' references undeclared secret '${secretName}'.`);
+    }
+    const value = env[secretName];
+    if (!value) {
+      throw new Error(`Plugin '${plugin.id}' missing environment value for '${secretName}'.`);
+    }
+    return value;
+  });
+}
+function filterMatches(filter, eventView) {
+  if (!filter) return true;
+  for (const [key, expected] of Object.entries(filter)) {
+    const actual = resolvePathValue(eventView, key);
+    if (Array.isArray(expected)) {
+      const allowed = expected.map((entry) => String(entry));
+      if (!allowed.includes(String(actual))) return false;
+      continue;
+    }
+    if (String(actual) !== String(expected)) return false;
+  }
+  return true;
+}
+function eventTemplateView(event) {
+  return {
+    type: event.type,
+    timestamp: event.timestamp,
+    ...event.payload
+  };
+}
+function buildContext(event, graph) {
+  const context = {
+    event: eventTemplateView(event)
+  };
+  if (graph) {
+    const payload = event.payload;
+    const taskId = typeof payload.task_id === "string" ? payload.task_id : void 0;
+    const deliveryId = typeof payload.delivery_id === "string" ? payload.delivery_id : void 0;
+    if (taskId) {
+      const task = graph.nodes.get(taskId);
+      if (task) {
+        context.task = task;
+      }
+    }
+    if (deliveryId) {
+      const delivery = graph.deliveries.get(deliveryId);
+      if (delivery) {
+        context.delivery = delivery;
+      }
+    }
+  }
+  return context;
+}
+function appendRunLog(coopDir, record) {
+  const runsDir = import_node_path4.default.join(coopDir, "runs");
+  import_node_fs7.default.mkdirSync(runsDir, { recursive: true });
+  const logPath = import_node_path4.default.join(runsDir, "plugin-events.log");
+  import_node_fs7.default.appendFileSync(logPath, `${JSON.stringify(record)}
+`, "utf8");
+}
+async function executeWebhookAction(plugin, trigger, action, context, env, fetchImpl) {
+  const resolvedUrl = resolveSecrets(action.url, env, plugin);
+  const template = action.template ?? "{{ event.type }}";
+  const body = renderTemplate(resolveSecrets(template, env, plugin), context);
+  const headers = {
+    "content-type": "text/plain; charset=utf-8"
+  };
+  for (const [key, value] of Object.entries(action.headers ?? {})) {
+    headers[key] = resolveSecrets(value, env, plugin);
+  }
+  const response = await fetchImpl(resolvedUrl, {
+    method: "POST",
+    headers,
+    body
+  });
+  return {
+    statusCode: response.status,
+    message: `${trigger.event} -> ${response.status}`
+  };
+}
+function executeConsoleAction(plugin, action, context, env) {
+  const template = resolveSecrets(action.template, env, plugin);
+  const message = renderTemplate(template, context);
+  console.log(`[COOP][plugin:${plugin.id}] ${message}`);
+  return { message };
+}
+async function executeCustomAction(plugin, trigger, action, context, env, actionHandlers) {
+  const handler = actionHandlers[action.type];
+  if (!handler) {
+    throw new Error(`Plugin action '${action.type}' requires a registered action handler.`);
+  }
+  return handler(plugin, trigger, action, context, env);
+}
+async function run_plugins_for_event(coopDir, event, options = {}) {
+  const env = options.env ?? process.env;
+  const fetchImpl = options.fetch_impl ?? fetch;
+  const graph = options.graph;
+  const actionHandlers = options.action_handlers ?? {};
+  const plugins = load_plugins(coopDir);
+  const context = buildContext(event, graph);
+  const eventView = context.event;
+  const results = [];
+  for (const plugin of plugins) {
+    for (const trigger of plugin.triggers) {
+      if (trigger.event !== event.type) continue;
+      if (!filterMatches(trigger.filter, eventView)) continue;
+      const base = {
+        plugin_id: plugin.id,
+        plugin_name: plugin.name,
+        trigger_event: trigger.event,
+        action_type: trigger.action.type,
+        success: false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      try {
+        if (trigger.action.type === "webhook") {
+          const result = await executeWebhookAction(plugin, trigger, trigger.action, context, env, fetchImpl);
+          base.success = true;
+          base.status_code = result.statusCode;
+          base.message = result.message;
+        } else if (trigger.action.type === "console") {
+          const result = executeConsoleAction(plugin, trigger.action, context, env);
+          base.success = true;
+          base.message = result.message;
+        } else {
+          const result = await executeCustomAction(plugin, trigger, trigger.action, context, env, actionHandlers);
+          base.success = true;
+          base.status_code = result.statusCode;
+          base.message = result.message;
+        }
+      } catch (error6) {
+        base.success = false;
+        base.error = error6 instanceof Error ? error6.message : String(error6);
+      }
+      appendRunLog(coopDir, base);
+      results.push(base);
+    }
+  }
+  return results;
+}
+
+// src/models/run.ts
+var RunStatus = {
+  pending: "pending",
+  running: "running",
+  paused: "paused",
+  completed: "completed",
+  failed: "failed",
+  canceled: "canceled"
+};
+var RunStepStatus = {
+  completed: "completed",
+  failed: "failed",
+  paused: "paused",
+  skipped: "skipped"
+};
+
+// src/parser/idea-parser.ts
+var import_node_fs8 = __toESM(require("fs"), 1);
 function asStringArray2(value) {
   if (!Array.isArray(value)) {
     return [];
@@ -766,6 +2139,7 @@ function parseIdeaFromRaw(raw, source) {
     id,
     title,
     created,
+    aliases: asStringArray2(raw.aliases),
     author,
     status,
     tags: asStringArray2(raw.tags),
@@ -782,12 +2156,12 @@ function parseIdeaContent(content, source = "<content>") {
   };
 }
 function parseIdeaFile(filePath) {
-  const content = import_node_fs6.default.readFileSync(filePath, "utf8");
+  const content = import_node_fs8.default.readFileSync(filePath, "utf8");
   return parseIdeaContent(content, filePath);
 }
 
 // src/parser/task-writer.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
 var TASK_FIELD_ORDER = [
   "id",
   "title",
@@ -795,6 +2169,7 @@ var TASK_FIELD_ORDER = [
   "status",
   "created",
   "updated",
+  "aliases",
   "priority",
   "track",
   "assignee",
@@ -832,123 +2207,1971 @@ function buildOrderedFrontmatter(task, raw) {
   if (!raw) {
     return ordered;
   }
-  for (const key of Object.keys(raw)) {
-    if (ORDERED_TASK_FIELDS.has(key)) {
-      continue;
+  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) {
+    const existedBeforeWrite = import_node_fs9.default.existsSync(options.filePath);
+    import_node_fs9.default.writeFileSync(options.filePath, output, "utf8");
+    if (!existedBeforeWrite) {
+      options.eventEmitter?.emit({
+        type: "task.created",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: {
+          task_id: task.id,
+          title: task.title,
+          task_type: task.type,
+          file_path: options.filePath
+        }
+      });
+    }
+  }
+  return output;
+}
+
+// src/planning/capacity.ts
+function toDate(value) {
+  if (value instanceof Date) return new Date(value.getTime());
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  if (Number.isNaN(parsed.valueOf())) {
+    throw new Error(`Invalid date value '${value}'.`);
+  }
+  return parsed;
+}
+function isoDate(value) {
+  return value.toISOString().slice(0, 10);
+}
+function startOfWeek(date) {
+  const copy = new Date(date.getTime());
+  const day = copy.getUTCDay();
+  const offset = day === 0 ? -6 : 1 - day;
+  copy.setUTCDate(copy.getUTCDate() + offset);
+  copy.setUTCHours(0, 0, 0, 0);
+  return copy;
+}
+function endOfWeek(date) {
+  const start = startOfWeek(date);
+  const end = new Date(start.getTime());
+  end.setUTCDate(end.getUTCDate() + 6);
+  end.setUTCHours(0, 0, 0, 0);
+  return end;
+}
+function addDays(date, days) {
+  const next = new Date(date.getTime());
+  next.setUTCDate(next.getUTCDate() + days);
+  return next;
+}
+function isBusinessDay(date) {
+  const day = date.getUTCDay();
+  return day >= 1 && day <= 5;
+}
+function overlapBusinessDays(from, to, weekStart, weekEnd) {
+  const start = from > weekStart ? from : weekStart;
+  const end = to < weekEnd ? to : weekEnd;
+  if (start > end) return 0;
+  let count = 0;
+  const cursor = new Date(start.getTime());
+  while (cursor <= end) {
+    if (isBusinessDay(cursor)) {
+      count += 1;
+    }
+    cursor.setUTCDate(cursor.getUTCDate() + 1);
+  }
+  return count;
+}
+function clampPercent(input) {
+  if (!Number.isFinite(input)) return 0;
+  return Math.min(100, Math.max(0, Number(input)));
+}
+function normalizeTrackKey(input) {
+  return input.trim().toLowerCase();
+}
+function normalizeAgentKey(input) {
+  return input.trim().toLowerCase();
+}
+function simplifiedTrackKeyFromProfile(profileId) {
+  const lower = profileId.toLowerCase();
+  if (lower.endsWith("_team")) return lower.slice(0, -5);
+  if (lower.endsWith("-team")) return lower.slice(0, -5);
+  if (lower.endsWith("_cluster")) return lower.slice(0, -8);
+  if (lower.endsWith("-cluster")) return lower.slice(0, -8);
+  return null;
+}
+function valuesOfResources(resources) {
+  if (Array.isArray(resources)) return resources;
+  return [...resources.values()];
+}
+function selectedProfiles(delivery, resources) {
+  if (!delivery.capacity_profiles || delivery.capacity_profiles.length === 0) {
+    return resources;
+  }
+  const wanted = new Set(delivery.capacity_profiles.map((id) => id.toLowerCase()));
+  return resources.filter((profile) => wanted.has(profile.id.toLowerCase()));
+}
+function selectedHumanProfiles(delivery, resources) {
+  return selectedProfiles(delivery, resources).filter((profile) => profile.type === "human");
+}
+function dailyHours(memberHoursPerWeek) {
+  return memberHoursPerWeek / 5;
+}
+function effective_weekly_hours(profile, week_start, week_end) {
+  const weekStart = toDate(week_start);
+  const weekEnd = toDate(week_end);
+  let gross = 0;
+  for (const member of profile.members) {
+    const baseHours = member.hours_per_week ?? profile.defaults?.hours_per_week ?? 0;
+    let available = baseHours;
+    for (const window of member.availability ?? []) {
+      const from = toDate(window.from);
+      const to = toDate(window.to);
+      const overlapDays = overlapBusinessDays(from, to, weekStart, weekEnd);
+      if (overlapDays <= 0) continue;
+      const unavailablePerDay = Math.max(0, dailyHours(baseHours) - Math.max(0, window.hours_per_day));
+      available -= overlapDays * unavailablePerDay;
+    }
+    gross += Math.max(0, available);
+  }
+  const meetings = clampPercent(profile.overhead?.meetings_percent);
+  const contextSwitch = clampPercent(profile.overhead?.context_switch_percent);
+  const meetingFactor = 1 - meetings / 100;
+  const contextFactor = 1 - contextSwitch / 100;
+  return gross * meetingFactor * contextFactor;
+}
+function effective_ai_tokens_per_day(profile) {
+  if (profile.type !== "ai") return 0;
+  return profile.agents.reduce((sum, agent) => sum + Math.max(0, agent.token_limit_per_day ?? 0), 0);
+}
+function ai_tokens_per_agent(profile) {
+  if (profile.type !== "ai") return [];
+  return profile.agents.map((agent) => ({
+    id: normalizeAgentKey(agent.id),
+    limit: Math.max(0, agent.token_limit_per_day ?? 0)
+  }));
+}
+function addSlot(slots, trackId, week, hours) {
+  const key = normalizeTrackKey(trackId);
+  const byWeek = slots.get(key) ?? /* @__PURE__ */ new Map();
+  byWeek.set(week, (byWeek.get(week) ?? 0) + hours);
+  slots.set(key, byWeek);
+}
+function build_capacity_ledger(delivery, resources, today) {
+  const allResources = valuesOfResources(resources);
+  const start = startOfWeek(toDate(today));
+  const target = delivery.target_date ? toDate(delivery.target_date) : addDays(start, 7 * 8);
+  const finalWeekStart = startOfWeek(target);
+  const weeks = /* @__PURE__ */ new Map();
+  const slots = /* @__PURE__ */ new Map();
+  const ai_tokens = /* @__PURE__ */ new Map();
+  const ai_tokens_by_agent = /* @__PURE__ */ new Map();
+  const ai_tokens_consumed_by_agent = /* @__PURE__ */ new Map();
+  const humans = selectedHumanProfiles(delivery, allResources);
+  const selected = selectedProfiles(delivery, allResources);
+  let weekIndex = 0;
+  for (let cursor = new Date(start.getTime()); cursor <= finalWeekStart; cursor = addDays(cursor, 7), weekIndex += 1) {
+    const weekStart = new Date(cursor.getTime());
+    const weekEnd = endOfWeek(weekStart);
+    weeks.set(weekIndex, { start: isoDate(weekStart), end: isoDate(weekEnd) });
+    const totalHours = humans.reduce((sum, profile) => sum + effective_weekly_hours(profile, weekStart, weekEnd), 0);
+    addSlot(slots, "unassigned", weekIndex, totalHours);
+    for (const profile of humans) {
+      const hours = effective_weekly_hours(profile, weekStart, weekEnd);
+      addSlot(slots, profile.id, weekIndex, hours);
+      const simplified = simplifiedTrackKeyFromProfile(profile.id);
+      if (simplified) {
+        addSlot(slots, simplified, weekIndex, hours);
+      }
+    }
+  }
+  const aiProfiles = selected.filter((profile) => profile.type === "ai");
+  const defaultTokensPerDay = aiProfiles.reduce((sum, profile) => sum + effective_ai_tokens_per_day(profile), 0);
+  const tokenWindowEnd = delivery.target_date ? toDate(delivery.target_date) : addDays(start, 7 * 8);
+  for (let day = new Date(start.getTime()); day <= tokenWindowEnd; day = addDays(day, 1)) {
+    const dayKey = isoDate(day);
+    ai_tokens.set(dayKey, defaultTokensPerDay);
+    for (const profile of aiProfiles) {
+      for (const agent of ai_tokens_per_agent(profile)) {
+        const byDay = ai_tokens_by_agent.get(agent.id) ?? /* @__PURE__ */ new Map();
+        byDay.set(dayKey, (byDay.get(dayKey) ?? 0) + agent.limit);
+        ai_tokens_by_agent.set(agent.id, byDay);
+      }
+    }
+  }
+  return {
+    slots,
+    weeks,
+    ai_tokens,
+    ai_tokens_by_agent,
+    ai_tokens_consumed_by_agent
+  };
+}
+function findTrackSlots(ledger, trackId) {
+  const normalized = normalizeTrackKey(trackId ?? "unassigned");
+  return ledger.slots.get(normalized) ?? ledger.slots.get("unassigned") ?? null;
+}
+function allocate(ledger, task, start_week) {
+  const trackSlots = findTrackSlots(ledger, task.track);
+  if (!trackSlots) {
+    return { success: false, reason: "capacity_exhausted" };
+  }
+  let hoursRemaining = task_effort_hours(task);
+  let week = start_week;
+  while (hoursRemaining > 0) {
+    const available = trackSlots.get(week);
+    if (available == null) {
+      return { success: false, reason: "capacity_exhausted" };
+    }
+    const take = Math.min(hoursRemaining, available);
+    trackSlots.set(week, available - take);
+    hoursRemaining -= take;
+    if (hoursRemaining > 0) {
+      week += 1;
+    }
+  }
+  return {
+    success: true,
+    start_week,
+    end_week: week,
+    duration_weeks: week - start_week + 1
+  };
+}
+function check_wip(track, graph) {
+  if (!track) return true;
+  const limit = track.constraints?.max_concurrent_tasks;
+  if (!Number.isFinite(limit) || Number(limit) <= 0) return true;
+  let inProgressCount = 0;
+  for (const task of graph.nodes.values()) {
+    if ((task.track ?? "unassigned") !== track.id) continue;
+    if (task.status === "in_progress" || task.status === "in_review") {
+      inProgressCount += 1;
+    }
+  }
+  return inProgressCount < Number(limit);
+}
+function allocate_ai(ledger, task, day, fallback_tokens = 5e4) {
+  const tokensNeeded = task.resources?.ai_tokens ?? task.execution?.constraints?.max_tokens ?? fallback_tokens;
+  const preferredAgent = task.execution?.agent?.trim().toLowerCase();
+  const dayKey = day;
+  if (preferredAgent && ledger.ai_tokens_by_agent.size > 0) {
+    const allocated = allocate_ai_tokens(ledger, preferredAgent, tokensNeeded, dayKey);
+    if (allocated) {
+      return { success: true };
+    }
+  }
+  if (ledger.ai_tokens_by_agent.size > 0) {
+    const candidates = Array.from(ledger.ai_tokens_by_agent.keys()).sort((a, b) => a.localeCompare(b));
+    for (const agentId of candidates) {
+      if (preferredAgent && agentId === preferredAgent) continue;
+      const allocated = allocate_ai_tokens(ledger, agentId, tokensNeeded, dayKey);
+      if (allocated) {
+        return { success: true };
+      }
+    }
+  }
+  const available = ledger.ai_tokens.get(dayKey) ?? 0;
+  if (tokensNeeded > available) {
+    return { success: false, reason: "ai_capacity_exhausted" };
+  }
+  ledger.ai_tokens.set(dayKey, available - tokensNeeded);
+  return { success: true };
+}
+function allocate_ai_tokens(ledger, agent, tokens, day) {
+  const normalizedAgent = normalizeAgentKey(agent);
+  if (tokens <= 0) return true;
+  const byDay = ledger.ai_tokens_by_agent.get(normalizedAgent);
+  if (!byDay) return false;
+  const available = byDay.get(day) ?? 0;
+  if (tokens > available) return false;
+  byDay.set(day, available - tokens);
+  ledger.ai_tokens_by_agent.set(normalizedAgent, byDay);
+  const consumed = ledger.ai_tokens_consumed_by_agent.get(normalizedAgent) ?? /* @__PURE__ */ new Map();
+  consumed.set(day, (consumed.get(day) ?? 0) + tokens);
+  ledger.ai_tokens_consumed_by_agent.set(normalizedAgent, consumed);
+  const totalAvailable = ledger.ai_tokens.get(day) ?? 0;
+  ledger.ai_tokens.set(day, Math.max(0, totalAvailable - tokens));
+  return true;
+}
+function get_remaining_tokens(ledger, agent, day) {
+  const normalizedAgent = normalizeAgentKey(agent);
+  const byDay = ledger.ai_tokens_by_agent.get(normalizedAgent);
+  if (!byDay) return 0;
+  return byDay.get(day) ?? 0;
+}
+
+// src/planning/simulator.ts
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_worker_threads = require("worker_threads");
+var import_node_url = require("url");
+
+// src/planning/sampling.ts
+var DEFAULT_CONFIG2 = {
+  version: 2,
+  project: {
+    name: "COOP",
+    id: "coop"
+  },
+  defaults: {
+    task: {
+      complexity: "medium"
+    }
+  }
+};
+function sample_standard_normal(rng) {
+  let u = 0;
+  let v = 0;
+  while (u === 0) u = rng();
+  while (v === 0) v = rng();
+  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+}
+function sample_gamma(shape, rng) {
+  if (shape <= 0) {
+    throw new Error("Gamma shape must be > 0.");
+  }
+  if (shape < 1) {
+    const u = rng();
+    return sample_gamma(shape + 1, rng) * Math.pow(u, 1 / shape);
+  }
+  const d = shape - 1 / 3;
+  const c = 1 / Math.sqrt(9 * d);
+  while (true) {
+    const x = sample_standard_normal(rng);
+    const v = Math.pow(1 + c * x, 3);
+    if (v <= 0) continue;
+    const u = rng();
+    if (u < 1 - 0.0331 * Math.pow(x, 4)) {
+      return d * v;
+    }
+    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) {
+      return d * v;
+    }
+  }
+}
+function sample_beta(alpha, beta, rng) {
+  const x = sample_gamma(alpha, rng);
+  const y = sample_gamma(beta, rng);
+  return x / (x + y);
+}
+function sample_pert_beta(optimistic, expected, pessimistic, rng = Math.random) {
+  if (!Number.isFinite(optimistic) || !Number.isFinite(expected) || !Number.isFinite(pessimistic)) {
+    throw new Error("PERT inputs must be finite numbers.");
+  }
+  if (optimistic <= 0 || expected <= 0 || pessimistic <= 0) {
+    throw new Error("PERT inputs must be positive.");
+  }
+  if (optimistic > pessimistic) {
+    throw new Error("PERT optimistic must be <= pessimistic.");
+  }
+  if (optimistic === pessimistic) {
+    return optimistic;
+  }
+  const expectedClamped = Math.min(pessimistic, Math.max(optimistic, expected));
+  const range = pessimistic - optimistic;
+  const lambda = 4;
+  const alpha = 1 + lambda * ((expectedClamped - optimistic) / range);
+  const beta = 1 + lambda * ((pessimistic - expectedClamped) / range);
+  const sample = sample_beta(alpha, beta, rng);
+  return optimistic + sample * range;
+}
+function sample_task_hours(task, rng = Math.random) {
+  if (task.estimate) {
+    return sample_pert_beta(
+      task.estimate.optimistic_hours,
+      task.estimate.expected_hours,
+      task.estimate.pessimistic_hours,
+      rng
+    );
+  }
+  const base = effort_or_default(task, DEFAULT_CONFIG2);
+  const min = base * 0.7;
+  const max = base * 1.3;
+  return min + (max - min) * rng();
+}
+
+// src/planning/simulator.ts
+var DEFAULT_COMPLEXITY = "medium";
+var DEFAULT_MONTE_CARLO_WORKERS = 4;
+function asDate(value) {
+  if (value instanceof Date) return new Date(value.getTime());
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  if (Number.isNaN(parsed.valueOf())) {
+    throw new Error(`Invalid date '${value}'.`);
+  }
+  return parsed;
+}
+function isoDate2(value) {
+  return value.toISOString().slice(0, 10);
+}
+function startOfWeek2(date) {
+  const copy = new Date(date.getTime());
+  const day = copy.getUTCDay();
+  const offset = day === 0 ? -6 : 1 - day;
+  copy.setUTCDate(copy.getUTCDate() + offset);
+  copy.setUTCHours(0, 0, 0, 0);
+  return copy;
+}
+function addDays2(date, days) {
+  const out = new Date(date.getTime());
+  out.setUTCDate(out.getUTCDate() + days);
+  return out;
+}
+function addWeeks(date, weeks) {
+  return addDays2(date, weeks * 7);
+}
+function week_to_date(today, week) {
+  const origin = startOfWeek2(asDate(today));
+  const date = addDays2(origin, week * 7 + 6);
+  return isoDate2(date);
+}
+function clone_ledger(ledger) {
+  return {
+    slots: new Map(
+      Array.from(ledger.slots.entries(), ([track, byWeek]) => [track, new Map(byWeek)])
+    ),
+    weeks: new Map(ledger.weeks),
+    ai_tokens: new Map(ledger.ai_tokens),
+    ai_tokens_by_agent: new Map(
+      Array.from(ledger.ai_tokens_by_agent.entries(), ([agent, byDay]) => [agent, new Map(byDay)])
+    ),
+    ai_tokens_consumed_by_agent: new Map(
+      Array.from(ledger.ai_tokens_consumed_by_agent.entries(), ([agent, byDay]) => [
+        agent,
+        new Map(byDay)
+      ])
+    )
+  };
+}
+function normalize_track(track) {
+  return (track ?? "unassigned").trim().toLowerCase();
+}
+function find_track_slots(ledger, track) {
+  const key = normalize_track(track);
+  return ledger.slots.get(key) ?? ledger.slots.get("unassigned") ?? null;
+}
+function max_week(ledger) {
+  const keys = Array.from(ledger.weeks.keys());
+  if (keys.length === 0) return 0;
+  return Math.max(...keys);
+}
+function track_limit(trackId, graph) {
+  const limit = graph.tracks.get(trackId)?.constraints?.max_concurrent_tasks;
+  if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return limit;
+}
+function ordered_tasks(tasks, graph) {
+  const wanted = new Map(tasks.map((task) => [task.id, task]));
+  const ordered = [];
+  for (const id of graph.topological_order) {
+    const task = wanted.get(id);
+    if (task) {
+      ordered.push(task);
+    }
+  }
+  if (ordered.length !== wanted.size) {
+    const missing = Array.from(wanted.keys()).filter((id) => !ordered.some((task) => task.id === id));
+    throw new Error(`Tasks missing from graph topological order: ${missing.join(", ")}.`);
+  }
+  return ordered;
+}
+function task_with_default_complexity(task) {
+  const hasHumanHours = typeof task.resources?.human_hours === "number";
+  if (hasHumanHours || task.estimate || task.complexity) return task;
+  return {
+    ...task,
+    complexity: DEFAULT_COMPLEXITY
+  };
+}
+function sum_hours(slots) {
+  if (!slots) return 0;
+  let total = 0;
+  for (const value of slots.values()) {
+    total += value;
+  }
+  return total;
+}
+function compute_utilization(initial, current, tracks) {
+  const utilization = [];
+  for (const track of tracks) {
+    const normalized = normalize_track(track);
+    const initialSlots = find_track_slots(initial, normalized);
+    const currentSlots = find_track_slots(current, normalized);
+    const capacity = sum_hours(initialSlots ?? void 0);
+    const remaining = sum_hours(currentSlots ?? void 0);
+    const allocated = Math.max(0, capacity - remaining);
+    utilization.push({
+      track: normalized,
+      allocated_hours: allocated,
+      capacity_hours: capacity,
+      utilization: capacity > 0 ? allocated / capacity : 0
+    });
+  }
+  utilization.sort((a, b) => a.track.localeCompare(b.track));
+  return utilization;
+}
+function plan_allocation(trackSlots, effort, start_week) {
+  let hoursRemaining = effort;
+  let week = start_week;
+  while (hoursRemaining > 0) {
+    const available = trackSlots.get(week);
+    if (available == null || available <= 0) {
+      return { success: false, reason: "capacity_exhausted" };
+    }
+    hoursRemaining -= Math.min(hoursRemaining, available);
+    if (hoursRemaining > 0) {
+      week += 1;
+    }
+  }
+  return {
+    success: true,
+    start_week,
+    end_week: week,
+    duration_weeks: week - start_week + 1
+  };
+}
+function apply_allocation(trackSlots, effort, allocation) {
+  let hoursRemaining = effort;
+  for (let week = allocation.start_week; week <= allocation.end_week && hoursRemaining > 0; week += 1) {
+    const available = trackSlots.get(week) ?? 0;
+    const take = Math.min(hoursRemaining, available);
+    trackSlots.set(week, available - take);
+    hoursRemaining -= take;
+  }
+}
+function simulate_ordered_schedule(ordered, includedTaskIds, graph, delivery, today) {
+  const ledger = build_capacity_ledger(delivery, graph.resources, today);
+  const initialLedger = clone_ledger(ledger);
+  const schedule = {};
+  const wip = /* @__PURE__ */ new Map();
+  const maxWeek = max_week(ledger);
+  const tracks = /* @__PURE__ */ new Set();
+  for (const rawTask of ordered) {
+    const task = task_with_default_complexity(rawTask);
+    const track = normalize_track(task.track);
+    tracks.add(track);
+    if (task.status === "done" || task.status === "canceled") {
+      schedule[task.id] = {
+        task_id: task.id,
+        track,
+        start_week: null,
+        end_week: null,
+        already_complete: true
+      };
+      continue;
+    }
+    let earliest = 0;
+    for (const depId of task.depends_on ?? []) {
+      const depSchedule = schedule[depId];
+      if (depSchedule && typeof depSchedule.end_week === "number") {
+        earliest = Math.max(earliest, depSchedule.end_week + 1);
+        continue;
+      }
+      const depTask = graph.nodes.get(depId);
+      if (depTask && depTask.status !== "done" && depTask.status !== "canceled" && !includedTaskIds.has(depId)) {
+        return {
+          schedule,
+          projected_completion: null,
+          total_weeks: 0,
+          utilization_by_track: compute_utilization(initialLedger, ledger, /* @__PURE__ */ new Set([track])),
+          error: {
+            code: "schedule_overflow",
+            task: task.id
+          }
+        };
+      }
+    }
+    const trackSlots = find_track_slots(ledger, track);
+    const trackWip = wip.get(track) ?? /* @__PURE__ */ new Map();
+    const limit = track_limit(track, graph);
+    const effort = task_effort_hours(task);
+    let placed = false;
+    for (let week = earliest; week <= maxWeek; week += 1) {
+      const hasCapacity = (trackSlots?.get(week) ?? 0) > 0;
+      const hasWipRoom = (trackWip.get(week) ?? 0) < limit;
+      if (!hasCapacity || !hasWipRoom || !trackSlots) continue;
+      const allocation = plan_allocation(trackSlots, effort, week);
+      if (!allocation.success || allocation.start_week == null || allocation.end_week == null) {
+        continue;
+      }
+      let violatesWip = false;
+      for (let w = allocation.start_week; w <= allocation.end_week; w += 1) {
+        const nextWip = (trackWip.get(w) ?? 0) + 1;
+        if (nextWip > limit) {
+          violatesWip = true;
+          break;
+        }
+      }
+      if (violatesWip) continue;
+      apply_allocation(trackSlots, effort, {
+        start_week: allocation.start_week,
+        end_week: allocation.end_week
+      });
+      schedule[task.id] = {
+        task_id: task.id,
+        track,
+        start_week: allocation.start_week,
+        end_week: allocation.end_week
+      };
+      for (let w = allocation.start_week; w <= allocation.end_week; w += 1) {
+        trackWip.set(w, (trackWip.get(w) ?? 0) + 1);
+      }
+      wip.set(track, trackWip);
+      placed = true;
+      break;
+    }
+    if (!placed) {
+      return {
+        schedule,
+        projected_completion: null,
+        total_weeks: 0,
+        utilization_by_track: compute_utilization(initialLedger, ledger, /* @__PURE__ */ new Set([track])),
+        error: {
+          code: "schedule_overflow",
+          task: task.id
+        }
+      };
+    }
+  }
+  let latestEnd = -1;
+  for (const entry of Object.values(schedule)) {
+    if (entry.already_complete) continue;
+    if (typeof entry.end_week === "number") {
+      latestEnd = Math.max(latestEnd, entry.end_week);
+    }
+  }
+  return {
+    schedule,
+    projected_completion: latestEnd >= 0 ? week_to_date(today, latestEnd) : isoDate2(asDate(today)),
+    total_weeks: latestEnd >= 0 ? latestEnd + 1 : 0,
+    utilization_by_track: compute_utilization(initialLedger, ledger, tracks)
+  };
+}
+function simulate_schedule(tasks, graph, delivery, today) {
+  const ordered = ordered_tasks(tasks, graph);
+  return simulate_ordered_schedule(ordered, new Set(ordered.map((task) => task.id)), graph, delivery, today);
+}
+function percentile(sorted, ratio) {
+  if (sorted.length === 0) return Number.NaN;
+  const index = Math.min(sorted.length - 1, Math.max(0, Math.floor((sorted.length - 1) * ratio)));
+  return sorted[index] ?? Number.NaN;
+}
+function mean(values) {
+  if (values.length === 0) return Number.NaN;
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function stddev(values, avg) {
+  if (values.length === 0) return Number.NaN;
+  const variance = values.reduce((sum, value) => sum + Math.pow(value - avg, 2), 0) / values.length;
+  return Math.sqrt(variance);
+}
+function toDayOffset(origin, value) {
+  const target = asDate(value);
+  return Math.round((target.getTime() - origin.getTime()) / (24 * 60 * 60 * 1e3));
+}
+function fromDayOffset(origin, offset) {
+  return isoDate2(addDays2(origin, offset));
+}
+function resolve_scoped_tasks(delivery, graph) {
+  const include = new Set(delivery.scope.include);
+  for (const excluded of delivery.scope.exclude) {
+    include.delete(excluded);
+  }
+  const ordered = [];
+  for (const taskId of graph.topological_order) {
+    if (!include.has(taskId)) continue;
+    const task = graph.nodes.get(taskId);
+    if (!task) continue;
+    if (task.status === "done" || task.status === "canceled") continue;
+    ordered.push(task);
+  }
+  return ordered;
+}
+function sample_ordered_tasks(tasks, rng) {
+  const sampled = new Array(tasks.length);
+  for (let i = 0; i < tasks.length; i += 1) {
+    const task = tasks[i];
+    sampled[i] = {
+      ...task,
+      resources: {
+        ...task.resources ?? {},
+        human_hours: sample_task_hours(task, rng)
+      }
+    };
+  }
+  return sampled;
+}
+function create_seeded_rng(seed) {
+  let state = seed >>> 0 || 1831565813;
+  return () => {
+    state = state + 1831565813 | 0;
+    let t = Math.imul(state ^ state >>> 15, 1 | state);
+    t ^= t + Math.imul(t ^ t >>> 7, 61 | t);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function normalize_seed(seed) {
+  if (typeof seed === "number" && Number.isFinite(seed)) {
+    return Math.trunc(seed) >>> 0;
+  }
+  return Math.floor(Math.random() * 4294967296) >>> 0;
+}
+function derive_iteration_seed(seed, iterationIndex) {
+  return (seed ^ Math.imul(iterationIndex + 1, 2654435761)) >>> 0;
+}
+function run_monte_carlo_chunk(delivery, graph, options) {
+  const scopedTasks = resolve_scoped_tasks(delivery, graph);
+  if (scopedTasks.length === 0) {
+    return Array.from({ length: options.iterations }, () => 0);
+  }
+  const includedTaskIds = new Set(scopedTasks.map((task) => task.id));
+  const completionOffsets = [];
+  const startIndex = options.start_index ?? 0;
+  const seed = normalize_seed(options.seed);
+  for (let i = 0; i < options.iterations; i += 1) {
+    const rng = options.rng ?? create_seeded_rng(derive_iteration_seed(seed, startIndex + i));
+    const sampledTasks = sample_ordered_tasks(scopedTasks, rng);
+    const simulated = simulate_ordered_schedule(sampledTasks, includedTaskIds, graph, delivery, options.today);
+    if (simulated.error) {
+      continue;
+    }
+    const offset = simulated.total_weeks > 0 ? (simulated.total_weeks - 1) * 7 + 6 : 0;
+    completionOffsets.push(offset);
+  }
+  if (completionOffsets.length === 0 && scopedTasks.length > 0) {
+    return [];
+  }
+  return completionOffsets;
+}
+function buildHistogram(offsets, origin, total) {
+  if (offsets.length === 0 || total <= 0) return [];
+  const buckets = /* @__PURE__ */ new Map();
+  for (const offset of offsets) {
+    const week = Math.max(0, Math.floor(offset / 7));
+    buckets.set(week, (buckets.get(week) ?? 0) + 1);
+  }
+  return Array.from(buckets.entries()).sort((a, b) => a[0] - b[0]).map(([week, count]) => ({
+    week_index: week,
+    start_date: isoDate2(addWeeks(origin, week)),
+    end_date: isoDate2(addDays2(addWeeks(origin, week + 1), -1)),
+    count,
+    probability: count / total
+  }));
+}
+function build_monte_carlo_result(offsets, origin, iterations, targetOffset) {
+  const sorted = [...offsets].sort((a, b) => a - b);
+  const p50Value = percentile(sorted, 0.5);
+  const p75Value = percentile(sorted, 0.75);
+  const p85Value = percentile(sorted, 0.85);
+  const p95Value = percentile(sorted, 0.95);
+  const avg = mean(sorted);
+  const sigma = stddev(sorted, avg);
+  let probabilityByTarget = null;
+  if (targetOffset != null && sorted.length > 0) {
+    let onTime = 0;
+    for (const offset of sorted) {
+      if (offset <= targetOffset) {
+        onTime += 1;
+      } else {
+        break;
+      }
+    }
+    probabilityByTarget = onTime / sorted.length;
+  }
+  return {
+    iterations,
+    successful_iterations: sorted.length,
+    p50: Number.isFinite(p50Value) ? fromDayOffset(origin, p50Value) : null,
+    p75: Number.isFinite(p75Value) ? fromDayOffset(origin, p75Value) : null,
+    p85: Number.isFinite(p85Value) ? fromDayOffset(origin, p85Value) : null,
+    p95: Number.isFinite(p95Value) ? fromDayOffset(origin, p95Value) : null,
+    mean_date: Number.isFinite(avg) ? fromDayOffset(origin, Math.round(avg)) : null,
+    stddev_days: Number.isFinite(sigma) ? sigma : 0,
+    probability_by_target: probabilityByTarget,
+    histogram: buildHistogram(sorted, origin, sorted.length)
+  };
+}
+function default_worker_count(workers) {
+  if (typeof workers === "number" && Number.isInteger(workers) && workers > 0) {
+    return workers;
+  }
+  return DEFAULT_MONTE_CARLO_WORKERS;
+}
+function current_module_url() {
+  try {
+    return (0, eval)("import.meta.url");
+  } catch {
+    if (typeof __filename === "string") {
+      return (0, import_node_url.pathToFileURL)(__filename).href;
+    }
+    return null;
+  }
+}
+function resolve_worker_url() {
+  const moduleUrl = current_module_url();
+  if (!moduleUrl) {
+    return null;
+  }
+  if (moduleUrl.endsWith(".ts")) {
+    return null;
+  }
+  const candidates = [
+    new URL("./planning/monte-carlo-worker.js", moduleUrl),
+    new URL("./planning/monte-carlo-worker.cjs", moduleUrl),
+    new URL("./monte-carlo-worker.js", moduleUrl),
+    new URL("./monte-carlo-worker.cjs", moduleUrl)
+  ];
+  for (const candidate of candidates) {
+    if (import_node_fs10.default.existsSync((0, import_node_url.fileURLToPath)(candidate))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolve_worker_exec_argv(workerUrl) {
+  void workerUrl;
+  return void 0;
+}
+function should_use_worker_threads(iterations, options, workerUrl) {
+  return Boolean(workerUrl) && !options.rng && iterations > 1e3 && default_worker_count(options.workers) > 1;
+}
+async function run_monte_carlo_in_workers(delivery, graph, options) {
+  const workerUrl = resolve_worker_url();
+  if (!workerUrl) {
+    return run_monte_carlo_chunk(delivery, graph, options);
+  }
+  const desiredWorkers = Math.min(default_worker_count(options.workers), options.iterations, import_node_os.default.availableParallelism());
+  if (desiredWorkers <= 1) {
+    return run_monte_carlo_chunk(delivery, graph, options);
+  }
+  const execArgv = resolve_worker_exec_argv(workerUrl);
+  const baseChunk = Math.floor(options.iterations / desiredWorkers);
+  const remainder = options.iterations % desiredWorkers;
+  let startIndex = 0;
+  const jobs = [];
+  for (let index = 0; index < desiredWorkers; index += 1) {
+    const chunkIterations = baseChunk + (index < remainder ? 1 : 0);
+    if (chunkIterations <= 0) continue;
+    const payload = {
+      delivery,
+      graph,
+      today: typeof options.today === "string" ? options.today : isoDate2(asDate(options.today)),
+      iterations: chunkIterations,
+      start_index: startIndex,
+      seed: options.seed
+    };
+    startIndex += chunkIterations;
+    jobs.push(
+      new Promise((resolve, reject) => {
+        const worker = new import_node_worker_threads.Worker(workerUrl, {
+          workerData: payload,
+          execArgv
+        });
+        worker.once("message", (message) => {
+          resolve(message);
+        });
+        worker.once("error", reject);
+        worker.once("exit", (code) => {
+          if (code !== 0) {
+            reject(new Error(`Monte Carlo worker exited with code ${code}.`));
+          }
+        });
+      })
+    );
+  }
+  const chunks = await Promise.all(jobs);
+  return chunks.flat();
+}
+async function monte_carlo_forecast(delivery, graph, options = {}) {
+  const iterations = typeof options.iterations === "number" && Number.isInteger(options.iterations) && options.iterations > 0 ? options.iterations : 1e4;
+  const today = options.today ?? /* @__PURE__ */ new Date();
+  const origin = startOfWeek2(asDate(today));
+  const seed = normalize_seed(options.seed);
+  const targetOffset = delivery.target_date ? toDayOffset(origin, delivery.target_date) : null;
+  const workerUrl = resolve_worker_url();
+  const completionOffsets = should_use_worker_threads(iterations, options, workerUrl) ? await run_monte_carlo_in_workers(delivery, graph, {
+    iterations,
+    today,
+    seed,
+    workers: options.workers
+  }) : run_monte_carlo_chunk(delivery, graph, {
+    iterations,
+    today,
+    seed,
+    rng: options.rng
+  });
+  return build_monte_carlo_result(completionOffsets, origin, iterations, targetOffset);
+}
+
+// src/planning/feasibility.ts
+var DEFAULT_ESTIMATION_CONFIG = {
+  version: 2,
+  project: {
+    name: "COOP",
+    id: "coop"
+  },
+  defaults: {
+    task: {
+      complexity: "medium"
+    }
+  }
+};
+function asDate2(value) {
+  if (value instanceof Date) return new Date(value.getTime());
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  if (Number.isNaN(parsed.valueOf())) {
+    throw new Error(`Invalid date '${value}'.`);
+  }
+  return parsed;
+}
+function normalize_track2(track) {
+  return (track ?? "unassigned").trim().toLowerCase();
+}
+function isBusinessDay2(date) {
+  const day = date.getUTCDay();
+  return day >= 1 && day <= 5;
+}
+function business_days(from, to) {
+  const start = asDate2(from);
+  const end = asDate2(to);
+  if (start.getTime() === end.getTime()) return 0;
+  const forward = start.getTime() < end.getTime();
+  const low = forward ? start : end;
+  const high = forward ? end : start;
+  let count = 0;
+  const cursor = new Date(low.getTime());
+  while (cursor < high) {
+    if (isBusinessDay2(cursor)) count += 1;
+    cursor.setUTCDate(cursor.getUTCDate() + 1);
+  }
+  return forward ? count : -count;
+}
+function sumTaskEffort(tasks) {
+  let total = 0;
+  for (const task of tasks) {
+    total += effort_or_default(task, DEFAULT_ESTIMATION_CONFIG);
+  }
+  return total;
+}
+function sumPert(tasks) {
+  let mean3 = 0;
+  let variance = 0;
+  for (const task of tasks) {
+    if (task.estimate) {
+      mean3 += pert_hours(task.estimate);
+      const sigma = pert_stddev(task.estimate);
+      variance += sigma * sigma;
+    } else {
+      mean3 += effort_or_default(task, DEFAULT_ESTIMATION_CONFIG);
+    }
+  }
+  return {
+    mean: mean3,
+    stddev: Math.sqrt(variance)
+  };
+}
+function find_track_slots_hours(slots, track) {
+  const direct = slots.get(track);
+  if (direct) {
+    let sum2 = 0;
+    for (const value of direct.values()) sum2 += value;
+    return sum2;
+  }
+  const fallback = slots.get("unassigned");
+  if (!fallback) return 0;
+  let sum = 0;
+  for (const value of fallback.values()) sum += value;
+  return sum;
+}
+function track_effort(tasks) {
+  const out = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const track = normalize_track2(task.track);
+    out.set(track, (out.get(track) ?? 0) + effort_or_default(task, DEFAULT_ESTIMATION_CONFIG));
+  }
+  return out;
+}
+function analyze_feasibility(deliveryId, graph, today) {
+  const delivery = graph.deliveries.get(deliveryId);
+  if (!delivery) {
+    throw new Error(`Delivery '${deliveryId}' not found.`);
+  }
+  const include = new Set(delivery.scope.include);
+  for (const excluded of delivery.scope.exclude) {
+    include.delete(excluded);
+  }
+  const scope_tasks = Array.from(include).map((id) => graph.nodes.get(id)).filter((task) => Boolean(task));
+  const subgraph = extract_subgraph(
+    graph,
+    scope_tasks.map((task) => task.id)
+  );
+  const external_deps = find_external_dependencies(subgraph, graph);
+  const done_tasks = scope_tasks.filter((task) => task.status === "done");
+  const remaining_tasks = scope_tasks.filter(
+    (task) => task.status !== "done" && task.status !== "canceled"
+  );
+  const total_effort = sumTaskEffort(remaining_tasks);
+  const pert = sumPert(remaining_tasks);
+  const cpm = compute_critical_path(delivery, graph);
+  const ledger = build_capacity_ledger(delivery, graph.resources, today);
+  const simulation = simulate_schedule(remaining_tasks, graph, delivery, today);
+  const tracks = new Set(remaining_tasks.map((task) => normalize_track2(task.track)));
+  const capacity_by_track = {};
+  for (const track of tracks) {
+    capacity_by_track[track] = find_track_slots_hours(ledger.slots, track);
+  }
+  const total_capacity = Object.values(capacity_by_track).reduce((sum, value) => sum + value, 0);
+  const budget_hours = delivery.budget.engineering_hours ?? Number.POSITIVE_INFINITY;
+  const budget_cost = delivery.budget.cost_usd ?? Number.POSITIVE_INFINITY;
+  const total_cost = remaining_tasks.reduce((sum, task) => sum + (task.resources?.cost_usd ?? 0), 0);
+  let feasible = true;
+  const risks = [];
+  if (total_effort > budget_hours) {
+    feasible = false;
+    risks.push({
+      type: "budget_exceeded",
+      message: `Required ${total_effort.toFixed(1)}h exceeds budget ${budget_hours.toFixed(1)}h.`,
+      overage_hours: total_effort - budget_hours
+    });
+  }
+  if (total_cost > budget_cost) {
+    feasible = false;
+    risks.push({
+      type: "cost_budget_exceeded",
+      message: `Required $${total_cost.toFixed(2)} exceeds budget $${budget_cost.toFixed(2)}.`,
+      overage_cost_usd: total_cost - budget_cost
+    });
+  }
+  if (total_effort > total_capacity) {
+    feasible = false;
+    risks.push({
+      type: "capacity_exceeded",
+      message: `Required ${total_effort.toFixed(1)}h exceeds capacity ${total_capacity.toFixed(1)}h.`,
+      overage_hours: total_effort - total_capacity
+    });
+  }
+  if (simulation.error) {
+    feasible = false;
+    risks.push({
+      type: "schedule_overflow",
+      message: `Simulation overflow while scheduling task ${simulation.error.task}.`,
+      tasks: [simulation.error.task]
+    });
+  }
+  if (delivery.target_date && simulation.projected_completion && simulation.projected_completion > delivery.target_date) {
+    feasible = false;
+    risks.push({
+      type: "schedule_exceeded",
+      message: `Projected ${simulation.projected_completion} exceeds target ${delivery.target_date}.`,
+      overage_days: business_days(delivery.target_date, simulation.projected_completion)
+    });
+  }
+  const effort_by_track = track_effort(remaining_tasks);
+  for (const [track, effort] of effort_by_track.entries()) {
+    const capacity = capacity_by_track[track] ?? 0;
+    if (capacity <= 0) continue;
+    const utilization = effort / capacity;
+    if (utilization > 0.85) {
+      risks.push({
+        type: "high_utilization",
+        message: `Track '${track}' at ${Math.round(utilization * 100)}% utilization.`,
+        track,
+        utilization
+      });
+    }
+  }
+  if (external_deps.length > 0) {
+    risks.push({
+      type: "external_dependencies",
+      message: `${external_deps.length} tasks depend on work outside this delivery.`,
+      tasks: external_deps
+    });
+  }
+  const buffer_days = delivery.target_date && simulation.projected_completion ? business_days(simulation.projected_completion, delivery.target_date) : null;
+  return {
+    delivery: deliveryId,
+    status: feasible ? "FEASIBLE" : "NOT_FEASIBLE",
+    risks,
+    summary: {
+      total_tasks: scope_tasks.length,
+      completed: done_tasks.length,
+      remaining: remaining_tasks.length,
+      effort_hours: {
+        required: total_effort,
+        budget: budget_hours
+      },
+      capacity_hours: {
+        available: total_capacity,
+        by_track: capacity_by_track
+      },
+      pert,
+      dates: {
+        target: delivery.target_date,
+        projected: simulation.projected_completion,
+        buffer_days
+      },
+      critical_path: cpm.critical_path,
+      critical_path_hours: cpm.project_duration_hours
+    },
+    simulation
+  };
+}
+
+// src/planning/risk-detector.ts
+function toIsoTimestamp(now) {
+  if (typeof now === "string") {
+    if (now.includes("T")) return now;
+    return `${now}T00:00:00.000Z`;
+  }
+  const date = now instanceof Date ? now : /* @__PURE__ */ new Date();
+  return date.toISOString();
+}
+function detect_delivery_risks(delivery, graph, velocity, options = {}) {
+  const today = options.today ?? /* @__PURE__ */ new Date();
+  const feasibility = analyze_feasibility(delivery.id, graph, today);
+  const criticalPath = compute_critical_path(delivery, graph);
+  const risks = [];
+  if (velocity.trend === "decelerating" && (feasibility.status === "NOT_FEASIBLE" || feasibility.summary.dates.target && feasibility.summary.dates.projected && feasibility.summary.dates.projected > feasibility.summary.dates.target || typeof feasibility.summary.dates.buffer_days === "number" && feasibility.summary.dates.buffer_days < 0)) {
+    risks.push({
+      type: "behind_schedule",
+      message: `Delivery '${delivery.id}' is slipping while velocity is decelerating.`
+    });
+  }
+  for (const utilization of feasibility.simulation.utilization_by_track) {
+    if (utilization.utilization >= 0.9) {
+      risks.push({
+        type: "capacity_crunch",
+        message: `Track '${utilization.track}' is at ${Math.round(utilization.utilization * 100)}% utilization.`,
+        track: utilization.track
+      });
+    }
+  }
+  const notStarted = criticalPath.critical_path.filter((taskId) => {
+    const task = graph.nodes.get(taskId);
+    return task?.status === "todo" || task?.status === "blocked";
+  });
+  if (notStarted.length > 0) {
+    risks.push({
+      type: "critical_path_not_started",
+      message: `${notStarted.length} critical path tasks are not started.`,
+      task_ids: notStarted
+    });
+  }
+  const highRiskCritical = criticalPath.critical_path.filter((taskId) => {
+    const task = graph.nodes.get(taskId);
+    return task?.risk?.level === "high" || task?.risk?.level === "critical";
+  });
+  if (highRiskCritical.length > 0) {
+    risks.push({
+      type: "high_risk_critical_path",
+      message: `${highRiskCritical.length} high-risk tasks are on the critical path.`,
+      task_ids: highRiskCritical
+    });
+  }
+  if (risks.length > 0) {
+    options.eventEmitter?.emit({
+      type: "delivery.at_risk",
+      timestamp: toIsoTimestamp(today),
+      payload: {
+        delivery_id: delivery.id,
+        status: feasibility.status,
+        risks: risks.map((risk) => risk.message)
+      }
+    });
+  }
+  return risks;
+}
+
+// src/planning/scorer.ts
+var DEFAULT_SCORE_WEIGHTS = {
+  priority: {
+    p0: 100,
+    p1: 75,
+    p2: 50,
+    p3: 25
+  },
+  urgency: {
+    days_7: 40,
+    days_14: 25,
+    days_28: 10
+  },
+  dependency_unlock: {
+    gte_5: 30,
+    gte_3: 20,
+    gte_1: 10,
+    transitive_cap: 15
+  },
+  critical_path: 35,
+  determinism: {
+    high: 30,
+    medium: 15,
+    low: 0,
+    experimental: -10
+  },
+  executor_fit: {
+    match: 15,
+    mismatch: -15,
+    ci_match: 10
+  },
+  type: {
+    bug: 10,
+    spike: 5,
+    feature: 0,
+    chore: 0,
+    epic: 0
+  },
+  complexity_penalty: {
+    trivial: 0,
+    small: 0,
+    medium: -10,
+    large: -25,
+    unknown: -40
+  },
+  risk_penalty: {
+    low: 0,
+    medium: -10,
+    high: -25,
+    critical: -40
+  }
+};
+function asDate3(value) {
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  if (Number.isNaN(parsed.valueOf())) {
+    throw new Error(`Invalid date '${value}'.`);
+  }
+  return parsed;
+}
+function calendar_days(today, target) {
+  const from = asDate3(today);
+  const to = asDate3(target);
+  const millis = to.getTime() - from.getTime();
+  return Math.floor(millis / (1e3 * 60 * 60 * 24));
+}
+function toMap(deliveries) {
+  if (!deliveries) return /* @__PURE__ */ new Map();
+  if (deliveries instanceof Map) return deliveries;
+  return new Map(deliveries.map((delivery) => [delivery.id, delivery]));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function number_or_default(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function configured_weights(config) {
+  const rawWeights = config?.scheduling?.weights;
+  if (!isRecord(rawWeights)) {
+    return DEFAULT_SCORE_WEIGHTS;
+  }
+  const priority = isRecord(rawWeights.priority) ? rawWeights.priority : {};
+  const urgency = isRecord(rawWeights.urgency) ? rawWeights.urgency : {};
+  const dependency_unlock = isRecord(rawWeights.dependency_unlock) ? rawWeights.dependency_unlock : {};
+  const determinism = isRecord(rawWeights.determinism) ? rawWeights.determinism : {};
+  const executor_fit = isRecord(rawWeights.executor_fit) ? rawWeights.executor_fit : {};
+  const type = isRecord(rawWeights.type) ? rawWeights.type : {};
+  const complexity_penalty2 = isRecord(rawWeights.complexity_penalty) ? rawWeights.complexity_penalty : {};
+  const risk_penalty2 = isRecord(rawWeights.risk_penalty) ? rawWeights.risk_penalty : {};
+  return {
+    priority: {
+      p0: number_or_default(priority.p0, DEFAULT_SCORE_WEIGHTS.priority.p0),
+      p1: number_or_default(priority.p1, DEFAULT_SCORE_WEIGHTS.priority.p1),
+      p2: number_or_default(priority.p2, DEFAULT_SCORE_WEIGHTS.priority.p2),
+      p3: number_or_default(priority.p3, DEFAULT_SCORE_WEIGHTS.priority.p3)
+    },
+    urgency: {
+      days_7: number_or_default(urgency.days_7, DEFAULT_SCORE_WEIGHTS.urgency.days_7),
+      days_14: number_or_default(urgency.days_14, DEFAULT_SCORE_WEIGHTS.urgency.days_14),
+      days_28: number_or_default(urgency.days_28, DEFAULT_SCORE_WEIGHTS.urgency.days_28)
+    },
+    dependency_unlock: {
+      gte_5: number_or_default(dependency_unlock.gte_5, DEFAULT_SCORE_WEIGHTS.dependency_unlock.gte_5),
+      gte_3: number_or_default(dependency_unlock.gte_3, DEFAULT_SCORE_WEIGHTS.dependency_unlock.gte_3),
+      gte_1: number_or_default(dependency_unlock.gte_1, DEFAULT_SCORE_WEIGHTS.dependency_unlock.gte_1),
+      transitive_cap: number_or_default(
+        dependency_unlock.transitive_cap,
+        DEFAULT_SCORE_WEIGHTS.dependency_unlock.transitive_cap
+      )
+    },
+    critical_path: number_or_default(rawWeights.critical_path, DEFAULT_SCORE_WEIGHTS.critical_path),
+    determinism: {
+      high: number_or_default(determinism.high, DEFAULT_SCORE_WEIGHTS.determinism.high),
+      medium: number_or_default(determinism.medium, DEFAULT_SCORE_WEIGHTS.determinism.medium),
+      low: number_or_default(determinism.low, DEFAULT_SCORE_WEIGHTS.determinism.low),
+      experimental: number_or_default(determinism.experimental, DEFAULT_SCORE_WEIGHTS.determinism.experimental)
+    },
+    executor_fit: {
+      match: number_or_default(executor_fit.match, DEFAULT_SCORE_WEIGHTS.executor_fit.match),
+      mismatch: number_or_default(executor_fit.mismatch, DEFAULT_SCORE_WEIGHTS.executor_fit.mismatch),
+      ci_match: number_or_default(executor_fit.ci_match, DEFAULT_SCORE_WEIGHTS.executor_fit.ci_match)
+    },
+    type: {
+      bug: number_or_default(type.bug, DEFAULT_SCORE_WEIGHTS.type.bug),
+      spike: number_or_default(type.spike, DEFAULT_SCORE_WEIGHTS.type.spike),
+      feature: number_or_default(type.feature, DEFAULT_SCORE_WEIGHTS.type.feature),
+      chore: number_or_default(type.chore, DEFAULT_SCORE_WEIGHTS.type.chore),
+      epic: number_or_default(type.epic, DEFAULT_SCORE_WEIGHTS.type.epic)
+    },
+    complexity_penalty: {
+      trivial: number_or_default(complexity_penalty2.trivial, DEFAULT_SCORE_WEIGHTS.complexity_penalty.trivial),
+      small: number_or_default(complexity_penalty2.small, DEFAULT_SCORE_WEIGHTS.complexity_penalty.small),
+      medium: number_or_default(complexity_penalty2.medium, DEFAULT_SCORE_WEIGHTS.complexity_penalty.medium),
+      large: number_or_default(complexity_penalty2.large, DEFAULT_SCORE_WEIGHTS.complexity_penalty.large),
+      unknown: number_or_default(complexity_penalty2.unknown, DEFAULT_SCORE_WEIGHTS.complexity_penalty.unknown)
+    },
+    risk_penalty: {
+      low: number_or_default(risk_penalty2.low, DEFAULT_SCORE_WEIGHTS.risk_penalty.low),
+      medium: number_or_default(risk_penalty2.medium, DEFAULT_SCORE_WEIGHTS.risk_penalty.medium),
+      high: number_or_default(risk_penalty2.high, DEFAULT_SCORE_WEIGHTS.risk_penalty.high),
+      critical: number_or_default(risk_penalty2.critical, DEFAULT_SCORE_WEIGHTS.risk_penalty.critical)
+    }
+  };
+}
+function unresolved_dependencies(task, graph) {
+  return (task.depends_on ?? []).filter((depId) => {
+    const dep = graph.nodes.get(depId);
+    return !dep || dep.status !== "done" && dep.status !== "canceled";
+  });
+}
+function priority_weight(task, config) {
+  const weights = configured_weights(config);
+  const priority = task.priority ?? "p2";
+  return weights.priority[priority];
+}
+function urgency_weight(task, deliveries, today, config) {
+  if (!task.delivery) return 0;
+  const delivery = toMap(deliveries).get(task.delivery);
+  if (!delivery?.target_date) return 0;
+  const weights = configured_weights(config);
+  const daysRemaining = calendar_days(today, delivery.target_date);
+  if (daysRemaining < 7) return weights.urgency.days_7;
+  if (daysRemaining < 14) return weights.urgency.days_14;
+  if (daysRemaining < 28) return weights.urgency.days_28;
+  return 0;
+}
+function dependency_unlock_weight(taskId, graph, config) {
+  const weights = configured_weights(config);
+  const reverse = graph.reverse.get(taskId) ?? /* @__PURE__ */ new Set();
+  const directBlocked = [];
+  for (const dependentId of reverse) {
+    const dependent = graph.nodes.get(dependentId);
+    if (!dependent) continue;
+    if (compute_readiness(dependent, graph) !== "blocked") continue;
+    const unresolved = unresolved_dependencies(dependent, graph);
+    if (unresolved.length === 1 && unresolved[0] === taskId) {
+      directBlocked.push(dependentId);
+    }
+  }
+  const directCount = directBlocked.length;
+  let directWeight = 0;
+  if (directCount >= 5) {
+    directWeight = weights.dependency_unlock.gte_5;
+  } else if (directCount >= 3) {
+    directWeight = weights.dependency_unlock.gte_3;
+  } else if (directCount >= 1) {
+    directWeight = weights.dependency_unlock.gte_1;
+  }
+  const transitive = /* @__PURE__ */ new Set();
+  for (const directId of directBlocked) {
+    const reverseDepth2 = graph.reverse.get(directId) ?? /* @__PURE__ */ new Set();
+    for (const transitiveId of reverseDepth2) {
+      const task = graph.nodes.get(transitiveId);
+      if (!task) continue;
+      if (compute_readiness(task, graph) === "blocked") {
+        transitive.add(transitiveId);
+      }
+    }
+  }
+  const transitiveWeight = Math.min(transitive.size * 2, weights.dependency_unlock.transitive_cap);
+  return directWeight + transitiveWeight;
+}
+function critical_path_weight(taskId, cpm, config) {
+  if (!cpm) return 0;
+  const weights = configured_weights(config);
+  const isCritical = cpm.critical_path.includes(taskId);
+  return isCritical ? weights.critical_path : 0;
+}
+function determinism_weight(task, config) {
+  const weights = configured_weights(config);
+  const defaultDeterminism = config?.defaults?.task?.determinism ?? "medium";
+  const determinism = task.determinism ?? defaultDeterminism;
+  return weights.determinism[determinism];
+}
+function executor_fit_weight(task, targetExecutor, config) {
+  if (!targetExecutor) return 0;
+  const weights = configured_weights(config);
+  const defaultDeterminism = config?.defaults?.task?.determinism ?? "medium";
+  const determinism = task.determinism ?? defaultDeterminism;
+  if (targetExecutor === "ai") {
+    return determinism === "high" || determinism === "medium" ? weights.executor_fit.match : weights.executor_fit.mismatch;
+  }
+  if (targetExecutor === "human") {
+    return determinism === "low" || determinism === "experimental" ? weights.executor_fit.match : weights.executor_fit.mismatch;
+  }
+  if (targetExecutor === "ci") {
+    const runbook = task.execution?.runbook ?? [];
+    const ciReady = task.type === "chore" && runbook.length > 0 && runbook.every((step) => step.action === "run");
+    return ciReady ? weights.executor_fit.ci_match : weights.executor_fit.mismatch;
+  }
+  return 0;
+}
+function type_weight(task, config) {
+  const weights = configured_weights(config);
+  return weights.type[task.type];
+}
+function complexity_penalty(task, config) {
+  const weights = configured_weights(config);
+  const complexity = task.complexity ?? config?.defaults?.task?.complexity ?? "medium";
+  return weights.complexity_penalty[complexity];
+}
+function risk_penalty(task, config) {
+  const weights = configured_weights(config);
+  const level = task.risk?.level ?? "low";
+  return weights.risk_penalty[level];
+}
+function compute_score(task, graph, context = {}) {
+  const deliveries = context.deliveries ?? graph.deliveries;
+  const today = context.today ?? /* @__PURE__ */ new Date();
+  const config = context.config;
+  return priority_weight(task, config) + urgency_weight(task, deliveries, today, config) + dependency_unlock_weight(task.id, graph, config) + critical_path_weight(task.id, context.cpm, config) + determinism_weight(task, config) + executor_fit_weight(task, context.target_executor, config) + type_weight(task, config) + complexity_penalty(task, config) + risk_penalty(task, config);
+}
+
+// src/planning/scheduler.ts
+function asDate4(value) {
+  if (value instanceof Date) return new Date(value.getTime());
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  if (Number.isNaN(parsed.valueOf())) {
+    throw new Error(`Invalid date '${value}'.`);
+  }
+  return parsed;
+}
+function isoDate3(value) {
+  return value.toISOString().slice(0, 10);
+}
+function addDays3(value, days) {
+  const out = new Date(value.getTime());
+  out.setUTCDate(out.getUTCDate() + days);
+  return out;
+}
+function clone_ledger2(ledger) {
+  return {
+    slots: new Map(
+      Array.from(ledger.slots.entries(), ([track, byWeek]) => [track, new Map(byWeek)])
+    ),
+    weeks: new Map(ledger.weeks),
+    ai_tokens: new Map(ledger.ai_tokens),
+    ai_tokens_by_agent: new Map(
+      Array.from(ledger.ai_tokens_by_agent.entries(), ([agent, byDay]) => [agent, new Map(byDay)])
+    ),
+    ai_tokens_consumed_by_agent: new Map(
+      Array.from(ledger.ai_tokens_consumed_by_agent.entries(), ([agent, byDay]) => [
+        agent,
+        new Map(byDay)
+      ])
+    )
+  };
+}
+function normalize_track3(track) {
+  return (track ?? "unassigned").trim().toLowerCase();
+}
+function find_track_slots2(ledger, track) {
+  const normalized = normalize_track3(track);
+  return ledger.slots.get(normalized) ?? ledger.slots.get("unassigned") ?? null;
+}
+function check_capacity(task, ledger) {
+  try {
+    const slots = find_track_slots2(ledger, task.track);
+    if (!slots) return false;
+    const week0 = slots.get(0) ?? 0;
+    if (week0 <= 0) return false;
+    const attempt = clone_ledger2(ledger);
+    return allocate(attempt, task, 0).success;
+  } catch {
+    return false;
+  }
+}
+function advisory_delivery(graph, tasks, options) {
+  if (options.delivery) {
+    const existing = graph.deliveries.get(options.delivery);
+    if (existing) {
+      return {
+        id: existing.id,
+        name: existing.name,
+        status: "planning",
+        target_date: existing.target_date ?? isoDate3(addDays3(asDate4(options.today ?? /* @__PURE__ */ new Date()), 56)),
+        started_date: existing.started_date,
+        delivered_date: existing.delivered_date,
+        budget: existing.budget,
+        capacity_profiles: existing.capacity_profiles,
+        scope: existing.scope
+      };
     }
-    ordered[key] = raw[key];
   }
-  return ordered;
+  const targetDate = isoDate3(addDays3(asDate4(options.today ?? /* @__PURE__ */ new Date()), 56));
+  return {
+    id: "__SCHEDULE__",
+    name: "Advisory Schedule",
+    status: "planning",
+    target_date: targetDate,
+    started_date: null,
+    delivered_date: null,
+    budget: {},
+    capacity_profiles: [],
+    scope: {
+      include: tasks.map((task) => task.id),
+      exclude: []
+    }
+  };
 }
-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");
+function resolve_cpm(graph, options) {
+  if (options.delivery) {
+    const delivery = graph.deliveries.get(options.delivery);
+    if (!delivery) return void 0;
+    return compute_critical_path(delivery, graph);
+  }
+  const preferred = Array.from(graph.deliveries.values()).find(
+    (delivery) => delivery.status === "committed" || delivery.status === "in_progress"
+  );
+  if (!preferred) return void 0;
+  return compute_critical_path(preferred, graph);
+}
+function schedule_next(graph, options = {}) {
+  const ready_tasks = Array.from(graph.nodes.values()).filter(
+    (task) => compute_readiness(task, graph) === "ready"
+  );
+  let filtered = ready_tasks;
+  if (options.track) {
+    filtered = filtered.filter((task) => (task.track ?? "unassigned") === options.track);
+  }
+  const deliveryFilter = options.delivery;
+  if (deliveryFilter) {
+    const scope = graph.deliveries.get(deliveryFilter)?.scope.include ?? [];
+    const scopeSet = new Set(scope);
+    filtered = filtered.filter(
+      (task) => task.delivery === deliveryFilter || scopeSet.has(task.id)
+    );
+  }
+  if (options.executor) {
+    filtered = filtered.filter(
+      (task) => task.execution?.executor === options.executor || task.execution?.executor == null
+    );
+  }
+  const cpm = resolve_cpm(graph, options);
+  const scored = filtered.map((task) => ({
+    task,
+    score: compute_score(task, graph, {
+      deliveries: graph.deliveries,
+      cpm,
+      today: options.today ?? /* @__PURE__ */ new Date(),
+      target_executor: options.executor,
+      config: options.config
+    }),
+    readiness: compute_readiness(task, graph),
+    fits_capacity: true,
+    fits_wip: true
+  }));
+  scored.sort((a, b) => {
+    if (a.score !== b.score) return b.score - a.score;
+    return a.task.id.localeCompare(b.task.id);
+  });
+  const limit = typeof options.limit === "number" && Number.isInteger(options.limit) && options.limit > 0 ? options.limit : void 0;
+  const output = typeof limit === "number" ? scored.slice(0, limit) : scored;
+  if (output.length === 0) return output;
+  const delivery = advisory_delivery(graph, output.map((entry) => entry.task), options);
+  const ledger = build_capacity_ledger(delivery, graph.resources, options.today ?? /* @__PURE__ */ new Date());
+  for (const entry of output) {
+    entry.fits_capacity = check_capacity(entry.task, ledger);
+    entry.fits_wip = check_wip(
+      graph.tracks.get(entry.task.track ?? "unassigned"),
+      graph
+    );
   }
   return output;
 }
 
-// src/planning/readiness.ts
-function isResolvedDependencyStatus(status) {
-  return status === "done" || status === "canceled";
+// src/planning/velocity.ts
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var DEFAULT_ESTIMATION_CONFIG2 = {
+  version: 2,
+  project: {
+    name: "COOP",
+    id: "coop"
+  },
+  defaults: {
+    task: {
+      complexity: "medium"
+    }
+  }
+};
+function asDate5(value) {
+  if (value instanceof Date) return new Date(value.getTime());
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.valueOf())) {
+    throw new Error(`Invalid date '${value}'.`);
+  }
+  return parsed;
 }
-function compute_readiness(task, graph) {
-  if (task.status === "done" || task.status === "canceled") {
-    return "done";
+function isoDate4(value) {
+  return value.toISOString().slice(0, 10);
+}
+function startOfWeek3(date) {
+  const copy = new Date(date.getTime());
+  const day = copy.getUTCDay();
+  const offset = day === 0 ? -6 : 1 - day;
+  copy.setUTCDate(copy.getUTCDate() + offset);
+  copy.setUTCHours(0, 0, 0, 0);
+  return copy;
+}
+function addDays4(date, days) {
+  const out = new Date(date.getTime());
+  out.setUTCDate(out.getUTCDate() + days);
+  return out;
+}
+function durationHours2(run) {
+  const fromSteps = run.steps.reduce((sum, step) => sum + (step.duration_seconds ?? 0), 0) / 3600;
+  if (fromSteps > 0) {
+    return fromSteps;
   }
-  if (task.status === "in_review") {
-    return "waiting_review";
+  if (run.completed) {
+    const started = asDate5(run.started);
+    const completed = asDate5(run.completed);
+    return Math.max(0, completed.getTime() - started.getTime()) / (60 * 60 * 1e3);
   }
-  if (task.status === "in_progress") {
-    return "in_progress";
+  return 0;
+}
+function mean2(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function detectTrend(points) {
+  if (points.length < 4) {
+    return "stable";
   }
-  for (const depId of task.depends_on ?? []) {
-    const dep = graph.nodes.get(depId);
-    if (!dep || !isResolvedDependencyStatus(dep.status)) {
-      return "blocked";
-    }
+  const midpoint = Math.floor(points.length / 2);
+  const firstHalf = points.slice(0, midpoint).map((point) => point.completed_tasks);
+  const secondHalf = points.slice(midpoint).map((point) => point.completed_tasks);
+  const firstAverage = mean2(firstHalf);
+  const secondAverage = mean2(secondHalf);
+  if (firstAverage === 0 && secondAverage === 0) {
+    return "stable";
   }
-  return "ready";
+  if (firstAverage === 0 && secondAverage > 0) {
+    return "accelerating";
+  }
+  const ratio = secondAverage / Math.max(firstAverage, 1e-4);
+  if (ratio >= 1.15) {
+    return "accelerating";
+  }
+  if (ratio <= 0.85) {
+    return "decelerating";
+  }
+  return "stable";
 }
-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));
+function load_completed_runs(coopDir) {
+  const runsDir = import_node_path5.default.join(coopDir, "runs");
+  if (!import_node_fs11.default.existsSync(runsDir)) {
+    return [];
   }
-  return readiness;
+  return import_node_fs11.default.readdirSync(runsDir).filter((entry) => entry.toLowerCase().endsWith(".yml") || entry.toLowerCase().endsWith(".yaml")).sort((a, b) => a.localeCompare(b)).map((entry) => parseYamlFile(import_node_path5.default.join(runsDir, entry))).filter((run) => run.status === "completed" && typeof run.completed === "string");
 }
-function partition_by_readiness(graph) {
-  const partitions = {
-    ready: [],
-    blocked: [],
-    in_progress: [],
-    waiting_review: [],
-    done: []
+function compute_velocity(runs, windowWeeks, options = {}) {
+  const normalizedWindow = Number.isInteger(windowWeeks) && windowWeeks > 0 ? windowWeeks : 4;
+  const today = startOfWeek3(asDate5(options.today ?? /* @__PURE__ */ new Date()));
+  const windowStart = addDays4(today, -7 * (normalizedWindow - 1));
+  const pointMap = /* @__PURE__ */ new Map();
+  for (let weekIndex = 0; weekIndex < normalizedWindow; weekIndex += 1) {
+    const weekStart = addDays4(windowStart, weekIndex * 7);
+    const weekEnd = addDays4(weekStart, 6);
+    pointMap.set(isoDate4(weekStart), {
+      tasks: /* @__PURE__ */ new Set(),
+      hours: 0,
+      index: weekIndex,
+      end: isoDate4(weekEnd)
+    });
+  }
+  let completedRuns = 0;
+  let estimatedHours = 0;
+  let actualHours = 0;
+  for (const run of runs) {
+    if (!run.completed) continue;
+    const completedAt = asDate5(run.completed);
+    const weekStart = startOfWeek3(completedAt);
+    const weekKey = isoDate4(weekStart);
+    const bucket = pointMap.get(weekKey);
+    if (!bucket) continue;
+    completedRuns += 1;
+    const hours = durationHours2(run);
+    actualHours += hours;
+    bucket.tasks.add(run.task);
+    bucket.hours += hours;
+    const task = options.graph?.nodes.get(run.task);
+    if (task) {
+      estimatedHours += effort_or_default(task, DEFAULT_ESTIMATION_CONFIG2);
+    }
+  }
+  const points = Array.from(pointMap.entries()).sort((a, b) => a[1].index - b[1].index).map(([weekStart, bucket]) => ({
+    week_index: bucket.index,
+    week_start: weekStart,
+    week_end: bucket.end,
+    completed_tasks: bucket.tasks.size,
+    delivered_hours: Number(bucket.hours.toFixed(2))
+  }));
+  const tasksCompletedTotal = points.reduce((sum, point) => sum + point.completed_tasks, 0);
+  const deliveredHoursTotal = points.reduce((sum, point) => sum + point.delivered_hours, 0);
+  return {
+    window_weeks: normalizedWindow,
+    completed_runs: completedRuns,
+    tasks_completed_total: tasksCompletedTotal,
+    delivered_hours_total: Number(deliveredHoursTotal.toFixed(2)),
+    tasks_completed_per_week: Number((tasksCompletedTotal / normalizedWindow).toFixed(2)),
+    hours_delivered_per_week: Number((deliveredHoursTotal / normalizedWindow).toFixed(2)),
+    accuracy_ratio: estimatedHours > 0 ? Number((actualHours / estimatedHours).toFixed(3)) : null,
+    trend: detectTrend(points),
+    points
   };
-  for (const task of graph.nodes.values()) {
-    const state = compute_readiness(task, graph);
-    partitions[state].push(task);
+}
+
+// src/planning/what-if.ts
+function asDate6(value) {
+  if (value instanceof Date) return new Date(value.getTime());
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  if (Number.isNaN(parsed.valueOf())) {
+    throw new Error(`Invalid date '${value}'.`);
   }
-  return partitions;
+  return parsed;
 }
-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."
-      });
+function calendar_days2(from, to) {
+  const start = asDate6(from);
+  const end = asDate6(to);
+  return Math.round((end.getTime() - start.getTime()) / (24 * 60 * 60 * 1e3));
+}
+function signed_number(value, suffix = "") {
+  if (!Number.isFinite(value) || value === 0) return "-";
+  return `${value > 0 ? "+" : ""}${value}${suffix}`;
+}
+function signed_hours(value) {
+  if (!Number.isFinite(value) || value === 0) return "-";
+  return `${value > 0 ? "+" : ""}${value.toFixed(1)}h`;
+}
+function format_hours(value) {
+  if (!Number.isFinite(value)) return "unbounded";
+  return `${value.toFixed(1)}h`;
+}
+function format_headroom(result) {
+  const budget = result.summary.effort_hours.budget;
+  if (!Number.isFinite(budget)) return "unbounded";
+  return `${(budget - result.summary.effort_hours.required).toFixed(1)}h`;
+}
+function modification_label(modification) {
+  switch (modification.kind) {
+    case "without":
+      return `--without ${modification.task_id}`;
+    case "add_member":
+      return `--add-member ${modification.target}`;
+    case "target":
+      return `--target ${modification.target_date}`;
+    case "set_priority":
+      return `--set ${modification.task_id}:priority=${modification.priority}`;
+  }
+}
+function build_rows(baseline, scenario) {
+  const baselineTarget = baseline.summary.dates.target ?? "-";
+  const scenarioTarget = scenario.summary.dates.target ?? "-";
+  const baselineProjected = baseline.summary.dates.projected ?? "-";
+  const scenarioProjected = scenario.summary.dates.projected ?? "-";
+  const baselineHeadroom = Number.isFinite(baseline.summary.effort_hours.budget) ? baseline.summary.effort_hours.budget - baseline.summary.effort_hours.required : Number.NaN;
+  const scenarioHeadroom = Number.isFinite(scenario.summary.effort_hours.budget) ? scenario.summary.effort_hours.budget - scenario.summary.effort_hours.required : Number.NaN;
+  return [
+    {
+      metric: "Target date",
+      original: baselineTarget,
+      scenario: scenarioTarget,
+      delta: baseline.summary.dates.target && scenario.summary.dates.target ? signed_number(calendar_days2(baseline.summary.dates.target, scenario.summary.dates.target), " days") : "-"
+    },
+    {
+      metric: "Projected date",
+      original: baselineProjected,
+      scenario: scenarioProjected,
+      delta: baseline.summary.dates.projected && scenario.summary.dates.projected ? signed_number(
+        calendar_days2(baseline.summary.dates.projected, scenario.summary.dates.projected),
+        " days"
+      ) : "-"
+    },
+    {
+      metric: "Effort (hours)",
+      original: format_hours(baseline.summary.effort_hours.required),
+      scenario: format_hours(scenario.summary.effort_hours.required),
+      delta: signed_hours(scenario.summary.effort_hours.required - baseline.summary.effort_hours.required)
+    },
+    {
+      metric: "Headroom",
+      original: format_headroom(baseline),
+      scenario: format_headroom(scenario),
+      delta: signed_hours(scenarioHeadroom - baselineHeadroom)
+    },
+    {
+      metric: "Critical path tasks",
+      original: String(baseline.summary.critical_path.length),
+      scenario: String(scenario.summary.critical_path.length),
+      delta: signed_number(scenario.summary.critical_path.length - baseline.summary.critical_path.length)
+    },
+    {
+      metric: "Status",
+      original: baseline.status,
+      scenario: scenario.status,
+      delta: baseline.status === scenario.status ? "-" : `${baseline.status} -> ${scenario.status}`
     }
-    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(", ")}.`
-      });
+  ];
+}
+function clone_graph(graph) {
+  return structuredClone(graph);
+}
+function resolve_delivery(graph, deliveryId) {
+  const delivery = graph.deliveries.get(deliveryId);
+  if (!delivery) {
+    throw new Error(`Delivery '${deliveryId}' not found.`);
+  }
+  return delivery;
+}
+function remove_task_and_exclusive_dependencies(graph, delivery, taskId) {
+  const scoped = new Set(delivery.scope.include);
+  for (const excluded of delivery.scope.exclude) {
+    scoped.delete(excluded);
+  }
+  if (!scoped.has(taskId)) {
+    throw new Error(`Task '${taskId}' is not in delivery '${delivery.id}' scope.`);
+  }
+  const toRemove = /* @__PURE__ */ new Set([taskId]);
+  const queue = [taskId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) continue;
+    for (const dependencyId of graph.forward.get(current) ?? /* @__PURE__ */ new Set()) {
+      if (!scoped.has(dependencyId) || toRemove.has(dependencyId)) continue;
+      const dependents = graph.reverse.get(dependencyId) ?? /* @__PURE__ */ new Set();
+      const hasRemainingDependent = Array.from(dependents).some(
+        (dependentId) => scoped.has(dependentId) && !toRemove.has(dependentId)
+      );
+      if (hasRemainingDependent) continue;
+      toRemove.add(dependencyId);
+      queue.push(dependencyId);
+    }
+  }
+  delivery.scope.include = delivery.scope.include.filter((id) => !toRemove.has(id));
+  delivery.scope.exclude = delivery.scope.exclude.filter((id) => !toRemove.has(id));
+}
+function resolve_human_profile(graph, delivery, target) {
+  const direct = graph.resources.get(target);
+  if (direct?.type === "human") {
+    return direct;
+  }
+  const track = graph.tracks.get(target);
+  if (track) {
+    for (const profileId of track.capacity_profiles) {
+      const profile = graph.resources.get(profileId);
+      if (profile?.type === "human") {
+        return profile;
+      }
+    }
+  }
+  for (const profileId of delivery.capacity_profiles) {
+    const profile = graph.resources.get(profileId);
+    if (profile?.type === "human") {
+      return profile;
+    }
+  }
+  throw new Error(`No human capacity profile found for '${target}'.`);
+}
+function add_member(graph, delivery, target, hoursPerWeek) {
+  const profile = resolve_human_profile(graph, delivery, target);
+  const defaultHours = hoursPerWeek ?? profile.defaults?.hours_per_week ?? profile.members[0]?.hours_per_week ?? 40;
+  const nextMemberIndex = profile.members.length + 1;
+  profile.members = [
+    ...profile.members,
+    {
+      id: `what-if-${profile.id}-${nextMemberIndex}`,
+      hours_per_week: defaultHours
     }
+  ];
+  graph.resources.set(profile.id, profile);
+}
+function set_target(delivery, targetDate) {
+  asDate6(targetDate);
+  delivery.target_date = targetDate;
+}
+function set_priority(graph, taskId, priority) {
+  const task = graph.nodes.get(taskId);
+  if (!task) {
+    throw new Error(`Task '${taskId}' not found.`);
+  }
+  task.priority = priority;
+  graph.nodes.set(taskId, task);
+}
+function apply_modification(graph, deliveryId, modification) {
+  const delivery = resolve_delivery(graph, deliveryId);
+  switch (modification.kind) {
+    case "without":
+      remove_task_and_exclusive_dependencies(graph, delivery, modification.task_id);
+      return;
+    case "add_member":
+      add_member(graph, delivery, modification.target, modification.hours_per_week);
+      return;
+    case "target":
+      set_target(delivery, modification.target_date);
+      graph.deliveries.set(delivery.id, delivery);
+      return;
+    case "set_priority":
+      set_priority(graph, modification.task_id, modification.priority);
+      return;
+  }
+}
+function analyze_what_if(baseline, modification) {
+  const modifications = Array.isArray(modification) ? modification : [modification];
+  if (modifications.length === 0) {
+    throw new Error("At least one what-if modification is required.");
+  }
+  const baselineResult = analyze_feasibility(baseline.delivery_id, baseline.graph, baseline.today);
+  const scenarioGraph = clone_graph(baseline.graph);
+  for (const next of modifications) {
+    apply_modification(scenarioGraph, baseline.delivery_id, next);
   }
+  const scenarioResult = analyze_feasibility(baseline.delivery_id, scenarioGraph, baseline.today);
   return {
-    readiness,
-    partitions,
-    corrections,
-    warnings
+    delivery: baseline.delivery_id,
+    label: modifications.map(modification_label).join(" "),
+    baseline: baselineResult,
+    scenario: scenarioResult,
+    rows: build_rows(baselineResult, scenarioResult)
   };
 }
 
+// src/schema/migration.ts
+var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+
 // src/schema/version.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var CURRENT_SCHEMA_VERSION = 2;
 function schemaVersionFile(coopDir) {
-  return import_node_path2.default.join(coopDir, "schema-version");
+  return import_node_path6.default.join(coopDir, "schema-version");
 }
 function read_schema_version(coopDir) {
   const filePath = schemaVersionFile(coopDir);
-  if (!import_node_fs8.default.existsSync(filePath)) {
+  if (!import_node_fs12.default.existsSync(filePath)) {
     throw new Error(`Missing schema-version file at ${filePath}.`);
   }
-  const raw = import_node_fs8.default.readFileSync(filePath, "utf8").trim();
+  const raw = import_node_fs12.default.readFileSync(filePath, "utf8").trim();
   if (!raw) {
     throw new Error(`Schema version file is empty at ${filePath}.`);
   }
@@ -963,10 +4186,168 @@ function write_schema_version(coopDir, version) {
     throw new Error(`Schema version must be a positive integer. Received: ${String(version)}.`);
   }
   const filePath = schemaVersionFile(coopDir);
-  import_node_fs8.default.writeFileSync(filePath, `${version}
+  import_node_fs12.default.writeFileSync(filePath, `${version}
 `, "utf8");
 }
 
+// src/schema/migration.ts
+function asString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function cloneRaw(raw) {
+  return JSON.parse(JSON.stringify(raw));
+}
+function estimate_to_three_point(value) {
+  return {
+    optimistic_hours: Number((value * 0.7).toFixed(2)),
+    expected_hours: Number(value.toFixed(2)),
+    pessimistic_hours: Number((value * 1.8).toFixed(2))
+  };
+}
+function walk_files(dirPath, extensions) {
+  if (!import_node_fs13.default.existsSync(dirPath)) return [];
+  const out = [];
+  const entries = import_node_fs13.default.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = import_node_path7.default.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...walk_files(fullPath, extensions));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const ext = import_node_path7.default.extname(entry.name).toLowerCase();
+    if (extensions.has(ext)) {
+      out.push(fullPath);
+    }
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+function file_mtime_iso(filePath) {
+  const stats = import_node_fs13.default.statSync(filePath);
+  return stats.mtime.toISOString().slice(0, 10);
+}
+function migration_v1_to_v2(rawTask, context = {}) {
+  const migrated = { ...rawTask };
+  if (migrated.status === "dropped") {
+    migrated.status = "canceled";
+  }
+  if (migrated.type === "task") {
+    migrated.type = "chore";
+  } else if (migrated.type === "research") {
+    migrated.type = "spike";
+  }
+  if (!Object.prototype.hasOwnProperty.call(migrated, "updated")) {
+    migrated.updated = context.file_mtime_iso ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  }
+  if (!Object.prototype.hasOwnProperty.call(migrated, "assignee")) {
+    migrated.assignee = null;
+  }
+  const deliveryRecord = asRecord(migrated.delivery);
+  if (deliveryRecord) {
+    const include = deliveryRecord.include;
+    if (Array.isArray(include)) {
+      const first = include.find((entry) => typeof entry === "string");
+      migrated.delivery = asString2(first) ?? null;
+    } else if (typeof include === "string" && include.trim().length > 0) {
+      migrated.delivery = include.trim();
+    } else {
+      migrated.delivery = null;
+    }
+  }
+  const estimate = migrated.estimate;
+  if (typeof estimate === "number" && Number.isFinite(estimate) && estimate > 0) {
+    migrated.estimate = estimate_to_three_point(estimate);
+  } else if (asRecord(estimate)) {
+    const estimateRecord = estimate;
+    const hasExpectedHours = typeof estimateRecord.expected_hours === "number" && Number.isFinite(estimateRecord.expected_hours);
+    const hasOptimisticHours = typeof estimateRecord.optimistic_hours === "number" && Number.isFinite(estimateRecord.optimistic_hours);
+    const hasPessimisticHours = typeof estimateRecord.pessimistic_hours === "number" && Number.isFinite(estimateRecord.pessimistic_hours);
+    if (hasExpectedHours && (!hasOptimisticHours || !hasPessimisticHours)) {
+      migrated.estimate = {
+        ...estimateRecord,
+        optimistic_hours: hasOptimisticHours ? estimateRecord.optimistic_hours : Number((Number(estimateRecord.expected_hours) * 0.7).toFixed(2)),
+        pessimistic_hours: hasPessimisticHours ? estimateRecord.pessimistic_hours : Number((Number(estimateRecord.expected_hours) * 1.8).toFixed(2))
+      };
+    }
+  }
+  return migrated;
+}
+var MIGRATIONS = [
+  {
+    from: 1,
+    to: 2,
+    description: "COOP schema v1 to v2 task migration.",
+    migrate: migration_v1_to_v2
+  }
+];
+function migration_for_step(fromVersion, toVersion) {
+  const found = MIGRATIONS.find((migration) => migration.from === fromVersion && migration.to === toVersion);
+  if (!found) {
+    throw new Error(`No schema migration registered for v${fromVersion} -> v${toVersion}.`);
+  }
+  return found;
+}
+function migrate_task(rawTask, fromVersion, toVersion, context = {}) {
+  if (!Number.isInteger(fromVersion) || fromVersion <= 0) {
+    throw new Error(`Invalid fromVersion '${String(fromVersion)}'.`);
+  }
+  if (!Number.isInteger(toVersion) || toVersion <= 0) {
+    throw new Error(`Invalid toVersion '${String(toVersion)}'.`);
+  }
+  if (fromVersion > toVersion) {
+    throw new Error(`Downgrade migration is not supported: v${fromVersion} -> v${toVersion}.`);
+  }
+  if (fromVersion === toVersion) {
+    return cloneRaw(rawTask);
+  }
+  let current = cloneRaw(rawTask);
+  for (let version = fromVersion; version < toVersion; version += 1) {
+    const migration = migration_for_step(version, version + 1);
+    current = migration.migrate(current, context);
+  }
+  return current;
+}
+function migrate_repository(coopDir, targetVersion = CURRENT_SCHEMA_VERSION, options = {}) {
+  if (!Number.isInteger(targetVersion) || targetVersion <= 0) {
+    throw new Error(`Target version must be a positive integer. Received: ${String(targetVersion)}.`);
+  }
+  const dry_run = Boolean(options.dry_run);
+  const from_version = read_schema_version(coopDir);
+  if (from_version > targetVersion) {
+    throw new Error(`Cannot migrate backwards from v${from_version} to v${targetVersion}.`);
+  }
+  const taskFiles = walk_files(import_node_path7.default.join(coopDir, "tasks"), /* @__PURE__ */ new Set([".md"]));
+  const changed_files = [];
+  for (const filePath of taskFiles) {
+    const { frontmatter, body } = parseFrontmatterFile(filePath);
+    const migrated = migrate_task(frontmatter, from_version, targetVersion, {
+      file_path: filePath,
+      file_mtime_iso: file_mtime_iso(filePath)
+    });
+    const before = JSON.stringify(frontmatter);
+    const after = JSON.stringify(migrated);
+    if (before === after) continue;
+    changed_files.push(filePath);
+    if (!dry_run) {
+      import_node_fs13.default.writeFileSync(filePath, stringifyFrontmatter(migrated, body), "utf8");
+    }
+  }
+  if (!dry_run && from_version !== targetVersion) {
+    write_schema_version(coopDir, targetVersion);
+  }
+  return {
+    from_version,
+    to_version: targetVersion,
+    dry_run,
+    files_scanned: taskFiles.length,
+    files_changed: changed_files.length,
+    changed_files
+  };
+}
+
 // src/state/auto-transitions.ts
 function toStatusMap(value) {
   if (!value) return /* @__PURE__ */ new Map();
@@ -1044,6 +4425,14 @@ function toIsoDate(now) {
   const date = now instanceof Date ? now : /* @__PURE__ */ new Date();
   return date.toISOString().slice(0, 10);
 }
+function toIsoTimestamp2(now) {
+  if (typeof now === "string") {
+    if (now.includes("T")) return now;
+    return `${now}T00:00:00.000Z`;
+  }
+  const date = now instanceof Date ? now : /* @__PURE__ */ new Date();
+  return date.toISOString();
+}
 function validateGovernanceAndDeps(task, targetStatus, context) {
   if (task.status === "in_review" && targetStatus === "done" && task.governance?.approval_required) {
     const reviewer = task.governance.reviewer;
@@ -1080,13 +4469,26 @@ function transition(task, targetStatus, context = {}) {
       error: governanceError
     };
   }
+  const nextTask = {
+    ...task,
+    status: targetStatus,
+    updated: toIsoDate(context.now)
+  };
+  if (targetStatus !== task.status) {
+    context.eventEmitter?.emit({
+      type: "task.transitioned",
+      timestamp: toIsoTimestamp2(context.now),
+      payload: {
+        task_id: task.id,
+        from: task.status,
+        to: targetStatus,
+        actor: context.actor
+      }
+    });
+  }
   return {
     success: true,
-    task: {
-      ...task,
-      status: targetStatus,
-      updated: toIsoDate(context.now)
-    }
+    task: nextTask
   };
 }
 
@@ -1304,8 +4706,9 @@ function validateSemantic(task, context = {}) {
 }
 
 // src/validator/structural.ts
-var import_node_path3 = __toESM(require("path"), 1);
-var ID_PATTERN = /^[A-Z]+-\d+$/;
+var import_node_path8 = __toESM(require("path"), 1);
+var ID_PATTERN = /^[A-Z0-9]+(?:-[A-Z0-9]+)+$/;
+var ALIAS_PATTERN = /^[A-Z0-9]+(?:[.-][A-Z0-9]+)*$/;
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 function error4(field, rule, message) {
   return { level: "error", field, rule, message };
@@ -1347,13 +4750,43 @@ function validateStructural(task, context = {}) {
     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));
+    const expected = import_node_path8.default.basename(context.filePath, import_node_path8.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}'.`)
       );
     }
   }
+  const aliases = task.aliases;
+  if (aliases !== void 0) {
+    if (!Array.isArray(aliases)) {
+      errors.push(error4("aliases", "struct.aliases_array", "Field 'aliases' must be an array of strings."));
+    } else {
+      const seen = /* @__PURE__ */ new Set();
+      for (const rawAlias of aliases) {
+        if (typeof rawAlias !== "string" || rawAlias.trim().length === 0) {
+          errors.push(error4("aliases", "struct.aliases_string", "Field 'aliases' entries must be non-empty strings."));
+          continue;
+        }
+        const normalized = rawAlias.trim().toUpperCase().replace(/_/g, ".");
+        if (!ALIAS_PATTERN.test(normalized)) {
+          errors.push(
+            error4(
+              "aliases",
+              "struct.aliases_pattern",
+              `Alias '${rawAlias}' is invalid. Use letters/numbers with '.' or '-' separators.`
+            )
+          );
+          continue;
+        }
+        if (seen.has(normalized)) {
+          errors.push(error4("aliases", "struct.aliases_unique", `Alias '${rawAlias}' is duplicated.`));
+          continue;
+        }
+        seen.add(normalized);
+      }
+    }
+  }
   return errors;
 }
 
@@ -1441,9 +4874,131 @@ function validate(task, context = {}) {
   };
 }
 
+// src/workspace.ts
+var import_node_fs14 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
+var COOP_DIR_NAME = ".coop";
+function sanitizeProjectId(value, fallback) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+  return normalized || fallback;
+}
+function coop_workspace_dir(repoRoot) {
+  return import_node_path9.default.join(import_node_path9.default.resolve(repoRoot), COOP_DIR_NAME);
+}
+function coop_projects_dir(repoRoot) {
+  return import_node_path9.default.join(coop_workspace_dir(repoRoot), "projects");
+}
+function coop_workspace_config_path(repoRoot) {
+  return import_node_path9.default.join(coop_workspace_dir(repoRoot), "config.yml");
+}
+function coop_project_root(repoRoot, projectId) {
+  return import_node_path9.default.join(coop_projects_dir(repoRoot), projectId);
+}
+function coop_project_config_path(projectRoot) {
+  return import_node_path9.default.join(projectRoot, "config.yml");
+}
+function repo_default_project_id(repoRoot) {
+  return sanitizeProjectId(import_node_path9.default.basename(import_node_path9.default.resolve(repoRoot)), "workspace");
+}
+function repo_default_project_name(repoRoot) {
+  const base = import_node_path9.default.basename(import_node_path9.default.resolve(repoRoot)).trim();
+  return base || "COOP Workspace";
+}
+function has_v2_projects_layout(repoRoot) {
+  return import_node_fs14.default.existsSync(coop_projects_dir(repoRoot));
+}
+function has_legacy_project_layout(repoRoot) {
+  const workspaceDir = coop_workspace_dir(repoRoot);
+  return import_node_fs14.default.existsSync(workspaceDir) && import_node_fs14.default.existsSync(import_node_path9.default.join(workspaceDir, "config.yml")) && !import_node_fs14.default.existsSync(coop_projects_dir(repoRoot));
+}
+function read_workspace_config(repoRoot) {
+  const configPath = coop_workspace_config_path(repoRoot);
+  if (!import_node_fs14.default.existsSync(configPath) || has_legacy_project_layout(repoRoot)) {
+    return { version: 2 };
+  }
+  return parseYamlFile(configPath);
+}
+function write_workspace_config(repoRoot, config) {
+  import_node_fs14.default.mkdirSync(coop_workspace_dir(repoRoot), { recursive: true });
+  writeYamlFile(coop_workspace_config_path(repoRoot), {
+    version: config.version ?? 2,
+    ...config.current_project ? { current_project: config.current_project } : {}
+  });
+}
+function read_project_config(projectRoot) {
+  return parseYamlFile(coop_project_config_path(projectRoot));
+}
+function project_ref_from_config(repoRoot, projectRoot, layout) {
+  const config = read_project_config(projectRoot);
+  const repoName = repo_default_project_name(repoRoot);
+  const fallbackId = repo_default_project_id(repoRoot);
+  return {
+    id: sanitizeProjectId(config.project?.id ?? fallbackId, fallbackId),
+    name: config.project?.name?.trim() || repoName,
+    aliases: Array.isArray(config.project?.aliases) ? config.project.aliases.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [],
+    root: projectRoot,
+    repo_root: import_node_path9.default.resolve(repoRoot),
+    layout
+  };
+}
+function list_projects(repoRoot) {
+  if (has_v2_projects_layout(repoRoot)) {
+    const projectsDir = coop_projects_dir(repoRoot);
+    return import_node_fs14.default.readdirSync(projectsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => import_node_path9.default.join(projectsDir, entry.name)).filter((projectRoot) => import_node_fs14.default.existsSync(coop_project_config_path(projectRoot))).map((projectRoot) => project_ref_from_config(repoRoot, projectRoot, "v2")).sort((a, b) => a.id.localeCompare(b.id));
+  }
+  if (has_legacy_project_layout(repoRoot)) {
+    return [project_ref_from_config(repoRoot, coop_workspace_dir(repoRoot), "legacy")];
+  }
+  return [];
+}
+function resolve_project(repoRoot, options = {}) {
+  const projects = list_projects(repoRoot);
+  const requested = options.project?.trim().toLowerCase();
+  if (requested) {
+    const match = projects.find(
+      (project) => project.id.toLowerCase() === requested || project.name.toLowerCase() === requested || project.aliases.some((alias) => alias.toLowerCase() === requested)
+    );
+    if (!match) {
+      throw new Error(`Project '${options.project}' not found.`);
+    }
+    return match;
+  }
+  if (projects.length === 1) {
+    return projects[0];
+  }
+  const workspaceConfig = read_workspace_config(repoRoot);
+  if (workspaceConfig.current_project) {
+    const match = projects.find((project) => project.id === workspaceConfig.current_project);
+    if (match) return match;
+  }
+  if (!options.require && projects.length === 0) {
+    return {
+      id: repo_default_project_id(repoRoot),
+      name: repo_default_project_name(repoRoot),
+      aliases: [],
+      root: coop_project_root(repoRoot, repo_default_project_id(repoRoot)),
+      repo_root: import_node_path9.default.resolve(repoRoot),
+      layout: "v2"
+    };
+  }
+  if (projects.length === 0) {
+    throw new Error("No COOP project found. Run 'coop init'.");
+  }
+  throw new Error("Multiple COOP projects found. Pass --project <id> or run 'coop project use <id>'.");
+}
+function ensure_workspace_layout(repoRoot) {
+  const workspaceDir = coop_workspace_dir(repoRoot);
+  import_node_fs14.default.mkdirSync(workspaceDir, { recursive: true });
+  import_node_fs14.default.mkdirSync(coop_projects_dir(repoRoot), { recursive: true });
+  return workspaceDir;
+}
+function is_project_initialized(projectRoot) {
+  return import_node_fs14.default.existsSync(coop_project_config_path(projectRoot));
+}
+
 // src/core.ts
-var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_fs15 = __toESM(require("fs"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var import_gray_matter = __toESM(require("gray-matter"), 1);
 
 // src/types.ts
@@ -1460,7 +5015,7 @@ var ITEM_DIRS = {
   spike: "spikes"
 };
 var COOP_DIR = ".coop";
-var DEFAULT_CONFIG = {
+var DEFAULT_CONFIG3 = {
   spec_version: 1,
   id_prefix: "COOP",
   id_strategy: "text"
@@ -1469,17 +5024,17 @@ function toIdKey(value) {
   return value.trim().toUpperCase();
 }
 function repoRootByPackage(cwd) {
-  let current = import_node_path4.default.resolve(cwd);
+  let current = import_node_path10.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)) {
+    const packageJson = import_node_path10.default.join(current, "package.json");
+    const workspaceYaml = import_node_path10.default.join(current, "pnpm-workspace.yaml");
+    if (import_node_fs15.default.existsSync(packageJson) && import_node_fs15.default.existsSync(workspaceYaml)) {
       lastWorkspaceRoot = current;
-      const hasCoop = import_node_fs9.default.existsSync(import_node_path4.default.join(current, COOP_DIR, "config.yml"));
+      const hasCoop = import_node_fs15.default.existsSync(import_node_path10.default.join(current, COOP_DIR, "config.yml"));
       if (hasCoop) return current;
     }
-    const parent = import_node_path4.default.dirname(current);
+    const parent = import_node_path10.default.dirname(current);
     if (parent === current) return lastWorkspaceRoot;
     current = parent;
   }
@@ -1488,24 +5043,24 @@ function findRepoRoot(cwd = process.cwd()) {
   return repoRootByPackage(cwd);
 }
 function configPathFor(rootDir, workspaceDir) {
-  return import_node_path4.default.join(rootDir, workspaceDir, "config.yml");
+  return import_node_path10.default.join(rootDir, workspaceDir, "config.yml");
 }
 function backlogPathFor(rootDir, workspaceDir) {
-  return import_node_path4.default.join(rootDir, workspaceDir, "backlog");
+  return import_node_path10.default.join(rootDir, workspaceDir, "backlog");
 }
 function releasesPathFor(rootDir, workspaceDir) {
-  return import_node_path4.default.join(rootDir, workspaceDir, "releases");
+  return import_node_path10.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;
+  if (import_node_fs15.default.existsSync(configPathFor(rootDir, COOP_DIR))) return COOP_DIR;
+  if (import_node_fs15.default.existsSync(import_node_path10.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));
+  const coopConfig = import_node_path10.default.relative(rootDir, configPathFor(rootDir, COOP_DIR));
   return new Error(`COOP config missing at ${coopConfig}. Run: coop init`);
 }
 function parseConfig(raw) {
@@ -1516,9 +5071,9 @@ function parseConfig(raw) {
     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 spec = Number(map.get("spec_version") ?? DEFAULT_CONFIG3.spec_version);
+  const idPrefix = map.get("id_prefix") ?? DEFAULT_CONFIG3.id_prefix;
+  const strategy = String(map.get("id_strategy") ?? DEFAULT_CONFIG3.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.");
@@ -1551,10 +5106,10 @@ function configToString(config) {
   return lines.join("\n");
 }
 function toPortablePath(value) {
-  return value.split(import_node_path4.default.sep).join("/");
+  return value.split(import_node_path10.default.sep).join("/");
 }
 function ensureReleasesDir(rootDir, workspaceDir) {
-  import_node_fs9.default.mkdirSync(releasesPathFor(rootDir, workspaceDir), { recursive: true });
+  import_node_fs15.default.mkdirSync(releasesPathFor(rootDir, workspaceDir), { recursive: true });
 }
 function releaseHeader(date) {
   return `## ${date}`;
@@ -1576,12 +5131,12 @@ function appendReleaseEntry(rootDir, workspaceDir, item, previousStatus, nextSta
   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 releasePath = import_node_path10.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(
+  if (!import_node_fs15.default.existsSync(releasePath)) {
+    import_node_fs15.default.writeFileSync(
       releasePath,
       [
         `${heading}
@@ -1594,10 +5149,10 @@ function appendReleaseEntry(rootDir, workspaceDir, item, previousStatus, nextSta
       ].join("\n"),
       "utf8"
     );
-    return toPortablePath(import_node_path4.default.relative(rootDir, releasePath));
+    return toPortablePath(import_node_path10.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));
+  const existing = import_node_fs15.default.readFileSync(releasePath, "utf8");
+  if (hasReleaseEntry(existing, item.id)) return toPortablePath(import_node_path10.default.relative(rootDir, releasePath));
   let nextContent = existing;
   if (!existing.includes(`## ${date}`)) {
     if (!nextContent.endsWith("\n")) nextContent += "\n";
@@ -1607,9 +5162,9 @@ function appendReleaseEntry(rootDir, workspaceDir, item, previousStatus, nextSta
   if (!nextContent.endsWith("\n")) nextContent += "\n";
   nextContent += `${entry}
 `;
-  import_node_fs9.default.writeFileSync(releasePath, `${nextContent}
+  import_node_fs15.default.writeFileSync(releasePath, `${nextContent}
 `, "utf8");
-  return toPortablePath(import_node_path4.default.relative(rootDir, releasePath));
+  return toPortablePath(import_node_path10.default.relative(rootDir, releasePath));
 }
 function completeItem(rootDir, id) {
   const state = loadState(rootDir);
@@ -1687,28 +5242,28 @@ function validateAndNormalize(data, sourceFile) {
   };
 }
 function parseItem(filePath, rootDir) {
-  const raw = import_node_fs9.default.readFileSync(filePath, "utf8");
+  const raw = import_node_fs15.default.readFileSync(filePath, "utf8");
   const parsed = (0, import_gray_matter.default)(raw);
-  const data = validateAndNormalize(parsed.data, import_node_path4.default.relative(rootDir, filePath));
+  const data = validateAndNormalize(parsed.data, import_node_path10.default.relative(rootDir, filePath));
   return {
     ...data,
     body: parsed.content || "",
-    filePath: import_node_path4.default.relative(rootDir, filePath)
+    filePath: import_node_path10.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 });
+  if (!import_node_fs15.default.existsSync(dir)) return out;
+  const entries = import_node_fs15.default.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const file = import_node_path4.default.join(dir, entry.name);
+    const file = import_node_path10.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`);
+  return import_node_path10.default.join(backlogPathFor(rootDir, workspaceDir), ITEM_DIRS[type], `${id}.md`);
 }
 function normalizeFrontmatterValue(value) {
   if (value == null) return void 0;
@@ -1795,30 +5350,30 @@ function nextGeneratedId(config, title, existing) {
 }
 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 });
+  const root = import_node_path10.default.join(rootDir, workspaceDir);
+  import_node_fs15.default.mkdirSync(root, { recursive: true });
+  import_node_fs15.default.mkdirSync(import_node_path10.default.join(root, "releases"), { recursive: true });
+  import_node_fs15.default.mkdirSync(import_node_path10.default.join(root, "plans"), { recursive: true });
+  import_node_fs15.default.mkdirSync(import_node_path10.default.join(root, "views"), { recursive: true });
+  import_node_fs15.default.mkdirSync(import_node_path10.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 });
+    import_node_fs15.default.mkdirSync(import_node_path10.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");
+  const configFile = import_node_path10.default.join(root, "config.yml");
+  if (!import_node_fs15.default.existsSync(configFile)) {
+    import_node_fs15.default.writeFileSync(configFile, configToString(DEFAULT_CONFIG3), "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"));
+  if (!import_node_fs15.default.existsSync(configPath)) throw missingConfigError(rootDir);
+  const config = parseConfig(import_node_fs15.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 dir = import_node_path10.default.join(backlogPathFor(rootDir, workspaceDir), ITEM_DIRS[type]);
     const files = walk(dir);
     for (const file of files) {
       const item = parseItem(file, rootDir);
@@ -1902,21 +5457,21 @@ function createItem(rootDir, params) {
     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");
+  import_node_fs15.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");
+        import_node_fs15.default.writeFileSync(configPathFor(rootDir, state.workspaceDir), configToString(config), "utf8");
       }
     }
   }
   return {
     ...item,
     body: params.body || "",
-    filePath: import_node_path4.default.relative(rootDir, itemPathName)
+    filePath: import_node_path10.default.relative(rootDir, itemPathName)
   };
 }
 function updateItem(rootDir, id, patch) {
@@ -1942,8 +5497,8 @@ function updateItem(rootDir, id, patch) {
   };
   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");
+  const filePath = import_node_path10.default.join(rootDir, existing.filePath);
+  import_node_fs15.default.writeFileSync(filePath, serialize(next, patch.body || existing.body), "utf8");
   return {
     ...next,
     body: patch.body || existing.body,
@@ -1959,7 +5514,7 @@ function deleteItem(rootDir, id) {
   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));
+  import_node_fs15.default.unlinkSync(import_node_path10.default.join(rootDir, existing.filePath));
   return existing;
 }
 function renderAgentPrompt(item) {
@@ -1998,8 +5553,8 @@ 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.");
+  if (!workspaceDir || !import_node_fs15.default.existsSync(configPathFor(rootDir, workspaceDir))) {
+    errors.push("Missing COOP config. Run coop init first.");
     return { valid: false, errors, warnings };
   }
   let state;
@@ -2032,13 +5587,20 @@ function validateRepo(rootDir) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArtifactType,
+  COOP_EVENT_TYPES,
   CURRENT_SCHEMA_VERSION,
+  CoopEventEmitter,
+  DEFAULT_SCORE_WEIGHTS,
   DeliveryStatus,
   ExecutorType,
   ITEM_STATUSES,
   ITEM_TYPES,
   IdeaStatus,
+  IndexManager,
+  MIGRATIONS,
   RiskLevel,
+  RunStatus,
+  RunStepStatus,
   RunbookAction,
   TaskComplexity,
   TaskDeterminism,
@@ -2047,23 +5609,63 @@ function validateRepo(rootDir) {
   TaskType,
   VALID_TASK_TRANSITIONS,
   VALID_TRANSITIONS,
+  allocate,
+  allocate_ai,
+  allocate_ai_tokens,
+  analyze_feasibility,
+  analyze_what_if,
+  build_capacity_ledger,
   build_graph,
   check_blocked,
+  check_permission,
   check_unblocked,
+  check_wip,
   completeItem,
+  complexity_penalty,
   compute_all_readiness,
+  compute_critical_path,
   compute_readiness,
   compute_readiness_with_corrections,
+  compute_score,
+  compute_velocity,
+  coop_project_config_path,
+  coop_project_root,
+  coop_projects_dir,
+  coop_workspace_config_path,
+  coop_workspace_dir,
   createItem,
+  create_seeded_rng,
+  critical_path_weight,
   deleteItem,
+  dependency_unlock_weight,
   detect_cycle,
+  detect_delivery_risks,
+  determinism_weight,
+  effective_weekly_hours,
+  effort_or_default,
   ensureCoopLayout,
+  ensure_workspace_layout,
+  executor_fit_weight,
+  external_dependencies_for_task,
   extract_subgraph,
   findRepoRoot,
   find_external_dependencies,
   getItemById,
+  get_remaining_tokens,
+  get_user_role,
+  has_legacy_project_layout,
+  has_v2_projects_layout,
+  is_external_dependency,
+  is_project_initialized,
+  list_projects,
   loadState,
+  load_auth_config,
+  load_completed_runs,
   load_graph,
+  load_plugins,
+  migrate_repository,
+  migrate_task,
+  monte_carlo_forecast,
   parseDeliveryContent,
   parseDeliveryFile,
   parseFrontmatterContent,
@@ -2074,16 +5676,38 @@ function validateRepo(rootDir) {
   parseTaskFile,
   parseYamlContent,
   parseYamlFile,
+  parse_external_dependency,
   partition_by_readiness,
+  pert_hours,
+  pert_stddev,
+  priority_weight,
   queryItems,
+  read_project_config,
   read_schema_version,
+  read_workspace_config,
   renderAgentPrompt,
+  repo_default_project_id,
+  repo_default_project_name,
+  resolve_external_dependencies,
+  resolve_project,
+  risk_penalty,
+  run_hook,
+  run_monte_carlo_chunk,
+  run_plugins_for_event,
+  sample_pert_beta,
+  sample_task_hours,
+  schedule_next,
+  simulate_schedule,
   stringifyFrontmatter,
+  stringifyYamlContent,
+  task_effort_hours,
   topological_sort,
   transition,
   transitive_dependencies,
   transitive_dependents,
+  type_weight,
   updateItem,
+  urgency_weight,
   validate,
   validateReferential,
   validateRepo,
@@ -2093,5 +5717,7 @@ function validateRepo(rootDir) {
   validate_graph,
   validate_transition,
   writeTask,
-  write_schema_version
+  writeYamlFile,
+  write_schema_version,
+  write_workspace_config
 });