@wrongstack/core 0.8.2 → 0.8.5

package/dist/{plan-templates-BnlpEkX8.d.ts → plan-templates-D8zQgZzc.d.ts}

@@ -2,7 +2,7 @@ import { E as EventBus } from './events-DyhxkstG.js';
 import { y as SessionStore, x as SessionMetadata, B as SessionWriter, r as ResumedSession, S as SessionData, z as SessionSummary, c as ContentBlock, w as SessionEvent, N as TodoItem, f as ConversationState } from './context-z2x5gv_V.js';
 import { e as AttachmentStore, A as AddAttachmentInput, d as AttachmentRef, a as Attachment } from './session-reader-DsadjyF9.js';
 import { b as MemoryStore, a as MemoryScope } from './memory-CEXuo7sz.js';
-import { a as WstackPaths } from './wstack-paths-gCrJ631C.js';
+import { a as WstackPaths } from './wstack-paths-Bxik3CsK.js';
 import { c as ConfigStore, a as Config, b as ConfigLoader } from './config-Bi4Q0fnz.js';
 import { S as SecretVault } from './secret-vault-DoISxaKO.js';
 

package/dist/sdd/index.d.ts

@@ -55,15 +55,16 @@ declare class TaskTracker {
     private graph;
     private transitions;
     constructor(opts: TaskTrackerOptions);
+    /**
+     * 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: TaskGraph): void;
     createGraph(specId: string, title: string): Promise<TaskGraph>;
     loadGraph(id: string): Promise<TaskGraph | null>;
     addNode(node: Omit<TaskNode, 'id' | 'createdAt' | 'updatedAt'>): TaskNode;
     addEdge(from: string, to: string, type?: TaskGraph['edges'][0]['type']): void;
     updateNodeStatus(id: string, status: TaskNode['status'], reason?: string): void;
-    /**
-     * Update node fields (title, description, priority, estimateHours, tags).
-     * Does NOT change status. Use updateNodeStatus for status changes.
-     */
     updateNode(id: string, patch: Partial<Pick<TaskNode, 'title' | 'description' | 'priority' | 'estimateHours' | 'tags'>>): void;
     getNode(id: string): TaskNode | undefined;
     getAllNodes(filter?: TaskFilter, sort?: TaskSort): TaskNode[];
@@ -72,15 +73,14 @@ declare class TaskTracker {
     getBlockers(taskId: string): string[];
     canStart(taskId: string): boolean;
     getProgress(): TaskProgress;
-    getTransitions(taskId?: string): TaskTransition[];
+    getTransitions(_taskId?: string): TaskTransition[];
     private unblockDependents;
     private checkAndBlockIfNeeded;
     /**
      * 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
-     * rejects, the configured `onPersistError` is invoked so failures are
-     * surfaced instead of swallowed by an unhandled promise rejection.
+     * is missing or throwing, the error is surfaced via onPersistError.
      */
     private persist;
 }

package/dist/sdd/index.js

@@ -581,6 +581,13 @@ var TaskTracker = class {
   opts;
   graph = null;
   transitions = [];
+  /**
+   * 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(),
@@ -653,10 +660,6 @@ var TaskTracker = class {
     this.graph.updatedAt = now;
     this.persist();
   }
-  /**
-   * Update node fields (title, description, priority, estimateHours, tags).
-   * Does NOT change status. Use updateNodeStatus for status changes.
-   */
   updateNode(id, patch) {
     if (!this.graph) throw new Error("No graph loaded");
     const node = this.graph.nodes.get(id);
@@ -734,8 +737,7 @@ var TaskTracker = class {
     }
     return computeTaskProgress(this.graph);
   }
-  getTransitions(taskId) {
-    if (!taskId) return [...this.transitions];
+  getTransitions(_taskId) {
     return [...this.transitions];
   }
   unblockDependents(completedId) {
@@ -775,18 +777,12 @@ var TaskTracker = class {
    * 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
-   * rejects, the configured `onPersistError` is invoked so failures are
-   * surfaced instead of swallowed by an unhandled promise rejection.
+   * is missing or throwing, the error is surfaced via onPersistError.
    */
   persist() {
     if (!this.graph) return;
     this.opts.store.saveGraph(this.graph).catch((err) => {
-      if (this.opts.onPersistError) this.opts.onPersistError(err);
-      else
-        console.warn(
-          "[task-tracker] saveGraph failed:",
-          err instanceof Error ? err.message : String(err)
-        );
+      this.opts.onPersistError ? this.opts.onPersistError(err) : console.warn("[task-tracker] saveGraph failed:", err instanceof Error ? err.message : String(err));
     });
   }
 };