@wrongstack/core 0.313.0 → 0.313.1

package/dist/tasking/index.js

@@ -1,679 +1,13 @@
-// 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";
-  }
-};
-
-// 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
-  };
-}
-function topologicalSort(graph) {
-  const visited = /* @__PURE__ */ new Set();
-  const inStack = /* @__PURE__ */ new Set();
-  const result = [];
-  function visit(id) {
-    if (inStack.has(id)) return;
-    if (visited.has(id)) return;
-    if (!graph.nodes.has(id)) return;
-    visited.add(id);
-    inStack.add(id);
-    for (const edge of graph.edges) {
-      if (edge.from === id) visit(edge.to);
-    }
-    inStack.delete(id);
-    result.push(id);
-  }
-  for (const rootId of graph.rootNodes) {
-    visit(rootId);
-  }
-  return result;
-}
-function serializeTaskGraph(graph) {
-  return {
-    ...graph,
-    nodes: Array.from(graph.nodes.values())
-  };
-}
-function deserializeTaskGraph(input) {
-  const nodes = /* @__PURE__ */ new Map();
-  if (Array.isArray(input.nodes)) {
-    for (const entry of input.nodes) {
-      if (Array.isArray(entry)) nodes.set(entry[0], { ...entry[1], id: entry[1].id || entry[0] });
-      else nodes.set(entry.id, entry);
-    }
-  } else {
-    for (const [id, node] of Object.entries(input.nodes)) {
-      nodes.set(id, { ...node, id: node.id || id });
-    }
-  }
-  return { ...input, nodes };
-}
-
-// 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;
-  }
-}
+import {
+  DefaultTaskStore,
+  TaskTracker,
+  computeTaskProgress,
+  deserializeTaskGraph,
+  serializeTaskGraph,
+  topologicalSort
+} from "../chunk-K4YUNKU7.js";
+import "../chunk-WOEZV3Q4.js";
+import "../chunk-TBRL2RCC.js";
 export {
   DefaultTaskStore,
   TaskTracker,