@schoolai/shipyard 3.1.1-nightly.20260415.0 → 3.1.1

package/dist/index.js

@@ -106,7 +106,7 @@ async function handleSubcommand() {
     return true;
   }
   if (subcommand === "start") {
-    const { startCommand } = await import("./start-D67TQIGL.js");
+    const { startCommand } = await import("./start-63XQAT6J.js");
     await startCommand();
     return true;
   }
@@ -118,7 +118,7 @@ async function main() {
   const args = parseCliArgs();
   if (args.serve) {
     await loadAuthFromConfig(env);
-    const { serve } = await import("./serve-2F6SKPPO.js");
+    const { serve } = await import("./serve-HDRZ2CU6.js");
     return serve({ isDev: env.SHIPYARD_DEV });
   }
   logger.error("Use `shipyard start` to run the daemon. Use --help for usage.");

package/dist/{serve-2F6SKPPO.js → serve-HDRZ2CU6.js}

@@ -32301,7 +32301,8 @@ async function sweepStaleTasks(taskStateStore, taskManager, log) {
   const noBroadcast = { broadcast: false };
   for (const action of actions) {
     if (action.kind === "mark_input_required") {
-      await taskStateStore.sweepToInputRequired(action.taskId, noBroadcast);
+      await taskStateStore.updateTaskStatus(action.taskId, "input_required", noBroadcast);
+      await taskStateStore.acknowledge(action.taskId, noBroadcast);
       log({
         event: "stale_task_swept",
         taskId: action.taskId,
@@ -80372,9 +80373,9 @@ var StructuredTaskTracker = class {
   /**
    * Apply an overlay on top of CC tasks. Stores the overlay and re-flushes.
    */
-  applyOverlay(overlay, options) {
+  applyOverlay(overlay) {
     this.#currentOverlay = overlay;
-    this.#flushStructuredTasks(options);
+    this.#flushStructuredTasks();
   }
   processStructuredTaskEvents(content) {
     const events = extractStructuredTaskEvents(content);
@@ -80499,11 +80500,11 @@ var StructuredTaskTracker = class {
     applyDepEdgeAdditions(merged, overlay.depEdges);
     return merged;
   }
-  #flushStructuredTasks(options) {
+  #flushStructuredTasks() {
     const overlay = this.#currentOverlay ?? DEFAULT_TASK_OVERLAY;
     const merged = this.#applyOverlayToMap(this.#structuredTasks, overlay);
     const todoProgress = this.#computeTodoProgress(merged);
-    this.#deps.updateStructuredTasks(Object.fromEntries(merged), todoProgress, options);
+    this.#deps.updateStructuredTasks(Object.fromEntries(merged), todoProgress);
     if (!this.#suppressWriteThrough) {
       this.#ccTaskFileWriter?.writeMergedTasks(merged);
     }
@@ -82523,8 +82524,8 @@ Use this context to maintain continuity. You have already done this work \u2014
       }
     }
   }
-  applyOverlay(overlay, options) {
-    this.#structuredTaskTracker.applyOverlay(overlay, options);
+  applyOverlay(overlay) {
+    this.#structuredTaskTracker.applyOverlay(overlay);
   }
   /** ---------------------------------------------------------------- */
   /** Resource resolution                                              */
@@ -83201,8 +83202,7 @@ var TaskManager = class {
     this.#tasks.set(taskId, { taskId, channelId, cwd, mode, orchestrator });
     this.#flushPendingStreamSubs(taskId, orchestrator);
     this.#deps.taskStateStore.getTask(taskId).then((record) => {
-      if (record?.taskOverlay)
-        orchestrator.applyOverlay(record.taskOverlay, { preserveUpdatedAt: true });
+      if (record?.taskOverlay) orchestrator.applyOverlay(record.taskOverlay);
     }).catch((err) => {
       this.#deps.log({
         event: "overlay_restore_failed",
@@ -83567,13 +83567,8 @@ var TaskManager = class {
           });
         });
       },
-      updateStructuredTasks: (tasks, todoProgress, options) => {
-        this.#deps.taskStateStore.updateStructuredTasks(
-          taskId,
-          tasks,
-          todoProgress,
-          options ? { preserveUpdatedAt: options.preserveUpdatedAt } : void 0
-        ).catch((err) => {
+      updateStructuredTasks: (tasks, todoProgress) => {
+        this.#deps.taskStateStore.updateStructuredTasks(taskId, tasks, todoProgress).catch((err) => {
           this.#deps.log({
             event: "task_state_store_structured_tasks_failed",
             taskId,
@@ -83720,29 +83715,52 @@ function buildTaskStateStore(dataDir) {
       });
     },
     async updateTaskStatus(taskId, status, options) {
-      await safeUpdate(taskId, (task) => applyStatusTransition(task, status, Date.now()), options);
+      const task = await store.get(taskId);
+      if (!task) return;
+      pushBroadcast(options);
+      await store.set(taskId, applyStatusTransition(task, status, Date.now()));
     },
     async updateTitle(taskId, title, options) {
-      await safeUpdate(taskId, (task) => ({ ...task, title, updatedAt: Date.now() }), options);
+      const task = await store.get(taskId);
+      if (!task) return;
+      pushBroadcast(options);
+      await store.set(taskId, {
+        ...task,
+        title,
+        updatedAt: Date.now()
+      });
     },
     async updateCwd(taskId, cwd, options) {
-      await safeUpdate(taskId, (task) => ({ ...task, cwd, updatedAt: Date.now() }), options);
+      const task = await store.get(taskId);
+      if (!task) return;
+      pushBroadcast(options);
+      await store.set(taskId, {
+        ...task,
+        cwd,
+        updatedAt: Date.now()
+      });
     },
     async updateMode(taskId, mode, options) {
-      await safeUpdate(taskId, (task) => ({ ...task, mode, updatedAt: Date.now() }), options);
+      const task = await store.get(taskId);
+      if (!task) return;
+      pushBroadcast(options);
+      await store.set(taskId, {
+        ...task,
+        mode,
+        updatedAt: Date.now()
+      });
     },
     async updateTodoProgress(taskId, progress, options) {
-      await safeUpdate(
-        taskId,
-        (task) => ({
-          ...task,
-          todoCompleted: progress.todoCompleted,
-          todoTotal: progress.todoTotal,
-          currentActivity: progress.currentActivity,
-          updatedAt: Date.now()
-        }),
-        options
-      );
+      const task = await store.get(taskId);
+      if (!task) return;
+      pushBroadcast(options);
+      await store.set(taskId, {
+        ...task,
+        todoCompleted: progress.todoCompleted,
+        todoTotal: progress.todoTotal,
+        currentActivity: progress.currentActivity,
+        updatedAt: Date.now()
+      });
     },
     async acknowledge(taskId, options) {
       await safeUpdate(taskId, (task) => ({ ...task, acknowledgedAt: Date.now() }), options);
@@ -83751,42 +83769,39 @@ function buildTaskStateStore(dataDir) {
       await safeUpdate(taskId, (task) => ({ ...task, pinned: !task.pinned }), options);
     },
     async updateStructuredTasks(taskId, tasks, todoProgress, options) {
-      await safeUpdate(
-        taskId,
-        (task) => ({
-          ...task,
-          structuredTasks: tasks,
-          ...todoProgress && {
-            todoCompleted: todoProgress.todoCompleted,
-            todoTotal: todoProgress.todoTotal,
-            currentActivity: todoProgress.currentActivity
-          },
-          updatedAt: options?.preserveUpdatedAt ? task.updatedAt : Date.now()
-        }),
-        options
-      );
+      const task = await store.get(taskId);
+      if (!task) return;
+      pushBroadcast(options);
+      await store.set(taskId, {
+        ...task,
+        structuredTasks: tasks,
+        ...todoProgress && {
+          todoCompleted: todoProgress.todoCompleted,
+          todoTotal: todoProgress.todoTotal,
+          currentActivity: todoProgress.currentActivity
+        },
+        updatedAt: Date.now()
+      });
     },
     async updateTaskOverlay(taskId, overlay, options) {
-      await safeUpdate(
-        taskId,
-        (task) => ({
-          ...task,
-          taskOverlay: overlay,
-          updatedAt: options?.preserveUpdatedAt ? task.updatedAt : Date.now()
-        }),
-        options
-      );
+      const task = await store.get(taskId);
+      if (!task) return;
+      pushBroadcast(options);
+      await store.set(taskId, {
+        ...task,
+        taskOverlay: overlay,
+        updatedAt: Date.now()
+      });
     },
     async updateComposerSettings(taskId, settings, options) {
-      await safeUpdate(
-        taskId,
-        (task) => ({
-          ...task,
-          composerSettings: { ...task.composerSettings, ...settings },
-          updatedAt: Date.now()
-        }),
-        options
-      );
+      const task = await store.get(taskId);
+      if (!task) return;
+      pushBroadcast(options);
+      await store.set(taskId, {
+        ...task,
+        composerSettings: { ...task.composerSettings, ...settings },
+        updatedAt: Date.now()
+      });
     },
     async updateCostStats(taskId, stats, options) {
       await safeUpdate(
@@ -83812,27 +83827,12 @@ function buildTaskStateStore(dataDir) {
         options
       );
     },
-    async sweepToInputRequired(taskId, options) {
-      await safeUpdate(
-        taskId,
-        (task) => ({
-          ...task,
-          status: "input_required",
-          taskStartedAt: null
-        }),
-        options
-      );
-    },
     async getTask(taskId) {
       return store.get(taskId);
     },
     async listTasks() {
       return store.list();
     },
-    async listTasksWithVersion() {
-      const tasks = await store.list();
-      return { tasks, version: _version };
-    },
     subscribe(listener) {
       taskListeners.add(listener);
       return () => {
@@ -87328,11 +87328,12 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
         });
       },
       onRequestTaskIndex: () => {
-        daemon.taskStateStore.listTasksWithVersion().then(({ tasks, version }) => {
+        const snapshotVersion = daemon.taskStateStore.version;
+        daemon.taskStateStore.listTasks().then((tasks) => {
           controlHandler.sendControl({
             type: "task_index_snapshot",
             tasks,
-            version
+            version: snapshotVersion
           });
         }).catch((err) => {
           logAdapter({
@@ -87546,6 +87547,19 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
     }
   };
   pushMcpStatus(5);
+  const initialSnapshotVersion = daemon.taskStateStore.version;
+  daemon.taskStateStore.listTasks().then((tasks) => {
+    controlHandler.sendControl({
+      type: "task_index_snapshot",
+      tasks,
+      version: initialSnapshotVersion
+    });
+  }).catch((err) => {
+    logAdapter({
+      event: "task_index_initial_push_failed",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  });
   daemon.userSettingsStore.getSettings().then((settings) => {
     controlHandler.sendControl({ type: "user_settings_snapshot", settings });
   }).catch((err) => {
@@ -91682,4 +91696,4 @@ export {
   classifyLogLevel,
   serve
 };
-//# sourceMappingURL=serve-2F6SKPPO.js.map
+//# sourceMappingURL=serve-HDRZ2CU6.js.map