@kitsy/coop-core 0.0.1 → 2.0.0

package/dist/chunk-UK4JN4TZ.js

@@ -0,0 +1,951 @@
+// 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/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/sampling.ts
+var DEFAULT_CONFIG = {
+  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_CONFIG);
+  const min = base * 0.7;
+  const max = base * 1.3;
+  return min + (max - min) * rng();
+}
+
+// src/planning/simulator.ts
+import fs from "fs";
+import os from "os";
+import { Worker } from "worker_threads";
+import { fileURLToPath, pathToFileURL } from "url";
+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 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 (fs.existsSync(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, os.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 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);
+}
+
+export {
+  pert_hours,
+  pert_stddev,
+  task_effort_hours,
+  effort_or_default,
+  effective_weekly_hours,
+  build_capacity_ledger,
+  allocate,
+  check_wip,
+  allocate_ai,
+  allocate_ai_tokens,
+  get_remaining_tokens,
+  sample_pert_beta,
+  sample_task_hours,
+  simulate_schedule,
+  create_seeded_rng,
+  run_monte_carlo_chunk,
+  monte_carlo_forecast
+};