@wrongstack/core 0.313.0 → 0.313.1

package/dist/goal/index.js

@@ -1,3439 +1,37 @@
-// src/tasking/task-store.ts
-var DefaultTaskStore = class {
-  graphs = /* @__PURE__ */ new Map();
-  async saveGraph(graph) {
-    this.graphs.set(graph.id, this.cloneGraph(graph));
-  }
-  async loadGraph(id) {
-    const graph = this.graphs.get(id);
-    return graph ? this.cloneGraph(graph) : null;
-  }
-  async listGraphs() {
-    return Array.from(this.graphs.values()).map((graph) => ({
-      id: graph.id,
-      title: graph.title,
-      updatedAt: graph.updatedAt
-    }));
-  }
-  async deleteGraph(id) {
-    this.graphs.delete(id);
-  }
-  cloneGraph(graph) {
-    return {
-      ...graph,
-      nodes: new Map(graph.nodes),
-      edges: [...graph.edges],
-      rootNodes: [...graph.rootNodes]
-    };
-  }
-};
-
-// src/utils/error.ts
-function toErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-
-// src/types/errors.ts
-var ERROR_CODES = {
-  // Provider
-  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
-  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
-  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
-  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
-  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
-  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
-  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
-  // Tool
-  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
-  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
-  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
-  TOOL_TIMEOUT: "TOOL_TIMEOUT",
-  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
-  // Config
-  CONFIG_INVALID: "CONFIG_INVALID",
-  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
-  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
-  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
-  // Plugin
-  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
-  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
-  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
-  // Agent
-  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
-  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
-  AGENT_ABORTED: "AGENT_ABORTED",
-  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
-  // Session
-  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
-  SESSION_CORRUPTED: "SESSION_CORRUPTED",
-  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
-  // Container / Registry
-  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
-  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
-  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
-  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
-  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
-  REGISTRY_INVALID: "REGISTRY_INVALID",
-  // File system
-  FS_READ_FAILED: "FS_READ_FAILED",
-  FS_WRITE_FAILED: "FS_WRITE_FAILED",
-  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
-  FS_DELETE_FAILED: "FS_DELETE_FAILED",
-  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
-  // SDD (Spec-Driven Development)
-  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
-  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
-  SDD_INVALID_STATE: "SDD_INVALID_STATE",
-  SDD_NOT_READY: "SDD_NOT_READY",
-  // General
-  VALIDATION_ERROR: "VALIDATION_ERROR",
-  PARSE_FAILED: "PARSE_FAILED",
-  UNKNOWN: "UNKNOWN"
-};
-var WrongStackError = class extends Error {
-  code;
-  subsystem;
-  severity;
-  recoverable;
-  context;
-  constructor(opts) {
-    super(opts.message, { cause: opts.cause });
-    this.name = "WrongStackError";
-    this.code = opts.code;
-    this.subsystem = opts.subsystem;
-    this.severity = opts.severity ?? "error";
-    this.recoverable = opts.recoverable ?? false;
-    this.context = opts.context;
-  }
-  /**
-   * Render a one-line user-facing description.
-   * Subclasses should override for domain-specific formatting.
-   */
-  describe() {
-    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
-    return `${this.code}: ${this.message}${ctx}`;
-  }
-};
-function formatContext(ctx) {
-  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
-  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
-}
-var SddError = class extends WrongStackError {
-  constructor(opts) {
-    super({
-      message: opts.message,
-      code: opts.code,
-      subsystem: "sdd",
-      severity: opts.code === ERROR_CODES.SDD_PARSE_FAILED ? "warning" : "error",
-      recoverable: opts.code === ERROR_CODES.SDD_NOT_READY,
-      context: opts.context,
-      cause: opts.cause
-    });
-    this.name = "SddError";
-  }
-};
-var FsError = class extends WrongStackError {
-  path;
-  constructor(opts) {
-    super({
-      message: opts.message,
-      code: opts.code,
-      subsystem: "fs",
-      severity: "error",
-      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
-      context: { path: opts.path, ...opts.context },
-      cause: opts.cause
-    });
-    this.name = "FsError";
-    this.path = opts.path;
-  }
-};
-
-// src/types/task-graph.ts
-function computeTaskProgress(graph) {
-  let completed = 0;
-  let pending = 0;
-  let inProgress = 0;
-  let blocked = 0;
-  let failed = 0;
-  let review = 0;
-  let estimatedHours = 0;
-  let actualHours = 0;
-  for (const n of graph.nodes.values()) {
-    switch (n.status) {
-      case "completed":
-        completed++;
-        break;
-      case "pending":
-        pending++;
-        break;
-      case "in_progress":
-        inProgress++;
-        break;
-      case "blocked":
-        blocked++;
-        break;
-      case "failed":
-        failed++;
-        break;
-      case "review":
-        review++;
-        break;
-    }
-    estimatedHours += n.estimateHours ?? 0;
-    actualHours += n.actualHours ?? 0;
-  }
-  const total = graph.nodes.size;
-  return {
-    total,
-    pending,
-    inProgress,
-    blocked,
-    failed,
-    review,
-    completed,
-    percentComplete: total > 0 ? Math.round(completed / total * 100) : 0,
-    estimatedHours,
-    actualHours
-  };
-}
-
-// src/tasking/task-tracker.ts
-var TaskTracker = class _TaskTracker {
-  constructor(opts) {
-    this.opts = opts;
-  }
-  opts;
-  graph = null;
-  transitions = [];
-  listeners = [];
-  /**
-   * Re-entrancy guard for status cascades: true while an auto-block /
-   * auto-unblock cascade is running. Listener-driven mutations during a
-   * cascade still record their own primary transition — only their
-   * cascading is skipped (prevents unbounded recursion).
-   */
-  cascading = false;
-  static MAX_TRANSITIONS = 1e4;
-  /**
-   * Subscribe to live task mutations (add / update / status change). Returns an
-   * unsubscribe fn. This is the hook the board projector uses to stream a live
-   * snapshot — the tracker was previously fire-and-forget with no observability.
-   */
-  subscribe(listener) {
-    this.listeners.push(listener);
-    return () => {
-      const i = this.listeners.indexOf(listener);
-      if (i >= 0) this.listeners.splice(i, 1);
-    };
-  }
-  notifyChange(change) {
-    for (const l of this.listeners) {
-      try {
-        l(change);
-      } catch {
-      }
-    }
-  }
-  /**
-   * Attach an existing graph (used by PhaseOrchestrator to associate a tracker
-   * with a phase's pre-built task graph without re-creating it).
-   */
-  setGraph(graph) {
-    this.graph = graph;
-  }
-  async createGraph(specId, title) {
-    this.graph = {
-      id: crypto.randomUUID(),
-      specId,
-      title,
-      nodes: /* @__PURE__ */ new Map(),
-      edges: [],
-      rootNodes: [],
-      createdAt: Date.now(),
-      updatedAt: Date.now()
-    };
-    await this.opts.store.saveGraph(this.graph);
-    return this.graph;
-  }
-  async loadGraph(id) {
-    this.graph = await this.opts.store.loadGraph(id);
-    return this.graph;
-  }
-  addNode(node) {
-    if (!this.graph)
-      throw new SddError({
-        message: "No graph loaded",
-        code: ERROR_CODES.SDD_INVALID_STATE
-      });
-    const now = Date.now();
-    const newNode = {
-      ...node,
-      id: crypto.randomUUID(),
-      status: node.status ?? "pending",
-      createdAt: now,
-      updatedAt: now
-    };
-    this.graph.nodes.set(newNode.id, newNode);
-    if (!node.parentId) {
-      this.graph.rootNodes.push(newNode.id);
-    }
-    this.graph.updatedAt = now;
-    this.persist();
-    this.notifyChange({ type: "node_added", nodeId: newNode.id, node: newNode });
-    return newNode;
-  }
-  addEdge(from, to, type = "depends_on") {
-    if (!this.graph)
-      throw new SddError({
-        message: "No graph loaded",
-        code: ERROR_CODES.SDD_INVALID_STATE
-      });
-    if (!this.graph.nodes.has(from) || !this.graph.nodes.has(to)) {
-      throw new SddError({
-        message: `Cannot add ${type} edge ${from} -> ${to}: endpoint task is not in the graph`,
-        code: ERROR_CODES.SDD_NOT_READY,
-        context: { from, to, type }
-      });
-    }
-    if (from === to) {
-      throw new SddError({
-        message: `Cannot add ${type} edge: self-loop on task ${from}`,
-        code: ERROR_CODES.SDD_INVALID_STATE,
-        context: { nodeId: from, type }
-      });
-    }
-    if (this.graph.edges.some((e) => e.from === from && e.to === to && e.type === type)) return;
-    if (type === "depends_on" && this.dependsOnTransitively(from, to, /* @__PURE__ */ new Set())) {
-      throw new SddError({
-        message: `Cannot add depends_on edge ${from} -> ${to}: it would create a dependency cycle`,
-        code: ERROR_CODES.SDD_INVALID_STATE,
-        context: { from, to }
-      });
-    }
-    this.graph.edges.push({
-      id: crypto.randomUUID(),
-      from,
-      to,
-      type
-    });
-    this.graph.updatedAt = Date.now();
-    this.persist();
-  }
-  /**
-   * Declare that `taskId` depends on `depId` (a `depends_on` edge `depId → taskId`),
-   * guarding against self-loops, duplicates, missing nodes, and cycles. Returns
-   * true if the dependency now holds (added or already present), false if it was
-   * rejected (would create a cycle / unknown node). This is the safe entry point
-   * for wiring agent-declared `dependsOn` references into the graph.
-   */
-  addDependency(depId, taskId) {
-    if (!this.graph) return false;
-    if (depId === taskId) return false;
-    if (!this.graph.nodes.has(depId) || !this.graph.nodes.has(taskId)) return false;
-    if (this.getBlockers(taskId).includes(depId)) return true;
-    if (this.dependsOnTransitively(depId, taskId, /* @__PURE__ */ new Set())) return false;
-    this.addEdge(depId, taskId, "depends_on");
-    return true;
-  }
-  /** True when `taskId` transitively depends on `targetId` (follows depends_on blockers). */
-  dependsOnTransitively(taskId, targetId, seen) {
-    if (taskId === targetId) return true;
-    if (seen.has(taskId)) return false;
-    seen.add(taskId);
-    for (const blocker of this.getBlockers(taskId)) {
-      if (this.dependsOnTransitively(blocker, targetId, seen)) return true;
-    }
-    return false;
-  }
-  /**
-   * Merge `patch` into a node's `metadata` (used for per-task model/provider/
-   * fallback assignment and the cancel marker). Persists + notifies as a node
-   * update. No-op if the node is missing.
-   */
-  patchMetadata(id, patch) {
-    if (!this.graph) return;
-    const node = this.graph.nodes.get(id);
-    if (!node) return;
-    node.metadata = { ...node.metadata, ...patch };
-    node.updatedAt = Date.now();
-    this.graph.updatedAt = node.updatedAt;
-    this.persist();
-    this.notifyChange({ type: "node_updated", nodeId: id, node });
-  }
-  /**
-   * Remove a node and every edge touching it. Intended for deleting a task that
-   * has not started yet — callers must gate on status (do not remove a running
-   * task). Dependents simply lose this blocker (re-evaluated by `canStart`).
-   * Returns true if a node was removed.
-   */
-  removeNode(id) {
-    if (!this.graph) return false;
-    const node = this.graph.nodes.get(id);
-    if (!node) return false;
-    if (node.specRequirementId && this.graph.requiredRequirementIds?.includes(node.specRequirementId) && !Array.from(this.graph.nodes.values()).some(
-      (candidate) => candidate.id !== id && candidate.specRequirementId === node.specRequirementId
-    )) {
-      return false;
-    }
-    this.graph.nodes.delete(id);
-    this.graph.edges = this.graph.edges.filter((e) => e.from !== id && e.to !== id);
-    this.graph.rootNodes = this.graph.rootNodes.filter((r) => r !== id);
-    for (const n of this.graph.nodes.values()) {
-      if (n.children?.includes(id)) n.children = n.children.filter((c) => c !== id);
-    }
-    this.graph.updatedAt = Date.now();
-    this.persist();
-    this.notifyChange({ type: "node_removed", nodeId: id, node });
-    return true;
-  }
-  updateNodeStatus(id, status, reason) {
-    if (!this.graph)
-      throw new SddError({
-        message: "No graph loaded",
-        code: ERROR_CODES.SDD_INVALID_STATE
-      });
-    const node = this.graph.nodes.get(id);
-    if (!node)
-      throw new SddError({
-        message: `Node ${id} not found`,
-        code: ERROR_CODES.SDD_NOT_READY,
-        context: { nodeId: id }
-      });
-    const from = node.status;
-    const now = Date.now();
-    node.status = status;
-    node.updatedAt = now;
-    if (status === "completed") {
-      node.completedAt = now;
-      node.startedAt = node.startedAt ?? now;
-    }
-    if (status === "in_progress") {
-      node.startedAt = now;
-    }
-    this.transitions.push({ nodeId: id, from, to: status, timestamp: now, reason });
-    if (this.transitions.length > _TaskTracker.MAX_TRANSITIONS) {
-      this.transitions.splice(0, this.transitions.length - _TaskTracker.MAX_TRANSITIONS);
-    }
-    if (status === "completed") {
-      this.unblockDependents(id);
-    }
-    if (status === "in_progress") {
-      this.checkAndBlockIfNeeded(id);
-    }
-    this.graph.updatedAt = now;
-    this.persist();
-    this.notifyChange({
-      type: "status_changed",
-      nodeId: id,
-      node,
-      transition: { nodeId: id, from, to: status, timestamp: now, reason }
-    });
-  }
-  updateNode(id, patch) {
-    if (!this.graph)
-      throw new SddError({
-        message: "No graph loaded",
-        code: ERROR_CODES.SDD_INVALID_STATE
-      });
-    const node = this.graph.nodes.get(id);
-    if (!node)
-      throw new SddError({
-        message: `Node ${id} not found`,
-        code: ERROR_CODES.SDD_NOT_READY,
-        context: { nodeId: id }
-      });
-    if (patch.title !== void 0) node.title = patch.title;
-    if (patch.description !== void 0) node.description = patch.description;
-    if (patch.priority !== void 0) node.priority = patch.priority;
-    if (patch.estimateHours !== void 0) node.estimateHours = patch.estimateHours;
-    if (patch.tags !== void 0) node.tags = patch.tags;
-    if (patch.assignee !== void 0) node.assignee = patch.assignee;
-    node.updatedAt = Date.now();
-    this.graph.updatedAt = node.updatedAt;
-    this.persist();
-    this.notifyChange({ type: "node_updated", nodeId: id, node });
-  }
-  getNode(id) {
-    return this.graph?.nodes.get(id);
-  }
-  getAllNodes(filter, sort) {
-    if (!this.graph) return [];
-    let nodes = Array.from(this.graph.nodes.values());
-    if (filter) {
-      nodes = nodes.filter((n) => {
-        if (filter.status?.length && !filter.status.includes(n.status)) return false;
-        if (filter.priority?.length && !filter.priority.includes(n.priority)) return false;
-        if (filter.type?.length && !filter.type.includes(n.type)) return false;
-        if (filter.assignee?.length && n.assignee && !filter.assignee.includes(n.assignee))
-          return false;
-        if (filter.tags?.length && n.tags && !n.tags.some((t) => filter.tags?.includes(t)))
-          return false;
-        if (filter.specRequirementId && n.specRequirementId !== filter.specRequirementId)
-          return false;
-        return true;
-      });
-    }
-    if (sort) {
-      nodes.sort((a, b) => {
-        const cmp = compareByField(a, b, sort.field);
-        return sort.direction === "asc" ? cmp : -cmp;
-      });
-    }
-    return nodes;
-  }
-  getChildren(parentId) {
-    if (!this.graph) return [];
-    return Array.from(this.graph.nodes.values()).filter((n) => n.parentId === parentId);
-  }
-  getDependents(taskId) {
-    if (!this.graph) return [];
-    return this.graph.edges.filter((e) => e.from === taskId && e.type === "depends_on").map((e) => e.to);
-  }
-  getBlockers(taskId) {
-    if (!this.graph) return [];
-    return this.graph.edges.filter((e) => e.to === taskId && e.type === "depends_on").map((e) => e.from);
-  }
-  canStart(taskId) {
-    const blockers = this.getBlockers(taskId);
-    return blockers.every((id) => {
-      const node = this.graph?.nodes.get(id);
-      return node?.status === "completed" || node?.status === "failed";
-    });
-  }
-  getProgress() {
-    if (!this.graph) {
-      return {
-        total: 0,
-        pending: 0,
-        inProgress: 0,
-        blocked: 0,
-        failed: 0,
-        review: 0,
-        completed: 0,
-        percentComplete: 0,
-        estimatedHours: 0,
-        actualHours: 0
-      };
-    }
-    return computeTaskProgress(this.graph);
-  }
-  /**
-   * Recorded transitions in insertion order (oldest first — the array is
-   * trimmed from the front). With `taskId`, only that task's transitions are
-   * returned, still oldest-first; a consumer wanting newest-first reverses
-   * the result. Per-task filtering is possible because every TaskTransition
-   * carries `nodeId` (BIZ-005).
-   */
-  getTransitions(taskId) {
-    return taskId === void 0 ? [...this.transitions] : this.transitions.filter((t) => t.nodeId === taskId);
-  }
-  /**
-   * Record a cascade-driven status change (BIZ-003): mutate the node, push a
-   * TaskTransition, persist, and notify subscribers — the same effects an
-   * explicit updateNodeStatus produces — so the board projector's live
-   * snapshot and the transition log observe auto-block/auto-unblock.
-   */
-  recordCascadeStatusChange(nodeId, node, to, reason) {
-    const from = node.status;
-    if (from === to) return;
-    const now = Date.now();
-    node.status = to;
-    node.updatedAt = now;
-    if (this.graph) this.graph.updatedAt = now;
-    this.transitions.push({ nodeId, from, to, timestamp: now, reason });
-    if (this.transitions.length > _TaskTracker.MAX_TRANSITIONS) {
-      this.transitions.splice(0, this.transitions.length - _TaskTracker.MAX_TRANSITIONS);
-    }
-    this.persist();
-    this.notifyChange({
-      type: "status_changed",
-      nodeId,
-      node,
-      transition: { nodeId, from, to, timestamp: now, reason }
-    });
-  }
-  unblockDependents(completedId) {
-    if (!this.graph || this.cascading) return;
-    this.cascading = true;
-    try {
-      const dependents = this.getDependents(completedId);
-      for (const depId of dependents) {
-        const dep = this.graph.nodes.get(depId);
-        if (dep?.status !== "blocked") continue;
-        const remainingBlockers = this.getBlockers(depId);
-        const allUnblocked = remainingBlockers.every((id) => {
-          const blocker = this.graph?.nodes.get(id);
-          return blocker?.status === "completed" || blocker?.status === "failed";
-        });
-        if (allUnblocked) {
-          this.recordCascadeStatusChange(
-            depId,
-            dep,
-            "pending",
-            `auto-unblocked: blocker ${completedId} reached a terminal state`
-          );
-        }
-      }
-    } finally {
-      this.cascading = false;
-    }
-  }
-  checkAndBlockIfNeeded(taskId) {
-    if (!this.graph || this.cascading) return;
-    this.cascading = true;
-    try {
-      const blockers = this.getBlockers(taskId);
-      const incomplete = blockers.filter((id) => {
-        const blocker = this.graph?.nodes.get(id);
-        return blocker?.status !== "completed" && blocker?.status !== "failed";
-      });
-      if (incomplete.length > 0) {
-        const node = this.graph.nodes.get(taskId);
-        if (node) {
-          this.recordCascadeStatusChange(
-            taskId,
-            node,
-            "blocked",
-            `auto-blocked: incomplete blocker(s) ${incomplete.join(", ")}`
-          );
-        }
-      }
-    } finally {
-      this.cascading = false;
-    }
-  }
-  /**
-   * Fire-and-forget persistence with attached error handler.
-   * Synchronous mutators (addNode/addEdge/updateNodeStatus) use this to
-   * avoid forcing an async cascade through every caller; if the store
-   * is missing or throwing, the error is surfaced via onPersistError.
-   */
-  persist() {
-    if (!this.graph) return;
-    this.opts.store.saveGraph(this.graph).catch((err) => {
-      this.opts.onPersistError ? this.opts.onPersistError(err) : console.warn(
-        JSON.stringify({
-          level: "warn",
-          event: "task_tracker.save_graph_failed",
-          message: toErrorMessage(err),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        })
-      );
-    });
-  }
-};
-var PRIORITY_RANK = {
-  critical: 0,
-  high: 1,
-  medium: 2,
-  low: 3
-};
-var STATUS_RANK = {
-  in_progress: 0,
-  pending: 1,
-  review: 2,
-  blocked: 3,
-  failed: 4,
-  completed: 5
-};
-function compareByField(a, b, field) {
-  switch (field) {
-    case "priority":
-      return PRIORITY_RANK[a.priority] - PRIORITY_RANK[b.priority];
-    case "status":
-      return STATUS_RANK[a.status] - STATUS_RANK[b.status];
-    case "createdAt":
-      return a.createdAt - b.createdAt;
-    case "updatedAt":
-      return a.updatedAt - b.updatedAt;
-  }
-}
-
-// 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/infrastructure/logger.ts
-import * as fsp from "node:fs/promises";
-import * as path from "node:path";
-
-// src/utils/term.ts
-var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
-function isStdoutTTY() {
-  return hasStdout() && Boolean(process.stdout.isTTY);
-}
-var activeOutputGuard = null;
-function writeTo(s, stream) {
-  if (!stream || typeof stream.write !== "function") return false;
-  const guard = activeOutputGuard;
-  if (!guard) {
-    stream.write(s);
-    return true;
-  }
-  guard.suspend();
-  stream.write(s);
-  guard.resume();
-  return true;
-}
-function writeErr(s, stream = process.stderr) {
-  return writeTo(s, stream);
-}
-var ESCAPE_TERMINATOR = Object.freeze({
-  BEL: "\x07",
-  // OSC 0 / OSC 2 (title)
-  ST: "\x1B\\"
-  // DCS / strict OSC
-});
-
-// src/utils/color.ts
-var isColorTty = () => {
-  if (envFlag(process.env.NO_COLOR)) return false;
-  if (envFlag(process.env.FORCE_COLOR)) return true;
-  return isStdoutTTY();
-};
-function envFlag(value) {
-  if (value === void 0) return false;
-  if (value.trim() === "") return false;
-  return !/^(0|false|no|off)$/i.test(value.trim());
-}
-var COLOR = isColorTty();
-var wrap = (open, close) => (s) => COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : s;
-var color = {
-  reset: wrap("0", "0"),
-  bold: wrap("1", "22"),
-  dim: wrap("2", "22"),
-  italic: wrap("3", "23"),
-  underline: wrap("4", "24"),
-  red: wrap("31", "39"),
-  green: wrap("32", "39"),
-  yellow: wrap("33", "39"),
-  blue: wrap("34", "39"),
-  magenta: wrap("35", "39"),
-  cyan: wrap("36", "39"),
-  gray: wrap("90", "39"),
-  amber: wrap("38;5;214", "39"),
-  pink: wrap("38;5;205", "39"),
-  bgRed: wrap("41", "49"),
-  bgGreen: wrap("42", "49")
-};
-
-// src/infrastructure/logger.ts
-var LEVEL_RANK = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-  trace: 4
-};
-var COLORS = {
-  error: color.red,
-  warn: color.yellow,
-  info: color.cyan,
-  debug: color.gray,
-  trace: color.dim
-};
-var LOG_LEVELS = /* @__PURE__ */ new Set(["error", "warn", "info", "debug", "trace"]);
-var LOG_FORMATS = /* @__PURE__ */ new Set(["pretty", "json"]);
-var DefaultLogger = class _DefaultLogger {
-  /** How many file writes between rotation size checks (statSync is not free). */
-  static ROTATE_CHECK_EVERY = 100;
-  static MAX_PENDING_FILE_WRITES = 2e3;
-  static MAX_PENDING_FILE_BYTES = 8 * 1024 * 1024;
-  level;
-  file;
-  bindings;
-  format;
-  stderr;
-  maxFileBytes;
-  writesSinceRotateCheck = 0;
-  /**
-   * Serialized async tail for file writes. Every appendFile (and any
-   * chained rotation) is awaited through this promise so file I/O
-   * never overlaps itself — preserving the per-line ordering the
-   * sync version had, but without blocking the caller thread. Any
-   * rejection is swallowed (`catch(() => {})`) because logging must
-   * never crash the host.
-   *
-   * Children share the parent's tail: `child.tail === parent.tail`
-   * for the lifetime of the chain. Read/write access goes through
-   * `_tail` so that, when a child has been wired to a parent, both
-   * `enqueueRotate` and `log` always observe the parent's current tail
-   * rather than a stale snapshot taken at `child()` time.
-   */
-  tail = Promise.resolve();
-  parent = null;
-  pendingFileWrites = 0;
-  pendingFileBytes = 0;
-  get root() {
-    return this.parent ? this.parent.root : this;
-  }
-  /**
-   * Resolve the current tail. For the root logger this is the field;
-   * for a child logger we always read through the parent so that a
-   * child's appends land on the parent's most recent tail, and a
-   * parent's `flush()` waits for everything the child chained.
-   */
-  get _tail() {
-    return this.parent ? this.parent._tail : this.tail;
-  }
-  set _tail(next) {
-    if (this.parent) this.parent.tail = next;
-    else this.tail = next;
-  }
-  constructor(opts = {}) {
-    this.level = opts.level ?? parseLogLevel(process.env.WRONGSTACK_LOG_LEVEL);
-    this.file = opts.file;
-    this.bindings = opts.bindings ?? {};
-    this.format = opts.format ?? parseLogFormat(process.env.WRONGSTACK_LOG_FORMAT);
-    this.stderr = opts.stderr !== false;
-    this.maxFileBytes = opts.maxFileBytes ?? 10 * 1024 * 1024;
-    if (this.file) {
-      const dir = path.dirname(this.file);
-      this._tail = this._tail.then(async () => {
-        await fsp.mkdir(dir, { recursive: true });
-      }).catch(() => void 0);
-    }
-  }
-  error(msg, ctx) {
-    this.log("error", msg, ctx);
-  }
-  warn(msg, ctx) {
-    this.log("warn", msg, ctx);
-  }
-  info(msg, ctx) {
-    this.log("info", msg, ctx);
-  }
-  debug(msg, ctx) {
-    this.log("debug", msg, ctx);
-  }
-  trace(msg, ctx) {
-    this.log("trace", msg, ctx);
-  }
-  child(bindings) {
-    const child = Object.create(_DefaultLogger.prototype);
-    child.level = this.level;
-    child.file = this.file;
-    child.bindings = { ...this.bindings, ...bindings };
-    child.format = this.format;
-    child.stderr = this.stderr;
-    child.maxFileBytes = this.maxFileBytes;
-    child.parent = this;
-    child.writesSinceRotateCheck = this.writesSinceRotateCheck;
-    return child;
-  }
-  /**
-   * Wait until all queued file writes (and any pending rotation) have
-   * completed. `log()` is fire-and-forget by design — the caller never
-   * blocks on disk — so tests, shutdown handlers, and processes that
-   * need a deterministic "everything is on disk now" guarantee should
-   * `await logger.flush()` before reading the file or exiting.
-   */
-  flush() {
-    return this._tail;
-  }
-  /**
-   * Size-based rotation: when the file outgrows `maxFileBytes`, rename it to
-   * `<file>.1` (dropping the previous `.1`) so the live file restarts empty.
-   * Checked on the first write and every ROTATE_CHECK_EVERY writes after.
-   * Best-effort: a rename can fail on Windows while another process holds
-   * the file — the next check retries. Multiple processes appending to the
-   * same log all run this check; whoever crosses the threshold first wins.
-   *
-   * Async: the rotation runs on the file-write tail (so its writes don't
-   * interleave with the next append), and the caller never blocks on a
-   * statSync / renameSync syscall on the hot log path.
-   */
-  enqueueRotate(file) {
-    if (this.writesSinceRotateCheck++ % _DefaultLogger.ROTATE_CHECK_EVERY !== 0) return;
-    this._tail = this._tail.then(async () => {
-      let st;
-      try {
-        st = await fsp.stat(file);
-      } catch {
-        return;
-      }
-      if (st.size < this.maxFileBytes) return;
-      try {
-        await fsp.rm(`${file}.1`, { force: true });
-        await fsp.rename(file, `${file}.1`);
-      } catch {
-      }
-    }).catch(() => void 0);
-  }
-  log(level, msg, ctx) {
-    const r = LEVEL_RANK[level];
-    const allowed = LEVEL_RANK[this.level];
-    if (r > allowed) return;
-    const ts = (/* @__PURE__ */ new Date()).toISOString();
-    const entry = { ts, level, msg, ...this.bindings };
-    if (ctx !== void 0) {
-      entry.ctx = ctx instanceof Error ? { message: ctx.message, stack: ctx.stack } : ctx;
-    }
-    if (this.file) {
-      const line = `${JSON.stringify(entry)}
-`;
-      const bytes = Buffer.byteLength(line, "utf8");
-      const root = this.root;
-      if (root.pendingFileWrites < _DefaultLogger.MAX_PENDING_FILE_WRITES && bytes <= _DefaultLogger.MAX_PENDING_FILE_BYTES && root.pendingFileBytes + bytes <= _DefaultLogger.MAX_PENDING_FILE_BYTES) {
-        root.pendingFileWrites += 1;
-        root.pendingFileBytes += bytes;
-        this.enqueueRotate(this.file);
-        this._tail = this._tail.then(() => fsp.appendFile(this.file, line, { mode: 384 })).catch(() => void 0).finally(() => {
-          root.pendingFileWrites = Math.max(0, root.pendingFileWrites - 1);
-          root.pendingFileBytes = Math.max(0, root.pendingFileBytes - bytes);
-        });
-      }
-    }
-    if (!this.stderr) return;
-    if (this.format === "json") {
-      writeErr(`${JSON.stringify(entry)}
-`);
-    } else {
-      const head = `${color.dim(ts)} ${COLORS[level](level.toUpperCase().padEnd(5))} ${msg}`;
-      if (ctx !== void 0) {
-        writeErr(`${head} ${formatCtx(ctx)}
-`);
-      } else {
-        writeErr(`${head}
-`);
-      }
-    }
-  }
-};
-function parseLogLevel(raw) {
-  return raw && LOG_LEVELS.has(raw) ? raw : "info";
-}
-function parseLogFormat(raw) {
-  return raw && LOG_FORMATS.has(raw) ? raw : "pretty";
-}
-function formatCtx(ctx) {
-  if (ctx instanceof Error) return color.dim(ctx.message);
-  if (typeof ctx === "string") return color.dim(ctx);
-  try {
-    return color.dim(JSON.stringify(ctx));
-  } catch {
-    return color.dim(String(ctx));
-  }
-}
-var noOpLogger = {
-  // 'error' is the quietest level the Logger contract offers; the methods
-  // discard everything regardless, this only matters to level checks.
-  level: "error",
-  error: () => {
-  },
-  warn: () => {
-  },
-  info: () => {
-  },
-  debug: () => {
-  },
-  trace: () => {
-  },
-  child: () => noOpLogger
-};
-
-// 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 resolve4 = 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 (resolve4 !== void 0) mergeOpts.resolve = resolve4;
-    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((resolve4) => {
-        const timer = setTimeout(() => {
-          timeoutController.abort();
-          resolve4(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((resolve4) => {
-      const timer = setTimeout(resolve4, 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((resolve4) => setTimeout(resolve4, 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/utils/instruction-file.ts
-import { readFileSync, statSync } from "node:fs";
-import * as path2 from "node:path";
-import { fileURLToPath } from "node:url";
-var textCache = /* @__PURE__ */ new Map();
-var rootCandidates;
-function readBundledInstructionText(relativePath) {
-  const cached = textCache.get(relativePath);
-  if (cached !== void 0) return cached;
-  let resolved = "";
-  for (const root of instructionRootCandidates()) {
-    try {
-      resolved = readFileSync(path2.join(root, relativePath), "utf8").trimEnd();
-      break;
-    } catch {
-    }
-  }
-  textCache.set(relativePath, resolved);
-  return resolved;
-}
-function renderInstructionTemplate(template, values) {
-  return template.replace(
-    /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g,
-    (match, key) => Object.hasOwn(values, key) ? values[key] ?? "" : match
-  );
-}
-function instructionRootCandidates() {
-  if (rootCandidates !== void 0) return rootCandidates;
-  const here = path2.dirname(fileURLToPath(import.meta.url));
-  const candidates = [
-    path2.resolve(here, "../../instructions"),
-    path2.resolve(here, "../instructions"),
-    path2.resolve(here, "instructions")
-  ];
-  rootCandidates = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
-  return rootCandidates;
-}
-function isDirectory(candidate) {
-  try {
-    return statSync(candidate).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-// 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 fsp2 from "node:fs/promises";
-import * as path3 from "node:path";
-
-// src/utils/atomic-write.ts
 import {
-  createPersistencePrimitives
-} from "@wrongstack/persistence";
-var primitives = createPersistencePrimitives({
-  createLockTimeoutError: ({ targetPath, timeoutMs }) => new FsError({
-    message: `Timed out waiting for file lock: ${targetPath}`,
-    code: "FS_ATOMIC_WRITE_FAILED",
-    path: targetPath,
-    context: { timeoutMs }
-  })
-});
-var atomicWrite = primitives.atomicWrite;
-var atomicReplaceWithWriter = primitives.atomicReplaceWithWriter;
-var ensureDir = primitives.ensureDir;
-var withFileLock = primitives.withFileLock;
-
-// src/goal/phase-store.ts
-var PHASE_STORE_VERSION = 1;
-var PhaseStore = class {
-  baseDir;
-  legacyBaseDirs;
-  constructor(opts) {
-    this.baseDir = opts.baseDir;
-    this.legacyBaseDirs = (opts.legacyBaseDirs ?? []).filter(
-      (dir) => path3.resolve(dir) !== path3.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 = path3.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) => path3.join(dir, `${graphId}.json`))
-    ];
-    await Promise.all(paths.map((filePath) => fsp2.unlink(filePath).catch(() => void 0)));
-  }
-  async list() {
-    try {
-      await this.migrateLegacyGraphs();
-      const entries = await fsp2.readdir(this.baseDir, { withFileTypes: true });
-      const graphs = [];
-      for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-        try {
-          const raw = await fsp2.readFile(path3.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 path3.join(this.baseDir, `${graphId}.json`);
-  }
-  async loadFromPath(filePath) {
-    try {
-      const raw = await fsp2.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 fsp2.readdir(legacyDir, { withFileTypes: true }).catch(() => []);
-      for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-        const legacyPath = path3.join(legacyDir, entry.name);
-        const currentPath = this.getFilePath(path3.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 fsp2.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async removeMigratedLegacyFile(legacyDir, legacyPath) {
-    await fsp2.unlink(legacyPath).catch(() => void 0);
-    await fsp2.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/storage/goal-store.ts
-import * as fsp3 from "node:fs/promises";
-
-// src/utils/wstack-paths.ts
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path4 from "node:path";
-function canonicalProjectRoot(absRoot) {
-  const checkoutRoot = path4.resolve(absRoot);
-  const dotGit = path4.join(checkoutRoot, ".git");
-  try {
-    if (!fs.statSync(dotGit).isFile()) return checkoutRoot;
-    const gitDirLine = fs.readFileSync(dotGit, "utf8").trim();
-    const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
-    if (!match?.[1]) return checkoutRoot;
-    const gitDir = path4.resolve(checkoutRoot, match[1].trim());
-    const commonDirFile = path4.join(gitDir, "commondir");
-    if (!fs.statSync(commonDirFile).isFile()) return checkoutRoot;
-    const commonDir = path4.resolve(gitDir, fs.readFileSync(commonDirFile, "utf8").trim());
-    const worktreesDir = path4.dirname(gitDir);
-    if (path4.basename(worktreesDir).toLowerCase() !== "worktrees") return checkoutRoot;
-    if (path4.resolve(worktreesDir, "..") !== commonDir) return checkoutRoot;
-    if (path4.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
-    return path4.dirname(commonDir);
-  } catch {
-    return checkoutRoot;
-  }
-}
-function projectHash(absRoot) {
-  return createHash("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
-}
-function projectSlug(absRoot) {
-  const identityRoot = canonicalProjectRoot(absRoot);
-  const base = slugify(path4.basename(identityRoot));
-  const hash = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
-  return `${base}-${hash}`;
-}
-function slugify(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
-}
-function safeProfileName(name) {
-  const safe = (name ?? "").replace(/[/\\:]/g, "_").replace(/\.\./g, "_").trim();
-  return safe || "default";
-}
-function bootstrapProfileName(globalRoot) {
-  try {
-    const parsed = JSON.parse(fs.readFileSync(path4.join(globalRoot, "config.json"), "utf8"));
-    return safeProfileName(
-      typeof parsed.activeProfile === "string" ? parsed.activeProfile : void 0
-    );
-  } catch {
-    return "default";
-  }
-}
-function wstackGlobalRoot() {
-  const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path4.resolve(fromEnv);
-  return path4.join(os.homedir(), ".wrongstack");
-}
-function resolveWstackPaths(opts) {
-  const globalRoot = opts.globalRoot ?? (opts.userHome ? path4.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
-  const homeDir = opts.userHome ?? os.homedir();
-  const profileName = safeProfileName(opts.profileName ?? bootstrapProfileName(globalRoot));
-  const profileDir = path4.join(globalRoot, "profiles", profileName);
-  const hash = projectHash(opts.projectRoot);
-  const slug = projectSlug(opts.projectRoot);
-  const projectDir = path4.join(globalRoot, "projects", slug);
-  return {
-    globalRoot,
-    profileName,
-    profileDir,
-    projectRoot: opts.projectRoot,
-    homeDir,
-    configDir: profileDir,
-    globalConfig: path4.join(globalRoot, "config.json"),
-    profilesDir: path4.join(globalRoot, "profiles"),
-    profileConfig: (name) => {
-      return path4.join(globalRoot, "profiles", safeProfileName(name), "config.json");
-    },
-    profileStatuslineConfig: (name) => {
-      return path4.join(globalRoot, "profiles", safeProfileName(name), "statusline.json");
-    },
-    profileModeConfig: (name) => {
-      return path4.join(globalRoot, "profiles", safeProfileName(name), "mode.json");
-    },
-    profileProviderStatus: (name) => {
-      return path4.join(globalRoot, "profiles", safeProfileName(name), "provider-status.json");
-    },
-    profileUpdateCache: (name) => {
-      return path4.join(globalRoot, "profiles", safeProfileName(name), "update-cache.json");
-    },
-    secretsKey: path4.join(globalRoot, ".key"),
-    globalMemory: path4.join(profileDir, "memory.md"),
-    globalSkills: path4.join(profileDir, "skills"),
-    globalClaudeSkills: path4.join(homeDir, ".claude", "skills"),
-    globalDesignKits: path4.join(profileDir, "design-kits"),
-    globalPrompts: path4.join(profileDir, "prompts"),
-    globalInstructions: path4.join(profileDir, "instructions"),
-    promptUsage: path4.join(profileDir, "prompt-usage.json"),
-    cacheDir: path4.join(globalRoot, "cache"),
-    modelsCache: path4.join(globalRoot, "cache", "models.dev.json"),
-    modelsOverlayCache: path4.join(globalRoot, "cache", "models-overlay.json"),
-    historyFile: path4.join(profileDir, "history"),
-    logFile: path4.join(globalRoot, "logs", "wrongstack.log"),
-    projectDir,
-    projectCodebaseIndex: path4.join(projectDir, "codebase-index"),
-    projectMemory: path4.join(projectDir, "memory.md"),
-    projectSessions: path4.join(projectDir, "sessions"),
-    projectTrust: path4.join(projectDir, "trust.json"),
-    projectMeta: path4.join(projectDir, "meta.json"),
-    projectLocalConfig: path4.join(projectDir, "config.local.json"),
-    inProjectConfig: path4.join(opts.projectRoot, ".wrongstack", "config.json"),
-    inProjectAgentsFile: path4.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
-    inProjectSkills: path4.join(opts.projectRoot, ".wrongstack", "skills"),
-    inProjectClaudeSkills: path4.join(opts.projectRoot, ".claude", "skills"),
-    inProjectPrompts: path4.join(opts.projectRoot, ".wrongstack", "prompts"),
-    inProjectInstructions: path4.join(opts.projectRoot, ".wrongstack", "instructions"),
-    inProjectDesignKits: path4.join(opts.projectRoot, ".wrongstack", "design-kits"),
-    inProjectWorktrees: path4.join(opts.projectRoot, ".wrongstack", "worktrees"),
-    projectHash: hash,
-    projectSlug: slug,
-    projectGoal: path4.join(projectDir, "goal.json"),
-    projectInputHistory: path4.join(projectDir, "input-history.json"),
-    projectSpecs: path4.join(projectDir, "specs"),
-    projectTaskGraphs: path4.join(projectDir, "task-graphs"),
-    projectSddSession: path4.join(projectDir, "sdd-session.json"),
-    projectPlan: path4.join(projectDir, "plan.json"),
-    projectAutophase: path4.join(projectDir, "autophase"),
-    projectSddBoards: path4.join(projectDir, "sdd-boards"),
-    projectRequirementIntakes: path4.join(projectDir, "requirement-intakes"),
-    syncConfig: path4.join(profileDir, "sync.json"),
-    configHistoryDir: path4.join(globalRoot, "config-history"),
-    projectStatus: (statusProjectSlug) => {
-      if (!/^[a-z0-9](?:[a-z0-9-]{0,39})-[a-f0-9]{6}$/.test(statusProjectSlug)) {
-        throw new Error(`Invalid project slug: ${statusProjectSlug}`);
-      }
-      return path4.join(globalRoot, "projects", statusProjectSlug, "status.json");
-    }
-  };
-}
-
-// src/storage/goal-store.ts
-var MAX_JOURNAL_ENTRIES = 500;
-function goalFilePath(projectRoot) {
-  return resolveWstackPaths({ projectRoot }).projectGoal;
-}
-async function loadGoal(filePath, events, warn) {
-  const t0 = Date.now();
-  let raw;
-  try {
-    raw = await fsp3.readFile(filePath, "utf8");
-  } catch (err) {
-    const code = err.code;
-    if (code === "ENOENT") {
-      events?.emit("storage.read", {
-        sessionId: "~boot~",
-        store: "goal",
-        filePath,
-        operation: "load",
-        outcome: "success",
-        durationMs: Date.now() - t0
-      });
-      return null;
-    }
-    events?.emit("storage.error", {
-      sessionId: "~boot~",
-      store: "goal",
-      filePath,
-      operation: "load",
-      error: toErrorMessage(err),
-      recoverable: false
-    });
-    throw err;
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed?.version !== 1 || typeof parsed.goal !== "string" || !Array.isArray(parsed.journal)) {
-      (warn ?? ((msg) => console.warn(JSON.stringify({ level: "warn", event: "goal_store.invalid_schema", path: filePath, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }))))(
-        "invalid schema \u2014 consider deleting and re-creating"
-      );
-      events?.emit("storage.read", {
-        sessionId: "~boot~",
-        store: "goal",
-        filePath,
-        operation: "load",
-        outcome: "failure",
-        durationMs: Date.now() - t0,
-        error: "invalid_schema"
-      });
-      return null;
-    }
-    events?.emit("storage.read", {
-      sessionId: "~boot~",
-      store: "goal",
-      filePath,
-      operation: "load",
-      outcome: "success",
-      durationMs: Date.now() - t0
-    });
-    return parsed;
-  } catch {
-    (warn ?? ((msg) => console.warn(JSON.stringify({ level: "warn", event: "goal_store.parse_failed", path: filePath, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }))))(
-      "JSON parse failed \u2014 consider deleting and re-creating"
-    );
-    events?.emit("storage.read", {
-      sessionId: "~boot~",
-      store: "goal",
-      filePath,
-      operation: "load",
-      outcome: "failure",
-      durationMs: Date.now() - t0,
-      error: "parse_failed"
-    });
-    return null;
-  }
-}
-async function saveGoal(filePath, goal, events) {
-  const t0 = Date.now();
-  try {
-    await atomicWrite(filePath, JSON.stringify(goal, null, 2), { mode: 384 });
-    events?.emit("storage.write", {
-      sessionId: "~boot~",
-      store: "goal",
-      filePath,
-      operation: "save",
-      outcome: "success",
-      durationMs: Date.now() - t0
-    });
-  } catch (err) {
-    events?.emit("storage.error", {
-      sessionId: "~boot~",
-      store: "goal",
-      filePath,
-      operation: "save",
-      error: toErrorMessage(err),
-      recoverable: false
-    });
-    throw new FsError({
-      message: toErrorMessage(err),
-      code: ERROR_CODES.FS_ATOMIC_WRITE_FAILED,
-      path: filePath,
-      cause: err
-    });
-  }
-}
-function emptyGoal(goal) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    version: 1,
-    goal,
-    setAt: now,
-    lastActivityAt: now,
-    iterations: 0,
-    engineState: "idle",
-    goalState: "active",
-    todoAttempts: {},
-    journal: []
-  };
-}
-function setProgress(goal, progress, note) {
-  const clamped = Math.min(100, Math.max(0, progress));
-  return {
-    ...goal,
-    progress: clamped,
-    progressNote: note ?? clamped + "% complete"
-  };
-}
-function appendJournal(goal, entry) {
-  const iteration = goal.iterations + 1;
-  const at = (/* @__PURE__ */ new Date()).toISOString();
-  const full = { ...entry, iteration, at };
-  const journal = [...goal.journal, full];
-  const trimmed = journal.length > MAX_JOURNAL_ENTRIES ? journal.slice(journal.length - MAX_JOURNAL_ENTRIES) : journal;
-  return {
-    ...goal,
-    iterations: iteration,
-    lastActivityAt: at,
-    journal: trimmed
-  };
-}
-function summarizeUsage(goal) {
-  let totalCostUsd = 0;
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  let iterationsWithUsage = 0;
-  for (const e of goal.journal) {
-    if (typeof e.costUsd === "number") totalCostUsd += e.costUsd;
-    if (e.tokens) {
-      totalInputTokens += e.tokens.input;
-      totalOutputTokens += e.tokens.output;
-    }
-    if (typeof e.costUsd === "number" || e.tokens) iterationsWithUsage++;
-  }
-  return { totalCostUsd, totalInputTokens, totalOutputTokens, iterationsWithUsage };
-}
-var DOLLAR = "$";
-function formatGoal(goal, journalLimit = 10) {
-  const lines = [];
-  const displayGoal = goal.refinedGoal || goal.goal;
-  lines.push(color.bold("Goal") + ": " + displayGoal);
-  if (goal.refinedGoal && goal.refinedGoal !== goal.goal) {
-    const snippet = goal.goal.length > 60 ? goal.goal.slice(0, 60) + "\u2026" : goal.goal;
-    lines.push(color.dim('  (original: "' + snippet + '")'));
-  }
-  if (typeof goal.progress === "number") {
-    const pct = Math.min(100, Math.max(0, Math.round(goal.progress)));
-    const filled = Math.round(pct / 5);
-    const empty = 20 - filled;
-    const bar = color.green("\u2588".repeat(filled)) + color.dim("\u2591".repeat(empty));
-    lines.push("Progress: " + bar + " " + color.bold(pct + "%"));
-    if (goal.progressNote) {
-      lines.push("  " + color.dim(goal.progressNote));
-    }
-    if (goal.progressTrend) {
-      const trendIcon = goal.progressTrend === "accelerating" ? "\u{1F680}" : goal.progressTrend === "stalling" ? "\u26A0\uFE0F" : "\u27A1\uFE0F";
-      lines.push("  Trend: " + trendIcon + " " + goal.progressTrend);
-    }
-  }
-  if (goal.deliverables && goal.deliverables.length > 0) {
-    lines.push("");
-    lines.push(color.bold("Deliverables:"));
-    for (const d of goal.deliverables) {
-      const done = /^\[[x✓]\]|✅|\(done\)/i.test(d);
-      const marker = done ? color.green("\u2713") : color.dim("\u25CB");
-      lines.push("  " + marker + " " + d);
-    }
-  }
-  lines.push("");
-  lines.push("Set: " + goal.setAt);
-  lines.push("Last activity: " + goal.lastActivityAt);
-  lines.push("Iterations: " + goal.iterations);
-  const stateLabel = goal.goalState ?? "active";
-  lines.push("State: " + stateLabel + (goal.iterations > 0 ? " (iteration #" + goal.iterations + ")" : ""));
-  lines.push("Engine: " + goal.engineState);
-  const usage = summarizeUsage(goal);
-  if (usage.iterationsWithUsage > 0) {
-    const spent = "Spent: " + DOLLAR + usage.totalCostUsd.toFixed(4) + "  (in " + usage.totalInputTokens + " / out " + usage.totalOutputTokens + " tokens across " + usage.iterationsWithUsage + " iterations)";
-    lines.push(spent);
-  }
-  if (goal.journal.length > 0) {
-    lines.push("");
-    lines.push("Recent journal (last " + Math.min(journalLimit, goal.journal.length) + "):");
-    const tail = goal.journal.slice(-journalLimit);
-    for (const e of tail) {
-      const mark = e.status === "success" ? "\u2713" : e.status === "failure" ? "\u2717" : e.status === "aborted" ? "\u2298" : "\xB7";
-      const note = e.note ? " \u2014 " + e.note : "";
-      const cost = typeof e.costUsd === "number" ? " (" + DOLLAR + e.costUsd.toFixed(4) + ")" : "";
-      lines.push("  #" + e.iteration + " " + mark + " [" + e.source + "] " + e.task + cost + note);
-    }
-  }
-  return lines.join("\n");
-}
-function parseProgressFromText(text) {
-  const re = /\[progress:\s*(\d{1,3})%\]\s*(?:[—-]\s*(.+))?/i;
-  const m = text.match(re);
-  if (!m) return null;
-  const progress = Math.min(100, Math.max(0, Number.parseInt(m[1] ?? "0", 10)));
-  const note = m[2]?.trim() || void 0;
-  return note === void 0 ? { progress } : { progress, note };
-}
-function recordProgress(goal, progress, note) {
-  const clamped = Math.min(100, Math.max(0, progress));
-  const history = [...goal.progressHistory ?? [], { at: (/* @__PURE__ */ new Date()).toISOString(), progress: clamped, note }];
-  const trimmed = history.length > 200 ? history.slice(-200) : history;
-  return {
-    ...goal,
-    progress: clamped,
-    progressNote: note ?? `${clamped}% complete`,
-    progressHistory: trimmed,
-    progressTrend: computeTrend(trimmed)
-  };
-}
-var MAX_PROGRESS_HISTORY = 200;
-function computeTrend(history) {
-  if (history.length < 3) return void 0;
-  const recent = history.slice(-5);
-  const deltas = [];
-  for (let i = 1; i < recent.length; i++) {
-    deltas.push((recent[i]?.progress ?? 0) - (recent[i - 1]?.progress ?? 0));
-  }
-  if (deltas.length < 2) return void 0;
-  const avgDelta = deltas.reduce((a, b) => a + b, 0) / deltas.length;
-  if (avgDelta > 2) return "accelerating";
-  if (avgDelta < -1) return "stalling";
-  return "steady";
-}
-
-// src/goal/checkpoint.ts
-import * as fsp4 from "node:fs/promises";
-import * as path5 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 ?? path5.join(opts.store.baseDir, ".checkpoints");
-  }
-  async initialize() {
-    await fsp4.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 = path5.join(this.baseDir, `${checkpoint.graphId}.json`);
-    const serialized = {
-      ...checkpoint
-    };
-    await withFileLock(filePath, async () => {
-      let existing = [];
-      try {
-        const raw = await fsp4.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 fsp4.readdir(this.baseDir);
-    } catch {
-      return;
-    }
-    for (const filename of entries) {
-      if (!filename.endsWith(".json")) continue;
-      const filePath = path5.join(this.baseDir, filename);
-      try {
-        await withFileLock(filePath, async () => {
-          const raw = await fsp4.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 fsp4.unlink(filePath);
-            } else {
-              await atomicWrite(filePath, JSON.stringify(filtered, null, 2), { mode: 384 });
-            }
-          }
-        });
-      } catch {
-      }
-    }
-  }
-  async loadFromDisk() {
-    let entries;
-    try {
-      entries = await fsp4.readdir(this.baseDir);
-    } catch {
-      return;
-    }
-    for (const filename of entries) {
-      if (!filename.endsWith(".json")) continue;
-      const filePath = path5.join(this.baseDir, filename);
-      try {
-        const raw = await fsp4.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);
-      }
-    }
-  }
-};
+  CheckpointManager,
+  GoalAssessor,
+  GoalPlanner,
+  GoalRunner,
+  PHASE_EVENT_NAMES,
+  PhaseGraphBuilder,
+  PhaseOrchestrator,
+  PhaseStore,
+  createGoalRunnerFromTaskGraph,
+  extractJSONArray
+} from "../chunk-XQ2XGIBF.js";
+import "../chunk-K4YUNKU7.js";
+import {
+  MAX_JOURNAL_ENTRIES,
+  MAX_PROGRESS_HISTORY,
+  appendJournal,
+  emptyGoal,
+  formatGoal,
+  goalFilePath,
+  loadGoal,
+  parseProgressFromText,
+  recordProgress,
+  saveGoal,
+  setProgress,
+  summarizeUsage
+} from "../chunk-LZDDLNCZ.js";
+import "../chunk-WBPVKEEE.js";
+import "../chunk-5S437PRC.js";
+import "../chunk-4VWO3ZXL.js";
+import "../chunk-7ZHZE5EO.js";
+import "../chunk-YNCVSFGF.js";
+import "../chunk-WOEZV3Q4.js";
+import "../chunk-TBRL2RCC.js";
 export {
   CheckpointManager,
   GoalAssessor,