@schoolai/shipyard 3.2.3-rc.20260422.1 → 3.2.3-rc.20260422.2

package/dist/index.js

@@ -106,7 +106,7 @@ async function handleSubcommand() {
     return true;
   }
   if (subcommand === "start") {
-    const { startCommand } = await import("./start-FONQGWYX.js");
+    const { startCommand } = await import("./start-4KHICMP2.js");
     await startCommand();
     return true;
   }
@@ -123,7 +123,7 @@ async function main() {
   const args = parseCliArgs();
   if (args.serve) {
     await loadAuthFromConfig(env);
-    const { serve } = await import("./serve-KNOYKFPQ.js");
+    const { serve } = await import("./serve-3FTGY4YL.js");
     return serve({ isDev: env.SHIPYARD_DEV });
   }
   logger.error("Use `shipyard start` to run the daemon. Use --help for usage.");

package/dist/{serve-KNOYKFPQ.js → serve-3FTGY4YL.js}

@@ -87601,6 +87601,47 @@ ${conversationReplay}` : conversationReplay;
       }
     });
   }
+  /**
+   * Deduped append for echoed user messages. Browser-originated writes carry
+   * a correlationId so dedup catches the twin row via `corr:<id>`. Synthetic
+   * pushes (plan injection, side threads, model-set) have no correlationId —
+   * we pass `event.sdkUuid` so the `sdk:<uuid>` pass catches SDK replays
+   * instead of falling back to the 60s fingerprint window, which would
+   * wrongly collapse two distinct synthetic pushes with identical content.
+   */
+  async #handleUserMessageEcho(event) {
+    const echoMsgId = crypto.randomUUID();
+    const meta = this.#callbacks.onBeforeStoreUserMessage?.(event);
+    const result = await this.#config.store.appendMessageDeduped(
+      {
+        channelId: this.#config.channelId,
+        messageId: echoMsgId,
+        participantId: meta?.participantId ?? this.#config.humanParticipantId ?? PENDING_AGENT_PARTICIPANT_ID,
+        senderKind: "human",
+        content: meta?.content ?? event.content,
+        timestamp: Date.now(),
+        model: meta?.model ?? null,
+        reasoningEffort: meta?.reasoningEffort ?? null,
+        permissionMode: meta?.permissionMode ?? null,
+        ...meta?.isSynthetic && { isSynthetic: true },
+        ...meta?.correlationId && { correlationId: meta.correlationId },
+        ...event.sdkUuid && { sdkUuid: event.sdkUuid }
+      },
+      {}
+    );
+    if (result.isDuplicate) {
+      this.#config.log({
+        event: "thread_echo_dedup_hit",
+        threadId: this.#config.threadId,
+        dedupKey: result.dedupKey,
+        seqNo: result.seqNo
+      });
+    }
+    this.#callbacks.onMessageStored?.(result.seqNo, echoMsgId, "human", event.sdkUuid);
+    if (meta?.correlationId) {
+      this.#callbacks.onUserMessageConfirmed?.(meta.correlationId, event.sdkUuid);
+    }
+  }
   async #handleSubprocessEvent(event) {
     switch (event.type) {
       case "init_received":
@@ -87655,25 +87696,7 @@ ${conversationReplay}` : conversationReplay;
       case "rate_limit_error":
         break;
       case "user_message_echo": {
-        const echoMsgId = crypto.randomUUID();
-        const meta = this.#callbacks.onBeforeStoreUserMessage?.(event);
-        const echoSeqNo = await this.#config.store.appendMessage({
-          channelId: this.#config.channelId,
-          messageId: echoMsgId,
-          participantId: meta?.participantId ?? this.#config.humanParticipantId ?? PENDING_AGENT_PARTICIPANT_ID,
-          senderKind: "human",
-          content: meta?.content ?? event.content,
-          timestamp: Date.now(),
-          model: meta?.model ?? null,
-          reasoningEffort: meta?.reasoningEffort ?? null,
-          permissionMode: meta?.permissionMode ?? null,
-          ...meta?.isSynthetic && { isSynthetic: true },
-          ...meta?.correlationId && { correlationId: meta.correlationId }
-        });
-        this.#callbacks.onMessageStored?.(echoSeqNo, echoMsgId, "human", event.sdkUuid);
-        if (meta?.correlationId) {
-          this.#callbacks.onUserMessageConfirmed?.(meta.correlationId, event.sdkUuid);
-        }
+        await this.#handleUserMessageEcho(event);
         break;
       }
       case "assistant_message": {
@@ -89250,6 +89273,16 @@ var ResourcePushManager = class {
   #batchTimer;
   #pushCountThisTurn = 0;
   #pushedThisTurn = /* @__PURE__ */ new Set();
+  /**
+   * Ref-counted session-lifetime claims. Each `markPushed` increments;
+   * each `unmarkPushed` decrements. Entries are deleted when the count
+   * hits zero. Used for "inject exactly once per subprocess session"
+   * callers (the task-list prepend) where two concurrent paths (sync
+   * prepend + async push pipeline) may both legitimately claim the URI.
+   * A plain Set would let an optimistic claim's rollback erase another
+   * caller's successful mark; the ref count prevents that.
+   */
+  #pushedEverCount = /* @__PURE__ */ new Map();
   #disposed = false;
   #epoch = 0;
   #flushInProgress = Promise.resolve();
@@ -89302,12 +89335,46 @@ var ResourcePushManager = class {
     return this.#pushedThisTurn;
   }
   /**
-   * Mark a URI as already pushed this turn (e.g. when injected
-   * synchronously in handleBeforeSpawn rather than via the async
-   * push pipeline).
+   * Whether a URI has been pushed at least once this session. For one-shot
+   * callers (task-list prepend) to decide whether to inject again.
+   */
+  isSessionPushed(uri) {
+    return this.#pushedEverCount.has(uri);
+  }
+  /**
+   * Seed the session-lifetime claim for URIs already pushed in a prior
+   * daemon run (resumable_idle tasks whose JSONL already contains a
+   * prepend synthetic). Without this, restart re-injects the task-list
+   * because the fresh push manager has an empty count map.
+   */
+  seedSessionPushed(uri) {
+    if (!this.#pushedEverCount.has(uri)) this.#pushedEverCount.set(uri, 1);
+  }
+  /**
+   * Mark a URI as pushed this turn AND record a session-lifetime claim.
+   * Call from both the sync prepend (before awaiting resolve) and the
+   * async push pipeline (after a successful write). Pair each call with
+   * `unmarkPushed` only if the operation did NOT ultimately write.
    */
   markPushed(uri) {
     this.#pushedThisTurn.add(uri);
+    this.#pushedEverCount.set(uri, (this.#pushedEverCount.get(uri) ?? 0) + 1);
+  }
+  /**
+   * Release a `markPushed` claim. Decrements the session-lifetime count —
+   * the entry is only removed when the count hits zero, so a concurrent
+   * caller's successful write stays recorded even if this caller rolls
+   * back. Also clears the per-turn set unconditionally (a successful
+   * parallel caller re-adds it as needed before its own write).
+   */
+  unmarkPushed(uri) {
+    this.#pushedThisTurn.delete(uri);
+    const current2 = this.#pushedEverCount.get(uri) ?? 0;
+    if (current2 <= 1) {
+      this.#pushedEverCount.delete(uri);
+    } else {
+      this.#pushedEverCount.set(uri, current2 - 1);
+    }
   }
   /** Permanently shut down. Use reset() for clearSession. */
   dispose() {
@@ -89329,6 +89396,7 @@ var ResourcePushManager = class {
     this.#subscriptions.clear();
     this.#dirtyUris.clear();
     this.#pushedThisTurn.clear();
+    this.#pushedEverCount.clear();
     this.#pushCountThisTurn = 0;
   }
   #markDirty(uri) {
@@ -89439,35 +89507,11 @@ var ResourcePushManager = class {
     this.#batchTimer.reset();
     const batch = this.#drainDirtyBatch();
     if (!batch) return;
+    const markedUris = /* @__PURE__ */ new Set();
     try {
-      const resolved = await this.#resolveBatch(batch);
-      if (this.#disposed || this.#epoch !== startEpoch) return;
-      if (resolved.size === 0) {
-        if (this.#dirtyUris.size > 0) this.#batchTimer.schedule();
-        return;
-      }
-      const plan = await this.#planPush(resolved);
-      if (this.#disposed || this.#epoch !== startEpoch || plan.syntheticMessages.length === 0)
-        return;
-      const allContent = await this.#writeSynthetics(plan.syntheticMessages);
-      if (this.#disposed || this.#epoch !== startEpoch) return;
-      this.#deliverToSubprocess(allContent, resolved.size);
-      for (const uri of resolved.keys()) {
-        this.#pushedThisTurn.add(uri);
-      }
-      this.#deps.log({
-        event: "resource_push_delivered",
-        taskId: this.#deps.taskId,
-        uriCount: resolved.size
-      });
-      this.#deps.log({
-        event: "resource_push_flushed",
-        taskId: this.#deps.taskId,
-        uriCount: batch.size,
-        syntheticCount: plan.syntheticMessages.length,
-        pushCountThisTurn: this.#pushCountThisTurn
-      });
+      await this.#executeFlush(batch, startEpoch, markedUris);
     } catch (err) {
+      for (const uri of markedUris) this.unmarkPushed(uri);
       this.#requeueBatch(batch);
       this.#deps.log({
         event: "resource_push_flush_error",
@@ -89477,6 +89521,30 @@ var ResourcePushManager = class {
       });
     }
   }
+  async #executeFlush(batch, startEpoch, markedUris) {
+    const resolved = await this.#resolveBatch(batch);
+    if (this.#disposed || this.#epoch !== startEpoch) return;
+    if (resolved.size === 0) {
+      if (this.#dirtyUris.size > 0) this.#batchTimer.schedule();
+      return;
+    }
+    const plan = await this.#planPush(resolved);
+    if (this.#disposed || this.#epoch !== startEpoch || plan.syntheticMessages.length === 0) return;
+    for (const uri of resolved.keys()) {
+      this.markPushed(uri);
+      markedUris.add(uri);
+    }
+    const allContent = await this.#writeSynthetics(plan.syntheticMessages);
+    if (this.#disposed || this.#epoch !== startEpoch) return;
+    this.#deliverToSubprocess(allContent, resolved.size);
+    this.#deps.log({
+      event: "resource_push_flushed",
+      taskId: this.#deps.taskId,
+      uriCount: batch.size,
+      syntheticCount: plan.syntheticMessages.length,
+      pushCountThisTurn: this.#pushCountThisTurn
+    });
+  }
 };
 
 // src/services/rewind.ts
@@ -89625,10 +89693,10 @@ var RewindCheckpointHandler = class {
     this.#allCheckpointTurnNos = [...allTurnNos];
   }
   recordSeqNo(seqNo) {
-    this.#latestSeqNo = seqNo;
+    if (seqNo > this.#latestSeqNo) this.#latestSeqNo = seqNo;
   }
   recordSdkUuid(seqNo, sdkUuid) {
-    this.#seqNoToSdkUuid.set(seqNo, sdkUuid);
+    if (!this.#seqNoToSdkUuid.has(seqNo)) this.#seqNoToSdkUuid.set(seqNo, sdkUuid);
   }
   findSdkUuidForSeqNo(targetSeqNo) {
     let bestUuid = null;
@@ -92459,6 +92527,12 @@ function classifyRoiTransition(nextStatus, roiEverRan) {
   if (nextStatus === "in_progress") return "reset-cycle";
   return "nothing";
 }
+function isTaskListSynthetic(msg, taskUri) {
+  if (!msg.isSynthetic || msg.content.length !== 1) return false;
+  const block2 = msg.content[0];
+  if (!block2 || block2.type !== "resource") return false;
+  return "uri" in block2.resource && block2.resource.uri === taskUri;
+}
 var Task = class {
   #deps;
   #mainThread;
@@ -92594,6 +92668,8 @@ var Task = class {
           error: err instanceof Error ? err.message : String(err)
         });
       });
+      const seedPromise = this.#seedPushManagerFromHistory();
+      this.#hydrationPromise = this.#hydrationPromise ? this.#hydrationPromise.then(() => seedPromise) : seedPromise;
     }
     this.#subagentManager = new SubagentManager({
       taskId: deps.taskId,
@@ -93610,6 +93686,33 @@ var Task = class {
     if (!arr || arr.length === 0) return void 0;
     return arr.shift();
   }
+  /**
+   * Resume path: if a prior daemon run already injected the task-list for
+   * this channel, its synthetic row is in the JSONL. Seed the push manager
+   * so `#resolveTaskListPrepend`'s `isSessionPushed` guard matches on the
+   * first spawn — otherwise restart re-prepends, duplicating the chip and
+   * dumping the full resource text back into the agent's context.
+   *
+   * Chained into `#hydrationPromise` (which `#awaitHydration` blocks on at
+   * every spawn/flush entry point) so the seed completes before any
+   * caller reaches `#resolveTaskListPrepend`. A fire-and-forget scan would
+   * race against a fast-arriving first user message.
+   */
+  async #seedPushManagerFromHistory() {
+    const taskUri = buildTaskResourceUri(this.#deps.taskId);
+    try {
+      const msgs = await this.#deps.store.getMessages(this.#deps.channelId);
+      if (msgs.some((msg) => isTaskListSynthetic(msg, taskUri))) {
+        this.#pushManager.seedSessionPushed(taskUri);
+      }
+    } catch (err) {
+      this.#deps.log({
+        event: "push_manager_seed_failed",
+        taskId: this.#deps.taskId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
   async #awaitHydration() {
     if (this.#hydrationPromise) {
       await this.#hydrationPromise;
@@ -93730,10 +93833,12 @@ Use this context to maintain continuity. You have already done this work \u2014
     const registry = this.#deps.resourceRegistry;
     if (!registry) return null;
     const taskUri = buildTaskResourceUri(this.#deps.taskId);
-    if (this.#pushManager.getPushedUris().has(taskUri)) return null;
+    if (this.#pushManager.isSessionPushed(taskUri)) return null;
+    this.#pushManager.markPushed(taskUri);
+    let injected = false;
     try {
       const taskResource = await registry.resolve(taskUri);
-      if ("text" in taskResource && !taskResource.text.includes('task-count="0"')) {
+      if ("text" in taskResource && !taskResource.text.includes('<task-list task-count="0"')) {
         const rootMsg = buildRootMessage(
           taskUri,
           taskResource,
@@ -93748,10 +93853,12 @@ Use this context to maintain continuity. You have already done this work \u2014
           },
           [rootMsg]
         );
-        this.#pushManager.markPushed(taskUri);
+        injected = true;
         return rootMsg.content;
       }
     } catch {
+    } finally {
+      if (!injected) this.#pushManager.unmarkPushed(taskUri);
     }
     return null;
   }
@@ -94724,14 +94831,23 @@ function findSdkUuidForSeqNoInTask(tasks, taskId, seqNo) {
 // src/services/task/manager/task-manager-template.ts
 function buildInitialOverlayFromTemplate(template, now) {
   if (!template || template.items.length === 0) return void 0;
-  const userTasks = template.items.map((item2) => ({
-    id: item2.id,
+  const idRemap = new Map(template.items.map((item2, index) => [item2.id, String(index + 1)]));
+  const userTasks = template.items.map((item2, index) => ({
+    id: String(index + 1),
     subject: item2.content,
     description: item2.description,
     status: "pending",
     owner: "user",
     blocks: [],
-    blockedBy: item2.deps,
+    /**
+     * Drop deps pointing outside the template. Falling through the
+     * original colon-bearing ID would leave a dangling `blockedBy` that
+     * CC's TaskUpdate can't resolve — silently stuck in the UI.
+     */
+    blockedBy: item2.deps.flatMap((dep) => {
+      const mapped = idRemap.get(dep);
+      return mapped ? [mapped] : [];
+    }),
     createdAt: now,
     updatedAt: now
   }));
@@ -105833,4 +105949,4 @@ export {
   _testing,
   serve
 };
-//# sourceMappingURL=serve-KNOYKFPQ.js.map
+//# sourceMappingURL=serve-3FTGY4YL.js.map