@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-XQ2XGIBF.js

@@ -0,0 +1,2086 @@
+import {
+  DefaultTaskStore,
+  TaskTracker
+} from "./chunk-K4YUNKU7.js";
+import {
+  noOpLogger
+} from "./chunk-WBPVKEEE.js";
+import {
+  readBundledInstructionText,
+  renderInstructionTemplate
+} from "./chunk-5S437PRC.js";
+import {
+  atomicWrite,
+  withFileLock
+} from "./chunk-7ZHZE5EO.js";
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/goal/phase-graph-builder.ts
+var PhaseGraphBuilder = class _PhaseGraphBuilder {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  async build() {
+    const graphId = crypto.randomUUID();
+    const phases = /* @__PURE__ */ new Map();
+    const phaseIds = [];
+    for (let i = 0; i < this.opts.phases.length; i++) {
+      const tmpl = this.opts.phases[i] ?? { name: "", description: "", tasks: [], taskTemplates: [], parallelizable: false, priority: "medium", estimateHours: 0 };
+      const phaseId = crypto.randomUUID();
+      phaseIds.push(phaseId);
+      const store = this.opts.externalTaskStore ?? new DefaultTaskStore();
+      const tracker = new TaskTracker({ store });
+      const taskGraph = await tracker.createGraph(phaseId, `${tmpl.name} Tasks`);
+      if (tmpl.taskTemplates && tmpl.taskTemplates.length > 0) {
+        for (const tt of tmpl.taskTemplates) {
+          tracker.addNode({
+            title: tt.title,
+            description: tt.description,
+            type: tt.type,
+            priority: tt.priority,
+            status: "pending",
+            estimateHours: tt.estimateHours,
+            tags: tt.tags ?? []
+          });
+        }
+      }
+      const phase = {
+        id: phaseId,
+        name: tmpl.name,
+        description: tmpl.description,
+        status: "pending",
+        taskGraph,
+        dependsOn: i > 0 ? [phaseIds[i - 1] ?? ""] : [],
+        nextPhases: i < this.opts.phases.length - 1 ? [phaseIds[i + 1] ?? ""] : [],
+        parallelizable: tmpl.parallelizable,
+        priority: tmpl.priority,
+        estimateHours: tmpl.estimateHours,
+        assignedAgents: [],
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      phases.set(phaseId, phase);
+    }
+    const phaseArray = Array.from(phases.values());
+    for (let i = 0; i < phaseArray.length; i++) {
+      const phase = phaseArray[i];
+      if (!phase) continue;
+      phase.nextPhases = i < phaseArray.length - 1 ? [phaseArray[i + 1]?.id ?? ""] : [];
+    }
+    const graph = {
+      id: graphId,
+      title: this.opts.title,
+      description: this.opts.description ?? "",
+      phases,
+      rootPhaseIds: phaseIds.length > 0 ? [phaseIds[0] ?? ""] : [],
+      activePhaseIds: [],
+      completedPhaseIds: [],
+      failedPhaseIds: [],
+      autonomous: this.opts.autonomous ?? true,
+      stopOnComplete: true,
+      multiBoard: this.opts.multiBoard,
+      verifyTasks: this.opts.verifyTasks,
+      chimeraReview: this.opts.chimeraReview,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    return graph;
+  }
+  /**
+   * Create phases from an existing TaskGraph.
+   * Groups tasks into phases using topological sort so dependencies
+   * stay in the same phase wherever possible.
+   */
+  static fromTaskGraph(taskGraph, options) {
+    const tasksPerPhase = options.tasksPerPhase ?? 5;
+    const nodes = Array.from(taskGraph.nodes.values());
+    const dependents = /* @__PURE__ */ new Map();
+    for (const edge of taskGraph.edges) {
+      const list = dependents.get(edge.from) ?? [];
+      list.push(edge.to);
+      dependents.set(edge.from, list);
+    }
+    const inDegree = /* @__PURE__ */ new Map();
+    for (const node of nodes) inDegree.set(node.id, 0);
+    for (const edge of taskGraph.edges) {
+      inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1);
+    }
+    const queue = [];
+    for (const [id, degree] of inDegree) {
+      if (degree === 0) queue.push(id);
+    }
+    const prioOrder = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3
+    };
+    const topoSorted = [];
+    while (queue.length > 0) {
+      queue.sort((a, b) => {
+        const na = taskGraph.nodes.get(a);
+        const nb = taskGraph.nodes.get(b);
+        const naPrio = na ? prioOrder[na.priority] : 4;
+        const nbPrio = nb ? prioOrder[nb.priority] : 4;
+        return naPrio - nbPrio;
+      });
+      const id = queue.shift();
+      topoSorted.push(id);
+      for (const depId of dependents.get(id) ?? []) {
+        const deg = (inDegree.get(depId) ?? 1) - 1;
+        inDegree.set(depId, deg);
+        if (deg === 0) queue.push(depId);
+      }
+    }
+    const groups = [];
+    let currentGroup = [];
+    const assigned = /* @__PURE__ */ new Set();
+    for (const id of topoSorted) {
+      if (assigned.has(id)) continue;
+      assigned.add(id);
+      currentGroup.push(id);
+      const deps = dependents.get(id) ?? [];
+      for (const depId of deps) {
+        if (!assigned.has(depId) && currentGroup.length < tasksPerPhase) {
+          assigned.add(depId);
+          currentGroup.push(depId);
+        }
+      }
+      if (currentGroup.length >= tasksPerPhase) {
+        groups.push(currentGroup);
+        currentGroup = [];
+      }
+    }
+    if (currentGroup.length > 0) groups.push(currentGroup);
+    const phaseTemplates = groups.map((groupIds, idx) => {
+      const group = groupIds.map((id) => taskGraph.nodes.get(id)).filter((n) => n != null);
+      const hasCritical = group.some((t) => t.priority === "critical");
+      const totalHours = group.reduce((sum, t) => sum + (t.estimateHours ?? 2), 0);
+      return {
+        name: `Phase ${idx + 1}: ${group[0]?.title.slice(0, 30) ?? "Tasks"}`,
+        description: group.map((t) => t.title).join(", "),
+        priority: hasCritical ? "critical" : "high",
+        estimateHours: totalHours,
+        parallelizable: false,
+        taskTemplates: group.map((t) => ({
+          title: t.title,
+          description: t.description,
+          type: t.type,
+          priority: t.priority,
+          estimateHours: t.estimateHours ?? 2,
+          tags: t.tags ?? []
+        }))
+      };
+    });
+    const builder = new _PhaseGraphBuilder({
+      ...options,
+      phases: phaseTemplates
+    });
+    return builder.build();
+  }
+};
+
+// src/goal/phase-board-mutations.ts
+function findPhaseOfTaskInGraph(graph, taskId) {
+  for (const phase of graph.phases.values()) {
+    if (phase.taskGraph.nodes.has(taskId)) return phase;
+  }
+  return void 0;
+}
+function movePhaseTask(ctx, taskId, toPhaseId) {
+  const from = findPhaseOfTaskInGraph(ctx.graph, taskId);
+  const to = ctx.graph.phases.get(toPhaseId);
+  if (!from || !to || from.id === toPhaseId) return false;
+  const node = from.taskGraph.nodes.get(taskId);
+  if (!node) return false;
+  const dependents = from.taskGraph.edges.filter((e) => e.from === taskId).map((e) => e.to);
+  for (const depId of dependents) {
+    const depNode = from.taskGraph.nodes.get(depId);
+    if (depNode) {
+      depNode.parentId = void 0;
+      depNode.children = void 0;
+    }
+    from.taskGraph.edges = from.taskGraph.edges.filter(
+      (e) => !(e.from === taskId && e.to === depId)
+    );
+    if (!from.taskGraph.rootNodes.includes(depId)) {
+      from.taskGraph.rootNodes.push(depId);
+    }
+  }
+  from.taskGraph.nodes.delete(taskId);
+  from.taskGraph.rootNodes = from.taskGraph.rootNodes.filter((id) => id !== taskId);
+  from.taskGraph.edges = from.taskGraph.edges.filter((e) => e.from !== taskId && e.to !== taskId);
+  from.taskGraph.updatedAt = Date.now();
+  node.parentId = void 0;
+  node.children = void 0;
+  node.updatedAt = Date.now();
+  to.taskGraph.nodes.set(taskId, node);
+  to.taskGraph.rootNodes.push(taskId);
+  to.taskGraph.updatedAt = Date.now();
+  ctx.trackerCache.delete(from.id);
+  ctx.trackerCache.delete(to.id);
+  ctx.graph.updatedAt = Date.now();
+  ctx.emit("phase.taskMoved", { taskId, fromPhaseId: from.id, toPhaseId });
+  return true;
+}
+function setPhaseTaskAssignee(ctx, taskId, agentId, agentName) {
+  const phase = findPhaseOfTaskInGraph(ctx.graph, taskId);
+  if (!phase) return false;
+  const tracker = ctx.getTrackerForPhase(phase);
+  tracker.updateNode(taskId, { assignee: agentName ?? agentId ?? "" });
+  ctx.graph.updatedAt = Date.now();
+  ctx.emit("phase.taskAssigned", {
+    phaseId: phase.id,
+    taskId,
+    ...agentId !== void 0 ? { agentId } : {},
+    ...agentName !== void 0 ? { agentName } : {}
+  });
+  return true;
+}
+function addPhaseTask(ctx, phaseId, spec) {
+  const phase = ctx.graph.phases.get(phaseId);
+  if (!phase) return null;
+  const tracker = ctx.getTrackerForPhase(phase);
+  const node = tracker.addNode({
+    title: spec.title,
+    description: spec.description ?? "",
+    type: spec.type ?? "feature",
+    priority: spec.priority ?? "medium",
+    status: "pending"
+  });
+  ctx.graph.updatedAt = Date.now();
+  ctx.emit("phase.taskAdded", { phaseId, taskId: node.id, taskTitle: node.title });
+  return node.id;
+}
+function requeuePhaseTask(ctx, taskId) {
+  const phase = findPhaseOfTaskInGraph(ctx.graph, taskId);
+  if (!phase) return false;
+  const tracker = ctx.getTrackerForPhase(phase);
+  tracker.updateNodeStatus(taskId, "pending");
+  ctx.taskRetryCounts.delete(`${phase.id}:${taskId}`);
+  if (phase.status === "completed" || phase.status === "failed" || phase.status === "paused") {
+    ctx.graph.failedPhaseIds = ctx.graph.failedPhaseIds.filter((id) => id !== phase.id);
+    ctx.graph.completedPhaseIds = ctx.graph.completedPhaseIds.filter((id) => id !== phase.id);
+    ctx.graph.activePhaseIds = ctx.graph.activePhaseIds.filter((id) => id !== phase.id);
+    ctx.phaseWorktrees.delete(phase.id);
+    ctx.updatePhaseStatus(phase, "pending");
+  }
+  ctx.graph.updatedAt = Date.now();
+  return true;
+}
+
+// src/goal/phase-orchestrator-queries.ts
+function getReadyPhases(graph) {
+  const ready = [];
+  for (const phase of graph.phases.values()) {
+    if (phase.status !== "pending") continue;
+    const depsDone = phase.dependsOn.every((depId) => {
+      const dep = graph.phases.get(depId);
+      return dep?.status === "completed" || dep?.status === "skipped";
+    });
+    if (depsDone) {
+      ready.push(phase);
+    }
+  }
+  const prioOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+  ready.sort((a, b) => (prioOrder[a.priority] ?? 4) - (prioOrder[b.priority] ?? 4));
+  return ready;
+}
+function getActivePhases(graph) {
+  return Array.from(graph.phases.values()).filter((p) => p.status === "running");
+}
+function getExecutableTasks(trackerFor, phase) {
+  const tracker = trackerFor(phase);
+  return tracker.getAllNodes({ status: ["pending", "blocked"] }).filter(
+    (n) => n.status === "pending" && tracker.canStart(n.id)
+  ).sort((a, b) => {
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    return (priorityOrder[a.priority] ?? 4) - (priorityOrder[b.priority] ?? 4);
+  });
+}
+function getFailedTaskCount(trackerFor, phase) {
+  return trackerFor(phase).getAllNodes({ status: ["failed"] }).length;
+}
+function getCompletedTaskCount(trackerFor, phase) {
+  return trackerFor(phase).getAllNodes({ status: ["completed"] }).length;
+}
+function isGraphComplete(graph) {
+  const allPhases = Array.from(graph.phases.values());
+  return allPhases.every((p) => p.status === "completed" || p.status === "skipped");
+}
+function getProgress(graph, trackerFor) {
+  const phases = Array.from(graph.phases.values());
+  let pending = 0;
+  let ready = 0;
+  let running = 0;
+  let paused = 0;
+  let completed = 0;
+  let failed = 0;
+  let skipped = 0;
+  let totalTasks = 0;
+  let completedTasks = 0;
+  let failedTasks = 0;
+  let estimatedHours = 0;
+  let actualHours = 0;
+  for (const p of phases) {
+    switch (p.status) {
+      case "pending":
+        pending++;
+        break;
+      case "ready":
+        ready++;
+        break;
+      case "running":
+        running++;
+        break;
+      case "paused":
+        paused++;
+        break;
+      case "completed":
+        completed++;
+        break;
+      case "failed":
+        failed++;
+        break;
+      case "skipped":
+        skipped++;
+        break;
+      default:
+        break;
+    }
+    estimatedHours += p.estimateHours;
+    if (p.actualDurationMs) actualHours += p.actualDurationMs / 36e5;
+    const tracker = trackerFor(p);
+    const progress = tracker.getProgress();
+    totalTasks += progress.total;
+    completedTasks += progress.completed;
+    failedTasks += progress.failed;
+  }
+  const totalPhases = phases.length;
+  const done = completed + skipped;
+  return {
+    totalPhases,
+    pending,
+    ready,
+    running,
+    paused,
+    completed,
+    failed,
+    skipped,
+    percentComplete: totalPhases > 0 ? Math.min(100, Math.round(done / totalPhases * 100)) : 0,
+    totalTasks,
+    completedTasks,
+    failedTasks,
+    estimatedHours,
+    actualHours
+  };
+}
+function setIntegrationMetadata(graph, phase, status, details = {}) {
+  phase.metadata = {
+    ...phase.metadata,
+    integrationStatus: status,
+    integrationBranch: details.branch,
+    integrationWorktreeDir: details.worktreeDir,
+    integrationConflictFiles: details.conflictFiles,
+    integrationError: details.error,
+    integrationUpdatedAt: Date.now()
+  };
+  phase.updatedAt = Date.now();
+  graph.updatedAt = Date.now();
+}
+function truncate(text, max = 500) {
+  const t = text.trim();
+  return t.length <= max ? t : `${t.slice(0, max)}\u2026 (+${t.length - max} chars)`;
+}
+
+// src/goal/phase-orchestrator-integration.ts
+function worktreeEnv(int, phase) {
+  const handle = int.phaseWorktrees.get(phase.id);
+  return handle ? { cwd: handle.dir, branch: handle.branch } : void 0;
+}
+async function failPhaseAfterTasks(int, phase, error) {
+  int.updatePhaseStatus(phase, "failed");
+  phase.completedAt = Date.now();
+  phase.actualDurationMs = Date.now() - (phase.startedAt ?? Date.now());
+  int.runningPhases.delete(phase.id);
+  int.graph.activePhaseIds = int.graph.activePhaseIds.filter((id) => id !== phase.id);
+  if (!int.graph.failedPhaseIds.includes(phase.id)) int.graph.failedPhaseIds.push(phase.id);
+  int.emit("phase.failed", { phaseId: phase.id, name: phase.name, error });
+  int.ctx.onPhaseFail?.(phase, new Error(error));
+  await keepWorktreeForReview(int, phase);
+}
+function markPhaseMergeFailed(int, phase, error) {
+  if (phase.status !== "failed") {
+    int.graph.completedPhaseIds = int.graph.completedPhaseIds.filter((id) => id !== phase.id);
+    int.updatePhaseStatus(phase, "failed");
+  }
+  if (!int.graph.failedPhaseIds.includes(phase.id)) int.graph.failedPhaseIds.push(phase.id);
+  int.emit("phase.failed", { phaseId: phase.id, name: phase.name, error });
+  int.ctx.onPhaseFail?.(phase, new Error(error));
+}
+async function commitAndEnqueueMerge(int, phase) {
+  const handle = int.phaseWorktrees.get(phase.id);
+  if (!int.worktrees || !handle) return;
+  try {
+    await int.worktrees.commitAll(handle, `goal(${phase.name}): ${phase.id}`);
+  } catch {
+  }
+  const depPromises = phase.dependsOn.map((d) => int.phaseMergePromise.get(d)).filter((p) => Boolean(p));
+  const merged = (async () => {
+    await Promise.allSettled(depPromises);
+    int.setMergeQueue(
+      int.getMergeQueue().then(() => mergeOne(int, phase, handle)).catch((err) => {
+        const msg = toErrorMessage(err);
+        int.logger.error(msg, { event: "orchestrator.merge_failed", phaseId: phase.id });
+        markPhaseMergeFailed(int, phase, msg);
+      })
+    );
+    await int.getMergeQueue();
+  })();
+  int.phaseMergePromise.set(phase.id, merged);
+}
+async function mergeOne(int, phase, handle) {
+  if (!int.worktrees) return;
+  try {
+    const resolve2 = int.ctx.resolveConflict ? async (info) => {
+      const shouldResolve = await shouldAttemptConflictResolution(int, phase, info);
+      if (!shouldResolve) return false;
+      int.emit("phase.conflictResolving", {
+        phaseId: phase.id,
+        name: phase.name,
+        files: info.conflictFiles
+      });
+      const resolved = await int.ctx.resolveConflict?.(phase, info);
+      return resolved ?? false;
+    } : void 0;
+    const mergeOpts = {
+      squash: true
+    };
+    if (resolve2 !== void 0) mergeOpts.resolve = resolve2;
+    const result = await int.worktrees.merge(handle, mergeOpts);
+    if (result.resolved) {
+      int.emit("phase.conflictResolved", { phaseId: phase.id, name: phase.name });
+    }
+    setIntegrationMetadata(int.graph, phase, result.ok ? "merged" : "needs_review", {
+      branch: handle.branch,
+      worktreeDir: handle.dir,
+      conflictFiles: result.conflictFiles
+    });
+    await int.worktrees.release(handle, { keep: !result.ok });
+  } catch (err) {
+    setIntegrationMetadata(int.graph, phase, "merge_failed", {
+      branch: handle.branch,
+      worktreeDir: handle.dir,
+      error: toErrorMessage(err)
+    });
+    markPhaseMergeFailed(int, phase, `worktree merge failed: ${toErrorMessage(err)}`);
+  }
+}
+async function shouldAttemptConflictResolution(int, phase, info) {
+  if (!int.ctx.brain) return true;
+  const decision = await int.ctx.brain.decide({
+    id: `goal-conflict-${phase.id}`,
+    source: "goal",
+    question: `Should Goal try to resolve merge conflicts for phase "${phase.name}" automatically?`,
+    context: [
+      `Phase id: ${phase.id}`,
+      `Conflicted files: ${info.conflictFiles.join(", ") || "(unknown)"}`,
+      `Base working tree: ${info.cwd}`
+    ].join("\n"),
+    // 'critical', not 'high': choosing `resolve` lets a resolver agent EDIT
+    // FILES IN THE BASE WORKING TREE. That is the one Brain decision in the
+    // system whose wrong answer is not recoverable by simply continuing —
+    // unlike a budget grant (bounded, capped) or a goal-done verdict (the
+    // run can be restarted).
+    //
+    // Consequences of the level, both intended:
+    //   - it is at or above the council floor, so a multi-LLM panel decides
+    //     it whenever one can convene;
+    //   - with no council (a single-model install resolves the autonomy
+    //     ceiling to 'high'), it exceeds the ceiling and never reaches an
+    //     unchecked single model. The policy tier's `ask_human` then routes
+    //     to the terminal policy, which refuses a recommended option at
+    //     critical risk and denies — i.e. the worktree is kept for human
+    //     review, which is exactly the safe outcome.
+    risk: "critical",
+    fallback: "ask_human",
+    options: [
+      {
+        id: "resolve",
+        label: "Try the configured conflict resolver",
+        consequence: "A resolver agent may edit conflicted files in the base working tree.",
+        risk: "critical"
+      },
+      {
+        id: "review",
+        label: "Keep the worktree for human review",
+        consequence: "No automatic conflict resolution is attempted.",
+        risk: "low",
+        recommended: true
+      }
+    ]
+  });
+  phase.metadata = {
+    ...phase.metadata,
+    brainConflictDecision: decision.type,
+    brainConflictDecisionAt: Date.now()
+  };
+  if (decision.type !== "answer") return false;
+  return decision.optionId === "resolve";
+}
+async function keepWorktreeForReview(int, phase) {
+  const handle = int.phaseWorktrees.get(phase.id);
+  if (!int.worktrees || !handle) return;
+  try {
+    await int.worktrees.commitAll(handle, `goal(${phase.name}) [failed]: ${phase.id}`);
+  } catch {
+  }
+  setIntegrationMetadata(int.graph, phase, "not_merged_failed_phase", {
+    branch: handle.branch,
+    worktreeDir: handle.dir
+  });
+  await int.worktrees.release(handle, { keep: true }).catch(() => {
+  });
+}
+
+// src/goal/phase-orchestrator-runtime.ts
+function normalizePhaseGraphForResume(graph) {
+  graph.activePhaseIds = [];
+  for (const phase of graph.phases.values()) {
+    if (phase.status === "running") {
+      phase.status = "pending";
+      phase.updatedAt = Date.now();
+    }
+    if (phase.status === "pending") {
+      for (const task of phase.taskGraph.nodes.values()) {
+        if (task.status === "in_progress") task.status = "pending";
+      }
+    }
+  }
+}
+function createNoopEventBus() {
+  return {
+    emit: () => {
+    },
+    on: () => () => {
+    },
+    off: () => {
+    },
+    once: () => () => {
+    },
+    listeners: /* @__PURE__ */ new Map(),
+    wildcards: [],
+    setLogger: () => {
+    },
+    onAny: () => () => {
+    },
+    offAny: () => {
+    },
+    emitAsync: async () => [],
+    waitFor: async () => {
+    }
+  };
+}
+
+// src/goal/phase-orchestrator.ts
+var PhaseOrchestrator = class {
+  graph;
+  ctx;
+  opts;
+  events;
+  stopped = false;
+  paused = false;
+  /**
+   * Run-wide abort source. stop() aborts it; every in-flight
+   * ctx.executeTask call observes the abort through its per-task signal
+   * (composed from this controller and the task's own timeout controller).
+   * Recreated by start() so a stopped orchestrator can be reused.
+   */
+  stopController = new AbortController();
+  runningPhases = /* @__PURE__ */ new Set();
+  tickInterval = null;
+  trackerCache = /* @__PURE__ */ new Map();
+  taskRetryCounts = /* @__PURE__ */ new Map();
+  // ── Git-worktree isolation (optional) ──────────────────────────────────────
+  worktrees;
+  logger;
+  /** Per-phase worktree handles, keyed by phase id. */
+  phaseWorktrees = /* @__PURE__ */ new Map();
+  /** Serializes all merges back to the base branch (one at a time). */
+  mergeQueue = Promise.resolve();
+  /** Per-phase merge promise, so a phase merges only after its deps do. */
+  phaseMergePromise = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.graph = opts.graph;
+    this.ctx = opts.ctx;
+    this.events = opts.events ?? createNoopEventBus();
+    this.worktrees = opts.worktrees;
+    this.logger = opts.logger ?? noOpLogger;
+    this.opts = {
+      maxConcurrentPhases: opts.maxConcurrentPhases ?? 1,
+      maxConcurrentTasks: opts.maxConcurrentTasks ?? 2,
+      maxRetries: opts.maxRetries ?? 2,
+      maxVerifyAttempts: opts.maxVerifyAttempts ?? 2,
+      autonomous: opts.autonomous ?? true,
+      phaseDelayMs: opts.phaseDelayMs ?? 0,
+      // Autonomous goals must fail closed. Continuing after a terminal task or
+      // gate failure can make dependent phases look complete without their
+      // required evidence.
+      stopOnFailure: opts.stopOnFailure ?? true,
+      taskTimeoutMs: opts.taskTimeoutMs ?? 6e5,
+      events: this.events
+    };
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────────────────
+  /**
+   * Start the full phase flow.
+   * In autonomous mode, starts root phases and automatically starts the next phase when they finish.
+   */
+  async start() {
+    this.stopped = false;
+    this.paused = false;
+    this.stopController = new AbortController();
+    this.normalizeForResume();
+    this.graph.startedAt = Date.now();
+    this.graph.updatedAt = Date.now();
+    let readyPhases = this.getReadyPhases();
+    while (readyPhases.length > 0 && !this.stopped) {
+      await this.waitWhilePaused();
+      if (this.stopped) break;
+      const batch = readyPhases.slice(0, this.opts.maxConcurrentPhases);
+      await Promise.all(batch.map((p) => this.startPhase(p)));
+      if (this.opts.phaseDelayMs > 0) {
+        await this.delay(this.opts.phaseDelayMs);
+      }
+      await this.waitWhilePaused();
+      if (this.stopped) break;
+      readyPhases = this.getReadyPhases().filter(
+        (p) => !this.runningPhases.has(p.id) && p.status !== "completed" && p.status !== "failed"
+      );
+    }
+    await this.drainMerges();
+    if (this.opts.autonomous) {
+      this.tickInterval = setInterval(() => this.tick(), 1e3);
+    }
+  }
+  /**
+   * Make a (possibly resumed) graph runnable. A graph loaded from disk after an
+   * interrupted run can carry transient state from the dead process: phases left
+   * `running` and tasks left `in_progress`. The scheduler only starts `pending`
+   * phases (getReadyPhases) and only runs `pending` tasks (getExecutableTasks),
+   * so without this a resumed phase/task would stall forever. Reset that
+   * transient state to `pending`; terminal phases (completed/failed/skipped) and
+   * already-completed tasks are untouched, so completed work is never re-run.
+   * For a freshly built graph this is a no-op.
+   */
+  normalizeForResume() {
+    normalizePhaseGraphForResume(this.graph);
+  }
+  /** Wait for all pending phase merges, dependency-ordered and globally serialized. */
+  async drainMerges() {
+    await Promise.allSettled([...this.phaseMergePromise.values()]);
+    await this.mergeQueue.catch((err) => {
+      const msg = toErrorMessage(err);
+      this.logger.warn(msg, { event: "orchestrator.merge_queue_failed" });
+    });
+  }
+  /** Pause: active phases continue, but no new phase starts. */
+  pause() {
+    this.paused = true;
+  }
+  /** Resume: new phases may start again. */
+  resume() {
+    this.paused = false;
+    this.tick().catch((err) => {
+      const msg = toErrorMessage(err);
+      this.logger.error(msg, { event: "orchestrator.tick_failed" });
+    });
+  }
+  /** Stop completely, including active phases. */
+  stop() {
+    this.stopped = true;
+    this.stopController.abort();
+    if (this.tickInterval) {
+      clearInterval(this.tickInterval);
+      this.tickInterval = null;
+    }
+    for (const phaseId of this.runningPhases) {
+      const phase = this.graph.phases.get(phaseId);
+      if (phase) {
+        this.updatePhaseStatus(phase, "paused");
+      }
+    }
+    this.trackerCache.clear();
+    this.taskRetryCounts.clear();
+    if (this.worktrees) {
+      for (const handle of this.worktrees.list()) {
+        void this.worktrees.release(handle, { keep: true }).catch(() => {
+        });
+      }
+    }
+  }
+  // ─── Tick Loop (Autonomous) ───────────────────────────────────────────────
+  async tick() {
+    if (this.stopped || this.paused) return;
+    const active = this.getActivePhases();
+    const queued = this.getReadyPhases();
+    this.emit("autonomous.tick", {
+      activePhases: active.map((p) => p.id),
+      queuedPhases: queued.map((p) => p.id)
+    });
+    this.ctx.onTick?.({ activePhases: active, readyPhases: queued });
+    const availableSlots = this.opts.maxConcurrentPhases - active.length;
+    if (availableSlots > 0 && queued.length > 0) {
+      for (const phase of queued.slice(0, availableSlots)) {
+        if (phase.status === "pending") {
+          await this.startPhase(phase);
+        }
+      }
+    }
+    if (this.isComplete()) {
+      this.onGraphComplete();
+      return;
+    }
+    if (this.opts.stopOnFailure && this.graph.failedPhaseIds.length > 0) {
+      const failedPhase = this.graph.phases.get(this.graph.failedPhaseIds[0] ?? "");
+      if (failedPhase) {
+        this.onGraphFailed(failedPhase);
+      }
+      return;
+    }
+  }
+  // ─── Phase Execution ──────────────────────────────────────────────────────
+  async startPhase(phase) {
+    if (phase.status !== "pending" && phase.status !== "ready") return;
+    this.updatePhaseStatus(phase, "running");
+    phase.startedAt = Date.now();
+    this.runningPhases.add(phase.id);
+    this.graph.activePhaseIds.push(phase.id);
+    if (this.worktrees && !this.phaseWorktrees.has(phase.id)) {
+      try {
+        const handle = await this.worktrees.allocate(phase.id, {
+          slugHint: phase.name,
+          ownerLabel: phase.name
+        });
+        if (handle.status === "active") this.phaseWorktrees.set(phase.id, handle);
+      } catch {
+      }
+    }
+    this.emit("phase.started", { phaseId: phase.id, name: phase.name });
+    try {
+      if (phase.taskGraph.nodes.size === 0) {
+        await this.failPhaseAfterTasks(
+          phase,
+          "Phase has no executable tasks. Add task evidence before starting this phase."
+        );
+        return;
+      }
+      await this.executePhaseTasks(phase);
+      if (this.stopped) return;
+      const failedTasks = this.getFailedTaskCount(phase);
+      const completedTasks = this.getCompletedTaskCount(phase);
+      this.emit("phase.allTasksDone", {
+        phaseId: phase.id,
+        completed: completedTasks,
+        failed: failedTasks
+      });
+      if (failedTasks > 0 && this.opts.stopOnFailure) {
+        await this.failPhaseAfterTasks(phase, `${failedTasks} task(s) failed`);
+        return;
+      }
+      const verdict = await this.runVerifyGate(phase);
+      if (!verdict.ok) {
+        await this.failPhaseAfterTasks(
+          phase,
+          `verification failed${verdict.output ? `: ${this.truncate(verdict.output)}` : ""}`
+        );
+        return;
+      }
+      this.updatePhaseStatus(phase, "completed");
+      phase.completedAt = Date.now();
+      phase.actualDurationMs = Date.now() - (phase.startedAt ?? Date.now());
+      this.runningPhases.delete(phase.id);
+      this.graph.activePhaseIds = this.graph.activePhaseIds.filter((id) => id !== phase.id);
+      this.graph.completedPhaseIds.push(phase.id);
+      this.emit("phase.completed", {
+        phaseId: phase.id,
+        name: phase.name,
+        durationMs: phase.actualDurationMs
+      });
+      this.ctx.onPhaseComplete?.(phase);
+      await this.commitAndEnqueueMerge(phase);
+    } catch (error) {
+      this.updatePhaseStatus(phase, "failed");
+      phase.completedAt = Date.now();
+      phase.actualDurationMs = Date.now() - (phase.startedAt ?? Date.now());
+      this.runningPhases.delete(phase.id);
+      this.graph.activePhaseIds = this.graph.activePhaseIds.filter((id) => id !== phase.id);
+      this.graph.failedPhaseIds.push(phase.id);
+      this.emit("phase.failed", {
+        phaseId: phase.id,
+        name: phase.name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      this.ctx.onPhaseFail?.(phase, error instanceof Error ? error : new Error(String(error)));
+      await this.keepWorktreeForReview(phase);
+    }
+  }
+  // ─── Verification gate ──────────────────────────────────────────────────────
+  /**
+   * Run the verification gate for a phase whose tasks all succeeded. Verifies in
+   * the phase's worktree; on failure, runs the repair pass and re-verifies, up to
+   * `maxVerifyAttempts` repairs. Returns the final verdict. When no `verifyPhase`
+   * callback is wired the gate is a no-op and always passes.
+   */
+  async runVerifyGate(phase) {
+    if (!this.ctx.verifyPhase) return { ok: true };
+    const env = this.worktreeEnv(phase);
+    for (let attempt = 0; attempt <= this.opts.maxVerifyAttempts; attempt++) {
+      if (this.stopped) return { ok: false, output: "stopped before verification completed" };
+      this.emit("phase.verifying", { phaseId: phase.id, name: phase.name, attempt });
+      let verdict;
+      try {
+        verdict = await this.ctx.verifyPhase(phase, env);
+      } catch (err) {
+        verdict = { ok: false, output: toErrorMessage(err) };
+      }
+      if (verdict.ok) return { ok: true };
+      this.emit("phase.verifyFailed", {
+        phaseId: phase.id,
+        name: phase.name,
+        attempt,
+        error: verdict.output
+      });
+      if (attempt >= this.opts.maxVerifyAttempts || !this.ctx.repairPhase || this.stopped) {
+        return { ok: false, output: verdict.output };
+      }
+      this.emit("phase.repairing", { phaseId: phase.id, name: phase.name, attempt: attempt + 1 });
+      try {
+        await this.ctx.repairPhase(
+          phase,
+          verdict.output ?? "verification failed",
+          attempt + 1,
+          env
+        );
+      } catch {
+      }
+    }
+    return { ok: false };
+  }
+  /** Worktree env (cwd/branch) for a phase, or undefined if it runs on the shared tree. */
+  /** Bundle of orchestrator state the worktree-integration steps drive. */
+  integrationCtx() {
+    return {
+      graph: this.graph,
+      ctx: this.ctx,
+      logger: this.logger,
+      worktrees: this.worktrees,
+      phaseWorktrees: this.phaseWorktrees,
+      phaseMergePromise: this.phaseMergePromise,
+      runningPhases: this.runningPhases,
+      getMergeQueue: () => this.mergeQueue,
+      setMergeQueue: (queue) => {
+        this.mergeQueue = queue;
+      },
+      emit: (event, payload) => this.emit(event, payload),
+      updatePhaseStatus: (phase, status) => this.updatePhaseStatus(phase, status)
+    };
+  }
+  worktreeEnv(phase) {
+    return worktreeEnv(this.integrationCtx(), phase);
+  }
+  async failPhaseAfterTasks(phase, error) {
+    await failPhaseAfterTasks(this.integrationCtx(), phase, error);
+  }
+  /** Trim long verifier output so it fits cleanly in an event/error message. */
+  truncate(text, max = 500) {
+    return truncate(text, max);
+  }
+  // ─── Worktree integration ───────────────────────────────────────────────────
+  async commitAndEnqueueMerge(phase) {
+    await commitAndEnqueueMerge(this.integrationCtx(), phase);
+  }
+  /** A failed phase keeps its worktree on disk for inspection (no merge). */
+  async keepWorktreeForReview(phase) {
+    await keepWorktreeForReview(this.integrationCtx(), phase);
+  }
+  async executePhaseTasks(phase) {
+    const pendingTasks = this.getExecutableTasks(phase);
+    while (pendingTasks.length > 0 && !this.stopped) {
+      const batch = pendingTasks.splice(0, this.opts.maxConcurrentTasks);
+      const results = await Promise.allSettled(
+        batch.map((task) => this.executeSingleTask(task, phase))
+      );
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const task = batch[i];
+        if (!result || !task) continue;
+        if (result.status === "fulfilled") {
+          this.markTaskCompleted(phase, task);
+        } else {
+          this.markTaskFailed(phase, task, result.reason);
+        }
+      }
+      const newReady = this.getExecutableTasks(phase);
+      pendingTasks.length = 0;
+      pendingTasks.push(...newReady);
+    }
+  }
+  async executeSingleTask(task, phase) {
+    const tracker = this.getTrackerForPhase(phase);
+    tracker.updateNodeStatus(task.id, "in_progress");
+    this.emit("phase.taskStarted", {
+      phaseId: phase.id,
+      taskId: task.id,
+      taskTitle: task.title,
+      agentName: task.assignee
+    });
+    const handle = this.phaseWorktrees.get(phase.id);
+    const timeoutController = this.opts.taskTimeoutMs > 0 ? new AbortController() : void 0;
+    const signal = timeoutController ? AbortSignal.any([this.stopController.signal, timeoutController.signal]) : this.stopController.signal;
+    const taskPromise = this.ctx.executeTask(
+      task,
+      phase.id,
+      { cwd: handle?.dir, branch: handle?.branch },
+      signal
+    );
+    if (!timeoutController) return taskPromise;
+    const timeoutMs = this.opts.taskTimeoutMs;
+    const timedOut = /* @__PURE__ */ Symbol("timed_out");
+    const result = await Promise.race([
+      taskPromise,
+      new Promise((resolve2) => {
+        const timer = setTimeout(() => {
+          timeoutController.abort();
+          resolve2(timedOut);
+        }, timeoutMs);
+        taskPromise.then(() => clearTimeout(timer)).catch(() => clearTimeout(timer));
+      })
+    ]);
+    if (result !== timedOut) return result;
+    this.emit("phase.taskTimedOut", {
+      phaseId: phase.id,
+      taskId: task.id,
+      taskTitle: task.title,
+      timeoutMs
+    });
+    const settled = taskPromise.then(
+      () => void 0,
+      () => void 0
+    );
+    const grace = new Promise((resolve2) => {
+      const timer = setTimeout(resolve2, 5e3);
+      timer.unref?.();
+      void settled.then(() => clearTimeout(timer));
+    });
+    await Promise.race([settled, grace]);
+    throw new Error(
+      `Task "${task.title}" (${task.id}) exceeded timeout of ${timeoutMs} ms`
+    );
+  }
+  markTaskCompleted(phase, task) {
+    const tracker = this.getTrackerForPhase(phase);
+    tracker.updateNodeStatus(task.id, "completed");
+    this.emit("phase.taskCompleted", {
+      phaseId: phase.id,
+      taskId: task.id,
+      taskTitle: task.title
+    });
+  }
+  markTaskFailed(phase, task, error) {
+    const tracker = this.getTrackerForPhase(phase);
+    const taskKey = `${phase.id}:${task.id}`;
+    const currentRetries = this.taskRetryCounts.get(taskKey) ?? 0;
+    if (this.stopped) {
+      tracker.updateNodeStatus(task.id, "pending", "Stopped before completion");
+      return;
+    }
+    if (currentRetries < this.opts.maxRetries) {
+      this.taskRetryCounts.set(taskKey, currentRetries + 1);
+      tracker.updateNodeStatus(
+        task.id,
+        "pending",
+        `Retry ${currentRetries + 1}/${this.opts.maxRetries}`
+      );
+      this.emit("phase.taskRetrying", {
+        phaseId: phase.id,
+        taskId: task.id,
+        taskTitle: task.title,
+        attempt: currentRetries + 1,
+        maxRetries: this.opts.maxRetries
+      });
+    } else {
+      tracker.updateNodeStatus(
+        task.id,
+        "failed",
+        error instanceof Error ? error.message : String(error)
+      );
+      this.emit("phase.taskFailed", {
+        phaseId: phase.id,
+        taskId: task.id,
+        taskTitle: task.title,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  // ─── Helpers ──────────────────────────────────────────────────────────────
+  getReadyPhases() {
+    return getReadyPhases(this.graph);
+  }
+  getActivePhases() {
+    return getActivePhases(this.graph);
+  }
+  getExecutableTasks(phase) {
+    return getExecutableTasks((p) => this.getTrackerForPhase(p), phase);
+  }
+  getTrackerForPhase(phase) {
+    const cached = this.trackerCache.get(phase.id);
+    if (cached) return cached;
+    const tracker = new TaskTracker({ store: new DefaultTaskStore() });
+    tracker.setGraph(phase.taskGraph);
+    this.trackerCache.set(phase.id, tracker);
+    return tracker;
+  }
+  getFailedTaskCount(phase) {
+    return getFailedTaskCount((p) => this.getTrackerForPhase(p), phase);
+  }
+  getCompletedTaskCount(phase) {
+    return getCompletedTaskCount((p) => this.getTrackerForPhase(p), phase);
+  }
+  updatePhaseStatus(phase, status) {
+    const from = phase.status;
+    phase.status = status;
+    phase.updatedAt = Date.now();
+    this.graph.updatedAt = Date.now();
+    this.emit("phase.statusChange", { phaseId: phase.id, from, to: status });
+  }
+  isComplete() {
+    return isGraphComplete(this.graph);
+  }
+  onGraphComplete() {
+    this.graph.completedAt = Date.now();
+    const durationMs = this.graph.completedAt - (this.graph.startedAt ?? this.graph.completedAt);
+    this.emit("graph.completed", { graphId: this.graph.id, durationMs });
+    this.stop();
+  }
+  onGraphFailed(failedPhase) {
+    this.emit("graph.failed", {
+      graphId: this.graph.id,
+      failedPhaseId: failedPhase.id,
+      error: `Phase "${failedPhase.name}" failed`
+    });
+    this.stop();
+  }
+  // ─── Progress ─────────────────────────────────────────────────────────────
+  getProgress() {
+    return getProgress(this.graph, (p) => this.getTrackerForPhase(p));
+  }
+  getGraph() {
+    return this.graph;
+  }
+  isRunning() {
+    return !this.stopped && this.runningPhases.size > 0;
+  }
+  isPaused() {
+    return this.paused;
+  }
+  // ─── Agent Assignment ─────────────────────────────────────────────────────
+  assignAgent(phaseId, agentId) {
+    const phase = this.graph.phases.get(phaseId);
+    if (!phase) return;
+    if (!phase.assignedAgents.includes(agentId)) {
+      phase.assignedAgents.push(agentId);
+      this.emit("agent.assigned", { phaseId, agentId });
+    }
+  }
+  releaseAgent(phaseId, agentId) {
+    const phase = this.graph.phases.get(phaseId);
+    if (!phase) return;
+    phase.assignedAgents = phase.assignedAgents.filter((id) => id !== agentId);
+    this.emit("agent.released", { phaseId, agentId });
+  }
+  // ─── Interactive board mutations ──────────────────────────────────────────
+  //
+  // These are driven by an interactive board (WebUI/TUI), not the autonomous
+  // loop. Each mutates the live graph, emits a typed event so every surface
+  // stays in sync, and bumps updatedAt so the host re-persists.
+  /** Find the phase whose task graph currently holds `taskId`. */
+  findPhaseOfTask(taskId) {
+    return findPhaseOfTaskInGraph(this.graph, taskId);
+  }
+  /**
+   * Move a task to another phase's task graph. Edges that referenced the task
+   * are dropped (cross-phase dependencies are not modeled). No-op when the task
+   * or target phase is missing, or it is already in the target phase.
+   */
+  moveTask(taskId, toPhaseId) {
+    return movePhaseTask(this.boardMutationContext(), taskId, toPhaseId);
+  }
+  /** (Re)assign a task to a specific agent (or clear with agentName/agentId omitted). */
+  setTaskAssignee(taskId, agentId, agentName) {
+    return setPhaseTaskAssignee(this.boardMutationContext(), taskId, agentId, agentName);
+  }
+  /** Add a new task to a phase. Returns the created task id, or null if the phase is missing. */
+  addTask(phaseId, spec) {
+    return addPhaseTask(this.boardMutationContext(), phaseId, spec);
+  }
+  /**
+   * Requeue a task to `pending` (clearing its retry counter) and nudge a
+   * terminal/paused phase back to `ready` so the loop re-runs it. Backs both the
+   * board's "retry" and "start" affordances.
+   */
+  requeueTask(taskId) {
+    return requeuePhaseTask(this.boardMutationContext(), taskId);
+  }
+  boardMutationContext() {
+    return {
+      graph: this.graph,
+      trackerCache: this.trackerCache,
+      taskRetryCounts: this.taskRetryCounts,
+      phaseWorktrees: this.phaseWorktrees,
+      getTrackerForPhase: (phase) => this.getTrackerForPhase(phase),
+      updatePhaseStatus: (phase, status) => this.updatePhaseStatus(phase, status),
+      emit: (event, payload) => this.emit(event, payload)
+    };
+  }
+  // ─── Events ───────────────────────────────────────────────────────────────
+  emit(event, payload) {
+    this.events.emit(event, payload);
+  }
+  async waitWhilePaused() {
+    while (this.paused && !this.stopped) {
+      await this.delay(100);
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+};
+
+// src/goal/goal-runner.ts
+var GoalRunner = class {
+  graph = null;
+  orchestrator = null;
+  opts;
+  progressInterval = null;
+  maxRunTimer = null;
+  graphCompletedHandler = (payload) => {
+    const p = payload;
+    if (this.graph && p.graphId === this.graph.id) {
+      this.opts.onComplete?.(this.graph);
+      this.cleanup();
+    }
+  };
+  graphFailedHandler = (payload) => {
+    const p = payload;
+    if (this.graph && p.graphId === this.graph.id) {
+      const failedPhase = this.graph.phases.get(p.failedPhaseId);
+      if (failedPhase) {
+        this.opts.onFail?.(this.graph, failedPhase, new Error(p.error));
+      }
+      if (this.opts.stopOnFailure) {
+        this.cleanup();
+      }
+    }
+  };
+  /** Stores the unsubscribe function returned by EventBus.on() */
+  unsubscribeCompleted = null;
+  unsubscribeFailed = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async start() {
+    const builder = new PhaseGraphBuilder({
+      title: this.opts.title,
+      description: this.opts.description,
+      phases: this.opts.phases,
+      autonomous: this.opts.autonomous,
+      stopOnFailure: this.opts.stopOnFailure
+    });
+    this.graph = await builder.build();
+    const ctx = {
+      executeTask: this.opts.executeTask,
+      brain: this.opts.brain,
+      onPhaseComplete: (phase) => {
+        this.opts.onPhaseComplete?.(phase);
+      },
+      onPhaseFail: (phase, error) => {
+        this.opts.onPhaseFail?.(phase, error);
+      },
+      onTick: (tickCtx) => {
+        this.opts.onTick?.(tickCtx);
+      }
+    };
+    if (this.opts.verifyPhase !== void 0) ctx.verifyPhase = this.opts.verifyPhase;
+    if (this.opts.repairPhase !== void 0) ctx.repairPhase = this.opts.repairPhase;
+    if (this.opts.resolveConflict !== void 0) ctx.resolveConflict = this.opts.resolveConflict;
+    this.orchestrator = new PhaseOrchestrator({
+      graph: this.graph,
+      ctx,
+      maxConcurrentPhases: this.opts.maxConcurrentPhases,
+      maxConcurrentTasks: this.opts.maxConcurrentTasks,
+      maxRetries: this.opts.maxRetries,
+      maxVerifyAttempts: this.opts.maxVerifyAttempts,
+      autonomous: this.opts.autonomous,
+      phaseDelayMs: this.opts.phaseDelayMs,
+      stopOnFailure: this.opts.stopOnFailure,
+      events: this.opts.events,
+      worktrees: this.opts.worktrees
+    });
+    if (this.opts.events) {
+      const bus = this.opts.events;
+      const onUntyped = (event, handler) => bus.on(event, handler);
+      this.unsubscribeCompleted = onUntyped("graph.completed", this.graphCompletedHandler);
+      this.unsubscribeFailed = onUntyped("graph.failed", this.graphFailedHandler);
+    }
+    await this.orchestrator.start();
+    this.maxRunTimer = setTimeout(
+      () => {
+        this.opts.onProgress?.({
+          totalPhases: 0,
+          pending: 0,
+          ready: 0,
+          running: 0,
+          paused: 0,
+          completed: 0,
+          failed: 0,
+          skipped: 0,
+          percentComplete: 0,
+          totalTasks: 0,
+          completedTasks: 0,
+          failedTasks: 0,
+          estimatedHours: 0,
+          actualHours: 0
+        });
+        this.stop();
+      },
+      this.opts.maxRunDurationMs ?? 7 * 24 * 60 * 6e4
+    );
+    if (this.opts.maxRunDurationMs !== void 0 && this.opts.maxRunDurationMs <= 0) {
+      clearTimeout(this.maxRunTimer);
+      this.maxRunTimer = null;
+    }
+    this.maxRunTimer?.unref?.();
+    if (this.opts.onProgress) {
+      this.progressInterval = setInterval(() => {
+        const progress = this.orchestrator?.getProgress();
+        if (progress) this.opts.onProgress?.(progress);
+      }, 2e3);
+    }
+    return this.graph;
+  }
+  pause() {
+    this.orchestrator?.pause();
+  }
+  resume() {
+    this.orchestrator?.resume();
+  }
+  stop() {
+    this.orchestrator?.stop();
+    this.cleanup();
+  }
+  getProgress() {
+    return this.orchestrator?.getProgress() ?? null;
+  }
+  getGraph() {
+    return this.graph;
+  }
+  isRunning() {
+    return this.orchestrator?.isRunning() ?? false;
+  }
+  isPaused() {
+    return this.orchestrator?.isPaused() ?? false;
+  }
+  assignAgent(phaseId, agentId) {
+    this.orchestrator?.assignAgent(phaseId, agentId);
+  }
+  releaseAgent(phaseId, agentId) {
+    this.orchestrator?.releaseAgent(phaseId, agentId);
+  }
+  cleanup() {
+    if (this.progressInterval) {
+      clearInterval(this.progressInterval);
+      this.progressInterval = null;
+    }
+    if (this.maxRunTimer) {
+      clearTimeout(this.maxRunTimer);
+      this.maxRunTimer = null;
+    }
+    this.unsubscribeCompleted?.();
+    this.unsubscribeCompleted = null;
+    this.unsubscribeFailed?.();
+    this.unsubscribeFailed = null;
+  }
+};
+async function createGoalRunnerFromTaskGraph(taskGraph, options) {
+  const graph = await PhaseGraphBuilder.fromTaskGraph(taskGraph, {
+    title: options.title ?? taskGraph.title,
+    tasksPerPhase: options.tasksPerPhase
+  });
+  const phases = Array.from(graph.phases.values()).map((p) => ({
+    name: p.name,
+    description: p.description,
+    priority: p.priority,
+    estimateHours: p.estimateHours,
+    parallelizable: p.parallelizable
+  }));
+  return new GoalRunner({
+    ...options,
+    title: options.title ?? taskGraph.title,
+    phases
+  });
+}
+
+// src/goal/goal-planner.ts
+var VALID_TASK_TYPES = /* @__PURE__ */ new Set([
+  "feature",
+  "bugfix",
+  "refactor",
+  "docs",
+  "test",
+  "chore"
+]);
+var VALID_PRIORITIES = /* @__PURE__ */ new Set([
+  "critical",
+  "high",
+  "medium",
+  "low"
+]);
+var GoalPlanner = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  /** Convert the goal into a phase-and-todo plan. */
+  async plan() {
+    const prompt = this.buildPrompt();
+    const raw = await this.opts.runOnce(prompt);
+    const { phases, warnings } = this.parse(raw);
+    const totalTasks = phases.reduce((s, p) => s + (p.taskTemplates?.length ?? 0), 0);
+    const estimatedCostTokens = totalTasks > 0 ? totalTasks * 5 * 2e3 : void 0;
+    const maxTotal = this.opts.maxTotalTasks ?? 0;
+    let budgetExceeded = false;
+    if (maxTotal > 0 && totalTasks > maxTotal) {
+      warnings.push(
+        `Plan has ${totalTasks} total tasks, exceeding the limit of ${maxTotal}. Consider narrowing the scope or increasing the limit.`
+      );
+      budgetExceeded = true;
+    }
+    return { phases, raw, parseFailed: phases.length === 0, warnings, estimatedCostTokens, budgetExceeded };
+  }
+  /** Instruction prompt for the plan the model should produce. */
+  buildPrompt() {
+    const minP = this.opts.minPhases ?? 3;
+    const maxP = this.opts.maxPhases ?? 8;
+    const todos = this.opts.todosPerPhase ?? 6;
+    const ctx = this.opts.projectContext?.trim();
+    return renderInstructionTemplate(readBundledInstructionText("goal/phase-planner.md"), {
+      minPhases: String(minP),
+      maxPhases: String(maxP),
+      todosPerPhase: String(todos),
+      goal: this.opts.goal,
+      projectContext: ctx ? `
+PROJECT CONTEXT:
+${ctx}
+` : ""
+    });
+  }
+  /** Extract JSON from raw output, validate it, and convert it to PhaseTemplate[].
+   *  Returns `{ phases, warnings }` where warnings describe coerced defaults. */
+  parse(raw) {
+    const json = extractJSONArray(raw);
+    if (!json) return { phases: [], warnings: ["No JSON array found in model output"] };
+    let data;
+    try {
+      data = JSON.parse(json);
+    } catch {
+      return { phases: [], warnings: ["Failed to parse JSON from model output"] };
+    }
+    if (!Array.isArray(data)) return { phases: [], warnings: ["Model output is not a JSON array"] };
+    const warnings = [];
+    const phases = [];
+    for (const entry of data) {
+      const result = this.coercePhase(entry);
+      if (result) {
+        warnings.push(...result.warnings);
+        if (result.phase.taskTemplates?.length) {
+          phases.push(result.phase);
+        } else {
+          warnings.push(`Phase "${result.phase.name}" has no executable tasks and was rejected.`);
+        }
+      }
+    }
+    return { phases, warnings };
+  }
+  coercePhase(entry) {
+    if (!entry || typeof entry !== "object") return null;
+    const e = entry;
+    const name = typeof e.name === "string" ? e.name.trim() : "";
+    if (!name) return null;
+    const w = [];
+    const rawTasks = Array.isArray(e.tasks) ? e.tasks : Array.isArray(e.taskTemplates) ? e.taskTemplates : [];
+    const taskTemplates = [];
+    for (const t of rawTasks) {
+      const result = this.coerceTask(t);
+      if (result) {
+        taskTemplates.push(result.task);
+        w.push(...result.warnings);
+      }
+    }
+    const coercedPriority = coercePriority(e.priority);
+    if (typeof e.priority === "string" && coercedPriority !== e.priority) {
+      w.push('Phase "' + name + '": invalid priority "' + String(e.priority) + '", defaulting to "' + coercedPriority + '"');
+    }
+    return {
+      phase: {
+        name,
+        description: typeof e.description === "string" ? e.description : "",
+        priority: coercedPriority,
+        estimateHours: coerceHours(e.estimateHours, 4),
+        parallelizable: e.parallelizable === true,
+        taskTemplates
+      },
+      warnings: w
+    };
+  }
+  coerceTask(t) {
+    if (!t || typeof t !== "object") return null;
+    const o = t;
+    const title = typeof o.title === "string" ? o.title.trim() : "";
+    if (!title) return null;
+    const w = [];
+    let type = "feature";
+    if (typeof o.type === "string") {
+      if (VALID_TASK_TYPES.has(o.type)) {
+        type = o.type;
+      } else {
+        w.push('Task "' + title + '": invalid type "' + o.type + '", defaulting to "feature"');
+      }
+    }
+    const coercedPriority = coercePriority(o.priority);
+    if (typeof o.priority === "string" && coercedPriority !== o.priority) {
+      w.push('Task "' + title + '": invalid priority "' + String(o.priority) + '", defaulting to "' + coercedPriority + '"');
+    }
+    return {
+      task: {
+        title,
+        description: typeof o.description === "string" ? o.description : "",
+        type,
+        priority: coercedPriority,
+        estimateHours: coerceHours(o.estimateHours, 2),
+        tags: Array.isArray(o.tags) ? o.tags.map(String) : []
+      },
+      warnings: w
+    };
+  }
+};
+function coercePriority(value) {
+  return VALID_PRIORITIES.has(value) ? value : "medium";
+}
+function coerceHours(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function extractJSONArray(text) {
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidates = [];
+  if (fence?.[1]) candidates.push(fence[1]);
+  candidates.push(text);
+  for (const candidate of candidates) {
+    const balanced = firstBalancedArray(candidate);
+    if (balanced) return balanced;
+  }
+  return null;
+}
+function firstBalancedArray(text) {
+  const start = text.indexOf("[");
+  if (start === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i] ?? "";
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "[") {
+      depth++;
+    } else if (ch === "]") {
+      depth--;
+      if (depth === 0) {
+        return text.slice(start, i + 1);
+      }
+    }
+  }
+  return null;
+}
+
+// src/goal/goal-assessor.ts
+var GoalAssessor = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  /** Analyze the goal and return a structured realism assessment. */
+  async assess() {
+    const prompt = this.buildPrompt();
+    const raw = await this.opts.runOnce(prompt);
+    return this.parse(raw);
+  }
+  /** Build the instruction prompt for the LLM. */
+  buildPrompt() {
+    return renderInstructionTemplate(
+      readBundledInstructionText("goal/goal-assessor.md"),
+      { goal: this.opts.goal }
+    );
+  }
+  /** Extract and validate the JSON object from the raw LLM output. */
+  parse(raw) {
+    const json = extractJSONObject(raw);
+    if (!json) {
+      return {
+        realistic: true,
+        durationClaimed: null,
+        explanation: "",
+        recommendedDuration: null,
+        concerns: [],
+        raw,
+        parseFailed: true,
+        parseError: "No JSON object found in model output"
+      };
+    }
+    let data;
+    try {
+      data = JSON.parse(json);
+    } catch {
+      return {
+        realistic: true,
+        durationClaimed: null,
+        explanation: "",
+        recommendedDuration: null,
+        concerns: [],
+        raw,
+        parseFailed: true,
+        parseError: "Failed to parse JSON from model output"
+      };
+    }
+    return {
+      realistic: data.realistic === true,
+      durationClaimed: typeof data.durationClaimed === "string" ? data.durationClaimed : null,
+      explanation: typeof data.explanation === "string" ? data.explanation : "",
+      recommendedDuration: typeof data.recommendedDuration === "string" ? data.recommendedDuration : null,
+      concerns: Array.isArray(data.concerns) ? data.concerns.filter((c) => typeof c === "string") : [],
+      raw,
+      parseFailed: false
+    };
+  }
+};
+function extractJSONObject(text) {
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidates = [];
+  if (fence?.[1]) candidates.push(fence[1]);
+  candidates.push(text);
+  for (const candidate of candidates) {
+    const balanced = firstBalancedObject(candidate);
+    if (balanced) return balanced;
+  }
+  return null;
+}
+function firstBalancedObject(text) {
+  const start = text.indexOf("{");
+  if (start === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i] ?? "";
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return text.slice(start, i + 1);
+      }
+    }
+  }
+  return null;
+}
+
+// src/goal/types.ts
+var PHASE_EVENT_NAMES = [
+  "phase.statusChange",
+  "phase.started",
+  "phase.completed",
+  "phase.failed",
+  "phase.taskStarted",
+  "phase.taskCompleted",
+  "phase.taskFailed",
+  "phase.taskRetrying",
+  "phase.taskTimedOut",
+  "phase.allTasksDone",
+  "phase.verifying",
+  "phase.verifyFailed",
+  "phase.repairing",
+  "phase.conflictResolving",
+  "phase.conflictResolved",
+  "phase.taskMoved",
+  "phase.taskAssigned",
+  "phase.taskAdded",
+  "graph.completed",
+  "graph.failed",
+  "autonomous.tick",
+  "agent.assigned",
+  "agent.released"
+];
+
+// src/goal/phase-store.ts
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+var PHASE_STORE_VERSION = 1;
+var PhaseStore = class {
+  baseDir;
+  legacyBaseDirs;
+  constructor(opts) {
+    this.baseDir = opts.baseDir;
+    this.legacyBaseDirs = (opts.legacyBaseDirs ?? []).filter(
+      (dir) => path.resolve(dir) !== path.resolve(this.baseDir)
+    );
+  }
+  async save(graph) {
+    const filePath = this.getFilePath(graph.id);
+    const serialized = this.serializeGraph(graph);
+    await withFileLock(filePath, async () => {
+      await atomicWrite(filePath, JSON.stringify(serialized, null, 2), { mode: 384 });
+    });
+  }
+  async load(graphId) {
+    const filePath = this.getFilePath(graphId);
+    const current = await this.loadFromPath(filePath);
+    if (current) return current;
+    for (const legacyDir of this.legacyBaseDirs) {
+      const legacyPath = path.join(legacyDir, `${graphId}.json`);
+      const legacy = await this.loadFromPath(legacyPath);
+      if (!legacy) continue;
+      try {
+        await this.save(legacy);
+        await this.removeMigratedLegacyFile(legacyDir, legacyPath);
+      } catch {
+        return null;
+      }
+      return legacy;
+    }
+    return null;
+  }
+  async delete(graphId) {
+    const paths = [
+      this.getFilePath(graphId),
+      ...this.legacyBaseDirs.map((dir) => path.join(dir, `${graphId}.json`))
+    ];
+    await Promise.all(paths.map((filePath) => fsp.unlink(filePath).catch(() => void 0)));
+  }
+  async list() {
+    try {
+      await this.migrateLegacyGraphs();
+      const entries = await fsp.readdir(this.baseDir, { withFileTypes: true });
+      const graphs = [];
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+        try {
+          const raw = await fsp.readFile(path.join(this.baseDir, entry.name), "utf8");
+          const serialized = JSON.parse(raw);
+          const done = serialized.completedPhaseIds.length;
+          const total = serialized.phases.length;
+          graphs.push({
+            id: serialized.id,
+            title: serialized.title,
+            updatedAt: serialized.updatedAt,
+            status: done === total ? "completed" : done > 0 ? "in_progress" : "pending"
+          });
+        } catch {
+        }
+      }
+      return graphs.sort((a, b) => b.updatedAt - a.updatedAt);
+    } catch {
+      return [];
+    }
+  }
+  getFilePath(graphId) {
+    return path.join(this.baseDir, `${graphId}.json`);
+  }
+  async loadFromPath(filePath) {
+    try {
+      const raw = await fsp.readFile(filePath, "utf8");
+      const serialized = JSON.parse(raw);
+      return this.deserializeGraph(serialized);
+    } catch {
+      return null;
+    }
+  }
+  async migrateLegacyGraphs() {
+    for (const legacyDir of this.legacyBaseDirs) {
+      const entries = await fsp.readdir(legacyDir, { withFileTypes: true }).catch(() => []);
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+        const legacyPath = path.join(legacyDir, entry.name);
+        const currentPath = this.getFilePath(path.basename(entry.name, ".json"));
+        if (await this.pathExists(currentPath)) {
+          await this.removeMigratedLegacyFile(legacyDir, legacyPath);
+          continue;
+        }
+        const graph = await this.loadFromPath(legacyPath);
+        if (!graph) continue;
+        await this.save(graph);
+        await this.removeMigratedLegacyFile(legacyDir, legacyPath);
+      }
+    }
+  }
+  async pathExists(filePath) {
+    try {
+      await fsp.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async removeMigratedLegacyFile(legacyDir, legacyPath) {
+    await fsp.unlink(legacyPath).catch(() => void 0);
+    await fsp.rmdir(legacyDir).catch(() => void 0);
+  }
+  serializeGraph(graph) {
+    return {
+      version: PHASE_STORE_VERSION,
+      id: graph.id,
+      title: graph.title,
+      description: graph.description,
+      phases: Array.from(graph.phases.values()).map((p) => this.serializePhase(p)),
+      rootPhaseIds: graph.rootPhaseIds,
+      activePhaseIds: graph.activePhaseIds,
+      completedPhaseIds: graph.completedPhaseIds,
+      failedPhaseIds: graph.failedPhaseIds,
+      autonomous: graph.autonomous,
+      stopOnComplete: graph.stopOnComplete,
+      createdAt: graph.createdAt,
+      updatedAt: graph.updatedAt,
+      startedAt: graph.startedAt,
+      completedAt: graph.completedAt
+    };
+  }
+  serializePhase(phase) {
+    return {
+      id: phase.id,
+      name: phase.name,
+      description: phase.description,
+      status: phase.status,
+      taskGraph: this.serializeTaskGraph(phase.taskGraph),
+      dependsOn: phase.dependsOn,
+      nextPhases: phase.nextPhases,
+      parallelizable: phase.parallelizable,
+      priority: phase.priority,
+      estimateHours: phase.estimateHours,
+      actualDurationMs: phase.actualDurationMs,
+      startedAt: phase.startedAt,
+      completedAt: phase.completedAt,
+      assignedAgents: phase.assignedAgents,
+      metadata: phase.metadata,
+      createdAt: phase.createdAt,
+      updatedAt: phase.updatedAt
+    };
+  }
+  serializeTaskGraph(graph) {
+    return {
+      id: graph.id,
+      specId: graph.specId,
+      requiredRequirementIds: graph.requiredRequirementIds,
+      title: graph.title,
+      nodes: Array.from(graph.nodes.values()).map((n) => this.serializeTaskNode(n)),
+      edges: graph.edges,
+      rootNodes: graph.rootNodes,
+      createdAt: graph.createdAt,
+      updatedAt: graph.updatedAt
+    };
+  }
+  serializeTaskNode(node) {
+    return { ...node };
+  }
+  deserializeGraph(serialized) {
+    const fileVersion = serialized.version ?? 0;
+    if (fileVersion > PHASE_STORE_VERSION) {
+      throw new Error(
+        `Cannot load phase graph: file version ${fileVersion} is newer than supported version ${PHASE_STORE_VERSION}. Upgrade WrongStack to load this file.`
+      );
+    }
+    const phases = /* @__PURE__ */ new Map();
+    for (const sp of serialized.phases) {
+      phases.set(sp.id, this.deserializePhase(sp));
+    }
+    return {
+      id: serialized.id,
+      title: serialized.title,
+      description: serialized.description,
+      phases,
+      rootPhaseIds: serialized.rootPhaseIds,
+      activePhaseIds: serialized.activePhaseIds,
+      completedPhaseIds: serialized.completedPhaseIds,
+      failedPhaseIds: serialized.failedPhaseIds,
+      autonomous: serialized.autonomous,
+      stopOnComplete: serialized.stopOnComplete,
+      createdAt: serialized.createdAt,
+      updatedAt: serialized.updatedAt,
+      startedAt: serialized.startedAt,
+      completedAt: serialized.completedAt
+    };
+  }
+  deserializePhase(serialized) {
+    return {
+      id: serialized.id,
+      name: serialized.name,
+      description: serialized.description,
+      status: serialized.status,
+      taskGraph: this.deserializeTaskGraph(serialized.taskGraph),
+      dependsOn: serialized.dependsOn,
+      nextPhases: serialized.nextPhases,
+      parallelizable: serialized.parallelizable,
+      priority: serialized.priority,
+      estimateHours: serialized.estimateHours,
+      actualDurationMs: serialized.actualDurationMs,
+      startedAt: serialized.startedAt,
+      completedAt: serialized.completedAt,
+      assignedAgents: serialized.assignedAgents,
+      metadata: serialized.metadata,
+      createdAt: serialized.createdAt,
+      updatedAt: serialized.updatedAt
+    };
+  }
+  deserializeTaskGraph(serialized) {
+    const nodes = /* @__PURE__ */ new Map();
+    for (const sn of serialized.nodes) {
+      nodes.set(sn.id, sn);
+    }
+    return {
+      id: serialized.id,
+      specId: serialized.specId,
+      requiredRequirementIds: serialized.requiredRequirementIds,
+      title: serialized.title,
+      nodes,
+      edges: serialized.edges ?? [],
+      rootNodes: serialized.rootNodes ?? [],
+      createdAt: serialized.createdAt,
+      updatedAt: serialized.updatedAt
+    };
+  }
+};
+
+// src/goal/checkpoint.ts
+import * as fsp2 from "node:fs/promises";
+import * as path2 from "node:path";
+var CheckpointManager = class {
+  store;
+  maxCheckpoints;
+  maxCheckpointAgeMs;
+  checkpoints = /* @__PURE__ */ new Map();
+  baseDir;
+  constructor(opts) {
+    this.store = opts.store;
+    this.maxCheckpoints = opts.maxCheckpoints ?? 10;
+    this.maxCheckpointAgeMs = opts.maxCheckpointAgeMs ?? 7 * 24 * 60 * 60 * 1e3;
+    this.baseDir = opts.baseDir ?? path2.join(opts.store.baseDir, ".checkpoints");
+  }
+  async initialize() {
+    await fsp2.mkdir(this.baseDir, { recursive: true });
+    await this.loadFromDisk();
+  }
+  async saveCheckpoint(graph, label) {
+    await this.store.save(graph);
+    const activePhase = Array.from(graph.phases.values()).find(
+      (p) => p.status === "running" || p.status === "paused"
+    );
+    const checkpoint = {
+      id: crypto.randomUUID(),
+      graphId: graph.id,
+      phaseId: activePhase?.id ?? graph.rootPhaseIds[0] ?? "",
+      phaseStatus: activePhase?.status ?? "pending",
+      taskStatuses: activePhase ? Array.from(activePhase.taskGraph.nodes.values()).map((t) => ({
+        taskId: t.id,
+        status: t.status,
+        title: t.title
+      })) : [],
+      timestamp: Date.now(),
+      label
+    };
+    this.checkpoints.set(checkpoint.id, checkpoint);
+    await this.saveToDisk(checkpoint);
+    await this.pruneCheckpoints(graph.id);
+    return checkpoint;
+  }
+  async restoreCheckpoint(checkpointId) {
+    let checkpoint = this.checkpoints.get(checkpointId);
+    if (!checkpoint) {
+      await this.loadFromDisk();
+      checkpoint = this.checkpoints.get(checkpointId);
+    }
+    if (!checkpoint) return null;
+    const graph = await this.store.load(checkpoint.graphId);
+    if (!graph) return null;
+    const phase = graph.phases.get(checkpoint.phaseId);
+    if (phase) {
+      phase.status = checkpoint.phaseStatus;
+      phase.updatedAt = Date.now();
+      for (const ts of checkpoint.taskStatuses) {
+        const task = phase.taskGraph.nodes.get(ts.taskId);
+        if (task) {
+          task.status = ts.status;
+          task.updatedAt = Date.now();
+        }
+      }
+    }
+    graph.updatedAt = Date.now();
+    return graph;
+  }
+  listCheckpoints(graphId) {
+    const all = Array.from(this.checkpoints.values());
+    const filtered = graphId ? all.filter((c) => c.graphId === graphId) : all;
+    return filtered.sort((a, b) => b.timestamp - a.timestamp);
+  }
+  async deleteCheckpoint(checkpointId) {
+    const checkpoint = this.checkpoints.get(checkpointId);
+    if (!checkpoint) return false;
+    this.checkpoints.delete(checkpointId);
+    await this.deleteFromDisk(checkpointId);
+    return true;
+  }
+  async saveToDisk(checkpoint) {
+    const filePath = path2.join(this.baseDir, `${checkpoint.graphId}.json`);
+    const serialized = {
+      ...checkpoint
+    };
+    await withFileLock(filePath, async () => {
+      let existing = [];
+      try {
+        const raw = await fsp2.readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+          existing = parsed;
+        }
+      } catch {
+      }
+      existing.push(serialized);
+      await atomicWrite(filePath, JSON.stringify(existing, null, 2), { mode: 384 });
+    });
+  }
+  async deleteFromDisk(checkpointId) {
+    let entries;
+    try {
+      entries = await fsp2.readdir(this.baseDir);
+    } catch {
+      return;
+    }
+    for (const filename of entries) {
+      if (!filename.endsWith(".json")) continue;
+      const filePath = path2.join(this.baseDir, filename);
+      try {
+        await withFileLock(filePath, async () => {
+          const raw = await fsp2.readFile(filePath, "utf8");
+          const parsed = JSON.parse(raw);
+          if (!Array.isArray(parsed)) return;
+          const existing = parsed;
+          const filtered = existing.filter((c) => c.id !== checkpointId);
+          if (filtered.length !== existing.length) {
+            if (filtered.length === 0) {
+              await fsp2.unlink(filePath);
+            } else {
+              await atomicWrite(filePath, JSON.stringify(filtered, null, 2), { mode: 384 });
+            }
+          }
+        });
+      } catch {
+      }
+    }
+  }
+  async loadFromDisk() {
+    let entries;
+    try {
+      entries = await fsp2.readdir(this.baseDir);
+    } catch {
+      return;
+    }
+    for (const filename of entries) {
+      if (!filename.endsWith(".json")) continue;
+      const filePath = path2.join(this.baseDir, filename);
+      try {
+        const raw = await fsp2.readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) continue;
+        const checkpoints = parsed;
+        for (const sc of checkpoints) {
+          const checkpoint = {
+            id: sc.id,
+            graphId: sc.graphId,
+            phaseId: sc.phaseId,
+            phaseStatus: sc.phaseStatus,
+            taskStatuses: sc.taskStatuses,
+            timestamp: sc.timestamp,
+            label: sc.label
+          };
+          this.checkpoints.set(checkpoint.id, checkpoint);
+        }
+      } catch {
+      }
+    }
+  }
+  async pruneCheckpoints(graphId) {
+    const now = Date.now();
+    const graphCheckpoints = Array.from(this.checkpoints.values()).filter((checkpoint) => checkpoint.graphId === graphId).sort((a, b) => a.timestamp - b.timestamp);
+    for (const cp of graphCheckpoints) {
+      if (now - cp.timestamp > this.maxCheckpointAgeMs) {
+        this.checkpoints.delete(cp.id);
+        await this.deleteFromDisk(cp.id);
+      }
+    }
+    const remaining = Array.from(this.checkpoints.values()).filter((checkpoint) => checkpoint.graphId === graphId).sort((a, b) => a.timestamp - b.timestamp);
+    while (remaining.length > this.maxCheckpoints) {
+      const oldest = remaining.shift();
+      if (oldest) {
+        this.checkpoints.delete(oldest.id);
+        await this.deleteFromDisk(oldest.id);
+      }
+    }
+  }
+};
+
+export {
+  PhaseGraphBuilder,
+  PhaseOrchestrator,
+  GoalRunner,
+  createGoalRunnerFromTaskGraph,
+  GoalPlanner,
+  extractJSONArray,
+  GoalAssessor,
+  PHASE_EVENT_NAMES,
+  PhaseStore,
+  CheckpointManager
+};
+//# sourceMappingURL=chunk-XQ2XGIBF.js.map