@schoolai/shipyard 3.2.0-rc.20260420.1 → 3.2.0

package/dist/{serve-FOWLAISV.js → serve-3EFFP3PN.js}

@@ -46,7 +46,7 @@ import {
   VaultKeyPutRequestSchema,
   VaultKeyPutResponseSchema,
   classifyClaudeCodeCompatibility
-} from "./chunk-MEIJOKPG.js";
+} from "./chunk-5SJBSLGT.js";
 import "./chunk-EHQITHQX.js";
 import {
   loadAuthToken
@@ -25381,7 +25381,7 @@ var FEATURE_WORK = {
     item(FEATURE_WORK_ID, 1, "Research the task", "Map the surface area before writing code. Identify critical files, existing patterns, edge cases, and gotchas. For larger tasks, spawn parallel Shipyard threads to explore independent sub-areas. Pin key findings on Shipyard's canvas so they stay visible during implementation.", []),
     item(FEATURE_WORK_ID, 2, "Plan the approach", "Iterate on an approach on Shipyard's canvas with diagrams, state machines, or data flow so architectural decisions persist through the work. For risky or test-heavy work, write a test spec up front to drive red-green-refactor.", [1]),
     item(FEATURE_WORK_ID, 3, "Sequence implementation", "Break the plan into parallelizable subtasks with explicit dependencies wired between them using TaskUpdate's addBlockedBy / addBlocks. Identify what can be done by parallel Shipyard threads versus what must happen sequentially.", [2]),
-    item(FEATURE_WORK_ID, 4, "Implementation", "Replace this placeholder with concrete implementation subtasks via TaskCreate. The new tasks should be blocked by (3) and should block (5). Delete this placeholder after inserting the real work.", [3]),
+    item(FEATURE_WORK_ID, 4, "Implementation \u2014 REPLACE this placeholder", "This is a placeholder, not the work itself. Before touching code, call TaskCreate to insert 2\u2013N concrete subtasks that describe what you'll actually build (file-by-file if useful). Each new task should be blocked by 'Sequence implementation' and should block 'QA'. Then mark this placeholder completed. Shipping without doing this means the work never appeared in the plan.", [3]),
     item(FEATURE_WORK_ID, 5, "QA", "Multi-pass review and fix until convergence. Parallel reviewers catch different issue classes: type holes, missed edge cases, race conditions, pattern drift. Use Shipyard's add_comment on diff hunks where reviewer judgment is useful. Keep running passes until no new issues surface.", [4]),
     item(FEATURE_WORK_ID, 6, "Ship", `Commit the work with a meaningful message, open a PR whose description explains the "why," push, and verify CI passes. Check pre-commit hooks and formatters run clean. Open the result in Shipyard's PR panel.`, [5]),
     item(FEATURE_WORK_ID, 7, "Tend PR", "Monitor CI checks and reviewer feedback in Shipyard's PR panel; fix failures and respond to each comment even if no code change is needed. Shepherd through merge.", [6])
@@ -25397,7 +25397,7 @@ var QUICK_TASK = {
   items: [
     item(QUICK_TASK_ID, 1, "Research the task", "Lightweight investigation: read the relevant files, understand the surrounding code, check for similar prior changes. Do not go deep unless the scope warrants it.", []),
     item(QUICK_TASK_ID, 2, "Sequence implementation", "Break into concrete subtasks with dependencies via TaskCreate and TaskUpdate's addBlockedBy. Even for small work, explicit steps help catch missed pieces.", [1]),
-    item(QUICK_TASK_ID, 3, "Implementation", "Replace this placeholder with the real subtasks via TaskCreate. Tasks blocked by (2), blocking (4). Delete this placeholder after inserting the real work.", [2]),
+    item(QUICK_TASK_ID, 3, "Implementation \u2014 REPLACE this placeholder", "This is a placeholder, not the work itself. Call TaskCreate to insert the real subtasks describing what you'll actually build. Each new task should be blocked by 'Sequence implementation' and block 'QA'. Mark this placeholder completed once replaced.", [2]),
     item(QUICK_TASK_ID, 4, "QA", "Quick review pass: type safety, pattern consistency, obvious issues. Use add_comment on hunks where feedback is needed. Skip multi-pass convergence if the change is trivial.", [3]),
     item(QUICK_TASK_ID, 5, "Ship", "Commit, open PR, push, verify CI. Open the result in Shipyard's PR panel.", [4]),
     item(QUICK_TASK_ID, 6, "Tend PR", "Monitor and shepherd to merge via Shipyard's PR panel. Respond to reviewer comments promptly.", [5])
@@ -25426,7 +25426,7 @@ var PARALLEL_REFACTOR = {
   description: "Refactor work that can fan out into independent parallel groups. Map the scope, spawn threads, integrate, and ship as one coherent PR (or stacked PRs).",
   items: [
     item(PARALLEL_REFACTOR_ID, 1, "Map the scope", "Understand which files, patterns, and call sites the refactor touches. Sketch group boundaries on Shipyard's canvas so parallel workers see the same source of truth. Each group should be self-contained \u2014 no cross-group file modifications.", []),
-    item(PARALLEL_REFACTOR_ID, 2, "Parallel implementation", "Replace this placeholder with 2-4 independent groups via TaskCreate, each spawned as a Shipyard thread. Groups blocked by (1), all blocking (3).", [1]),
+    item(PARALLEL_REFACTOR_ID, 2, "Parallel implementation \u2014 REPLACE with 2\u20134 parallel groups", "Call TaskCreate 2\u20134 times to insert independent parallel groups. Each group runs on its own thread via the Agent tool. Groups blocked by 'Map the scope', all block 'Integration pass'. Delete this placeholder after inserting the real work.", [1]),
     item(PARALLEL_REFACTOR_ID, 3, "Integration pass", "Resolve cross-group issues: type errors at interfaces, import ordering, pattern consistency. Rerun type checks across the whole codebase. Track any surfaced issues on Shipyard's canvas.", [2]),
     item(PARALLEL_REFACTOR_ID, 4, "QA", "Multi-pass review with add_comment annotations. Refactors have high regression risk; extra scrutiny on callers of changed signatures.", [3]),
     item(PARALLEL_REFACTOR_ID, 5, "Ship", "Commit per group or per theme. Stack if the refactor is large enough to warrant separate reviewable units. Open in Shipyard's PR panel.", [4]),
@@ -27288,7 +27288,7 @@ var TaskRecordSchema = external_exports.object({
   lastActivityAt: external_exports.number().default(0),
   appliedTemplateId: external_exports.string().optional()
 });
-var TASK_STORE_VERSION = 9;
+var TASK_STORE_VERSION = 10;
 var TaskStoreSchema = external_exports.object({
   schemaVersion: external_exports.number(),
   tasks: external_exports.record(external_exports.string(), TaskRecordSchema)
@@ -27302,8 +27302,26 @@ function migrateTaskStore(raw) {
   if (version < 5) {
     return { schemaVersion: TASK_STORE_VERSION, tasks: {} };
   }
+  if (version < 10) {
+    backfillLastActivityAt(prop(raw, "tasks"));
+  }
   return TaskStoreSchema.parse({ ...raw, schemaVersion: TASK_STORE_VERSION });
 }
+function backfillLastActivityAt(tasksRaw) {
+  if (typeof tasksRaw !== "object" || tasksRaw === null)
+    return;
+  for (const record of Object.values(tasksRaw)) {
+    if (typeof record !== "object" || record === null)
+      continue;
+    const existing = prop(record, "lastActivityAt");
+    if (typeof existing === "number" && existing !== 0)
+      continue;
+    const updated = prop(record, "updatedAt");
+    const created = prop(record, "createdAt");
+    const fallback = (typeof updated === "number" ? updated : 0) || (typeof created === "number" ? created : 0) || 0;
+    Object.assign(record, { lastActivityAt: fallback });
+  }
+}
 var TemplateItemSchema = external_exports.object({
   id: external_exports.string(),
   content: external_exports.string(),
@@ -27656,7 +27674,8 @@ var PermissionRequestPayloadSchema = external_exports.object({
   description: external_exports.string().optional(),
   agentId: external_exports.string(),
   ownerDisplayName: external_exports.string().optional(),
-  threadId: external_exports.string().optional()
+  threadId: external_exports.string().optional(),
+  targetParticipantId: external_exports.string().optional()
 });
 var CapabilitiesPayloadSchema = external_exports.object({
   models: external_exports.array(external_exports.object({
@@ -27838,7 +27857,8 @@ var BrowserToDaemonControlMessageSchema = external_exports.discriminatedUnion("t
     channelId: external_exports.string(),
     title: external_exports.string(),
     cwd: external_exports.string(),
-    mode: external_exports.enum(taskModes).default("task")
+    mode: external_exports.enum(taskModes).default("task"),
+    templateId: external_exports.string().optional()
   }),
   external_exports.object({
     type: external_exports.literal("promote_task"),
@@ -28030,6 +28050,13 @@ var RateLimitInfoSchema = external_exports.object({
 });
 var DaemonToBrowserControlMessageSchema = external_exports.discriminatedUnion("type", [
   external_exports.object({ type: external_exports.literal("permission_request") }).merge(PermissionRequestPayloadSchema),
+  external_exports.object({
+    type: external_exports.literal("permission_resolved"),
+    taskId: external_exports.string(),
+    toolUseId: external_exports.string(),
+    decision: PermissionDecisionSchema,
+    threadId: external_exports.string().optional()
+  }),
   external_exports.object({ type: external_exports.literal("capabilities"), capabilities: CapabilitiesPayloadSchema }),
   external_exports.object({
     type: external_exports.literal("rate_limit_info"),
@@ -31542,6 +31569,15 @@ function humanParticipantId(userId) {
 }
 function createPeerRoleRegistry() {
   const peers = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  function notify(peerId) {
+    for (const listener of listeners) {
+      try {
+        listener(peerId);
+      } catch {
+      }
+    }
+  }
   return {
     registerPersonalPeer(machineId, userId, displayName) {
       peers.set(machineId, {
@@ -31551,6 +31587,7 @@ function createPeerRoleRegistry() {
         displayName,
         taskId: null
       });
+      notify(machineId);
     },
     registerCollabPeer(peerId, role, userId, displayName, taskId) {
       peers.set(peerId, {
@@ -31560,6 +31597,7 @@ function createPeerRoleRegistry() {
         displayName,
         taskId
       });
+      notify(peerId);
     },
     unregisterPeer(peerId) {
       peers.delete(peerId);
@@ -31580,6 +31618,15 @@ function createPeerRoleRegistry() {
       const entry = peers.get(peerId);
       if (entry) return entry.participantId;
       return humanParticipantId("unknown");
+    },
+    isRegistered(peerId) {
+      return peers.has(peerId);
+    },
+    onRegister(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
     }
   };
 }
@@ -46954,6 +47001,14 @@ var VisualizationFileWatcher = class {
         content = "";
       }
     }
+    this.#sendControlMessage?.({
+      type: "viz_content",
+      taskId: effect.taskId,
+      slug: effect.slug,
+      vizType: effect.vizType,
+      title: effect.title,
+      content
+    });
     const data = { slug: effect.slug, title: effect.title };
     const nodeId = this.#deps.canvasRepo.createElement(effect.taskId, {
       type: effect.vizType,
@@ -46964,14 +47019,6 @@ var VisualizationFileWatcher = class {
       zIndex: position.zIndex,
       data
     });
-    this.#sendControlMessage?.({
-      type: "viz_content",
-      taskId: effect.taskId,
-      slug: effect.slug,
-      vizType: effect.vizType,
-      title: effect.title,
-      content
-    });
     const followUp = this.registry.setCanvasElementId(effect.slug, `${nodeId}`);
     await this.executeEffects(followUp);
   }
@@ -47165,6 +47212,142 @@ var VisualizationRegistry = class {
   }
 };
 
+// src/services/loro-awareness-sampler.ts
+var DEFAULT_SAMPLE_INTERVAL_MS = 6e4;
+function planAwarenessSnapshot(inputs) {
+  const events = [];
+  for (const doc3 of inputs.docs) {
+    const ourVersionBytes = safeEncodeVV(doc3.currentVersion);
+    if (ourVersionBytes === null) continue;
+    const ourVersion = bytesToBase64(ourVersionBytes);
+    for (const peer of inputs.peers) {
+      const awareness = peer.docSyncStates.get(doc3.docId);
+      if (!awareness) continue;
+      if (awareness.status !== "synced") continue;
+      const theirVersion = awareness.lastKnownVersion;
+      const theirBytes = safeEncodeVV(theirVersion);
+      const theirCachedVersion = theirBytes === null ? null : bytesToBase64(theirBytes);
+      const matchStatus = computeMatchStatus(doc3.currentVersion, theirVersion);
+      events.push({
+        event: "loro_awareness_snapshot",
+        docId: doc3.docId,
+        ourVersion,
+        peerId: String(peer.peerId),
+        theirCachedVersion,
+        matchStatus
+      });
+    }
+  }
+  return events;
+}
+function computeMatchStatus(ours, theirs) {
+  try {
+    const cmp2 = ours.compare(theirs);
+    if (cmp2 === void 0) return "concurrent";
+    if (cmp2 === 0) return "equal";
+    if (cmp2 === 1) return "we-ahead";
+    if (cmp2 === -1) return "they-ahead";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function safeEncodeVV(vv) {
+  try {
+    return vv.encode();
+  } catch {
+    return null;
+  }
+}
+function bytesToBase64(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function createLoroAwarenessSampler(deps) {
+  let timer = null;
+  const intervalMs = deps.intervalMs ?? DEFAULT_SAMPLE_INTERVAL_MS;
+  function sampleOnce() {
+    try {
+      const synchronizer = getSynchronizer(deps.getRepo());
+      if (!synchronizer) return;
+      const peers = gatherPeers(synchronizer);
+      const docs = gatherDocs(synchronizer, deps.listTaskIds(), deps.buildDocIdsForTask, deps.log);
+      const events = planAwarenessSnapshot({ peers, docs });
+      const counts = { equal: 0, "we-ahead": 0, "they-ahead": 0, concurrent: 0, unknown: 0 };
+      for (const event of events) {
+        counts[event.matchStatus] += 1;
+        if (event.matchStatus === "equal") continue;
+        deps.log({ ...event });
+      }
+      deps.log({
+        event: "loro_awareness_summary",
+        docCount: docs.length,
+        peerCount: peers.length,
+        pairsChecked: events.length,
+        equalCount: counts.equal,
+        weAheadCount: counts["we-ahead"],
+        theyAheadCount: counts["they-ahead"],
+        concurrentCount: counts.concurrent,
+        unknownCount: counts.unknown
+      });
+    } catch (err) {
+      deps.log({
+        event: "loro_awareness_sample_failed",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return {
+    start() {
+      if (timer) return;
+      timer = setInterval(sampleOnce, intervalMs);
+      timer.unref?.();
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    },
+    sampleOnce
+  };
+}
+function safeOplogVersion(doc3) {
+  try {
+    return doc3.oplogVersion();
+  } catch {
+    return null;
+  }
+}
+function getSynchronizer(repo) {
+  const sync = repo.synchronizer;
+  if (sync !== null && sync !== void 0 && typeof sync === "object" && "getPeers" in sync && "getDocumentState" in sync && typeof sync.getPeers === "function" && typeof sync.getDocumentState === "function") {
+    return sync;
+  }
+  return null;
+}
+function gatherPeers(synchronizer) {
+  return synchronizer.getPeers().map((p2) => ({
+    peerId: p2.identity.peerId,
+    docSyncStates: p2.docSyncStates
+  }));
+}
+function gatherDocs(synchronizer, taskIds, buildDocIdsForTask, log) {
+  const docs = [];
+  for (const taskId of taskIds) {
+    for (const docId of buildDocIdsForTask(taskId)) {
+      const docState = synchronizer.getDocumentState(docId);
+      if (!docState) continue;
+      const currentVersion = safeOplogVersion(docState.doc);
+      if (!currentVersion) {
+        log({ event: "loro_awareness_doc_skipped", docId, reason: "oplog_version_unavailable" });
+        continue;
+      }
+      docs.push({ docId, currentVersion });
+    }
+  }
+  return docs;
+}
+
 // src/services/metrics/health-metrics.ts
 var HealthMetrics = class {
   #taskManager;
@@ -69481,7 +69664,7 @@ function classifyAbandoned(task, now, thresholdMs) {
   if (task.abandonedAt != null) return false;
   if (task.taskStartedAt == null) return false;
   if (TERMINAL_STATUSES.has(task.status)) return false;
-  const idleMs = now - (task.lastActivityAt || task.updatedAt);
+  const idleMs = now - task.lastActivityAt;
   return idleMs >= thresholdMs;
 }
 async function runAbandonedSweep(deps) {
@@ -82066,6 +82249,7 @@ function createCommentEventInjector(deps) {
 }
 
 // src/services/channels/permission-handler.ts
+var RESOLVED_REPLAY_LRU_SIZE = 50;
 var HIGH_RISK_TOOLS = /* @__PURE__ */ new Set(["Write", "Bash", "Edit", "NotebookEdit"]);
 var LOW_RISK_TOOLS = /* @__PURE__ */ new Set(["Read", "Glob", "Grep", "TodoRead", "TodoWrite"]);
 function classifyToolRisk(toolName, _input) {
@@ -82076,13 +82260,15 @@ function classifyToolRisk(toolName, _input) {
 var PermissionHandler = class {
   #deps;
   #pendingPermissions = /* @__PURE__ */ new Map();
+  /** LRU of recently-resolved permissions. Used for reconnect replay (#2164). */
+  #recentlyResolved = [];
   constructor(deps) {
     this.#deps = deps;
   }
   get pendingCount() {
     return this.#pendingPermissions.size;
   }
-  handlePermissionResponse(toolUseId, decision, opts) {
+  handlePermissionResponse(toolUseId, decision, opts, senderParticipantId) {
     const pending = this.#pendingPermissions.get(toolUseId);
     if (!pending) {
       this.#deps.log({
@@ -82092,6 +82278,20 @@ var PermissionHandler = class {
       });
       return;
     }
+    if (pending.targetParticipantId !== void 0 && senderParticipantId !== void 0 && pending.targetParticipantId !== senderParticipantId) {
+      this.#deps.log({
+        event: "permission_response_wrong_target",
+        taskId: this.#deps.taskId,
+        toolUseId,
+        target: pending.targetParticipantId,
+        sender: senderParticipantId
+      });
+      this.#deps.getSendControlMessage()?.({
+        type: "error",
+        error: `permission_response from "${senderParticipantId}" rejected \u2014 target is "${pending.targetParticipantId}"`
+      });
+      return;
+    }
     this.#pendingPermissions.delete(toolUseId);
     const durationMs = Date.now() - pending.requestedAt;
     this.#deps.log({
@@ -82108,6 +82308,19 @@ var PermissionHandler = class {
       durationMs,
       riskLevel: pending.riskLevel
     });
+    const resolvedMsg = {
+      type: "permission_resolved",
+      taskId: this.#deps.taskId,
+      toolUseId,
+      decision,
+      ...this.#deps.threadId !== void 0 && { threadId: this.#deps.threadId }
+    };
+    this.#deps.getSendControlMessage()?.(resolvedMsg);
+    this.#rememberResolved({
+      toolUseId,
+      decision,
+      ...this.#deps.threadId !== void 0 && { threadId: this.#deps.threadId }
+    });
     switch (decision) {
       case "approved":
         pending.resolve({
@@ -82129,6 +82342,12 @@ var PermissionHandler = class {
       }
     }
   }
+  #rememberResolved(entry) {
+    this.#recentlyResolved.push(entry);
+    if (this.#recentlyResolved.length > RESOLVED_REPLAY_LRU_SIZE) {
+      this.#recentlyResolved.shift();
+    }
+  }
   /**
    * Creates a permission request promise for a non-plan tool use.
    * Returns a Promise<PermissionResult> that resolves when the browser
@@ -82161,6 +82380,9 @@ var PermissionHandler = class {
         },
         ...this.#deps.threadId !== void 0 && {
           threadId: this.#deps.threadId
+        },
+        ...this.#deps.ownerParticipantId !== void 0 && {
+          targetParticipantId: this.#deps.ownerParticipantId
         }
       };
       this.#pendingPermissions.set(toolUseId, {
@@ -82169,7 +82391,10 @@ var PermissionHandler = class {
         requestedAt,
         toolName,
         riskLevel,
-        request
+        request,
+        ...this.#deps.ownerParticipantId !== void 0 && {
+          targetParticipantId: this.#deps.ownerParticipantId
+        }
       });
       const send = this.#deps.getSendControlMessage();
       if (send) {
@@ -82229,9 +82454,8 @@ var PermissionHandler = class {
    * store-writer dedup in apps/web/src/transport/control-channel/control-channel-store-writers.ts.
    */
   replayPendingToChannel(send) {
-    if (this.#pendingPermissions.size === 0) return;
-    let sent = 0;
     const currentMainAgentId = this.#deps.getAgentParticipantId();
+    let sent = 0;
     for (const [toolUseId, pending] of this.#pendingPermissions) {
       const request = pending.request.agentId === PENDING_AGENT_PARTICIPANT_ID ? { ...pending.request, agentId: currentMainAgentId } : pending.request;
       try {
@@ -82246,11 +82470,33 @@ var PermissionHandler = class {
         });
       }
     }
+    let resolvedSent = 0;
+    for (const entry of this.#recentlyResolved) {
+      try {
+        send({
+          type: "permission_resolved",
+          taskId: this.#deps.taskId,
+          toolUseId: entry.toolUseId,
+          decision: entry.decision,
+          ...entry.threadId !== void 0 && { threadId: entry.threadId }
+        });
+        resolvedSent++;
+      } catch (err) {
+        this.#deps.log({
+          event: "permission_resolved_replay_send_failed",
+          taskId: this.#deps.taskId,
+          toolUseId: entry.toolUseId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
     this.#deps.log({
       event: "permission_replay",
       taskId: this.#deps.taskId,
       sent,
-      total: this.#pendingPermissions.size
+      total: this.#pendingPermissions.size,
+      resolvedSent,
+      resolvedTotal: this.#recentlyResolved.length
     });
   }
   flushQueuedMessages(send, queue) {
@@ -83213,6 +83459,7 @@ var Thread = class {
       taskId: config2.permissionTaskId ?? config2.threadId,
       threadId: config2.permissionThreadId,
       ownerDisplayName: config2.ownerDisplayName,
+      ownerParticipantId: config2.ownerParticipantId,
       getAgentParticipantId: () => this.#agentParticipantId,
       getSubprocess: () => this.#subprocess,
       getSendControlMessage: () => this.#sendControlMessage,
@@ -83400,8 +83647,13 @@ var Thread = class {
       this.#streamDeltaSinks.delete(sink);
     };
   }
-  handlePermissionResponse(toolUseId, decision, opts) {
-    this.#permissionHandler.handlePermissionResponse(toolUseId, decision, opts);
+  handlePermissionResponse(toolUseId, decision, opts, senderParticipantId) {
+    this.#permissionHandler.handlePermissionResponse(
+      toolUseId,
+      decision,
+      opts,
+      senderParticipantId
+    );
   }
   /**
    * Wire the canUseTool callback on an adopted (pre-warmed) subprocess.
@@ -85169,12 +85421,15 @@ function buildPatchMessage(uri, current2, name, patch, now) {
     resolvedAt: now,
     patchContent: patch
   };
+  const patchText = uri.startsWith("shipyard://task/") ? `# Task list updated (append-only). Apply this patch to reconstruct current state:
+
+${patch}` : patch;
   return {
     kind: "synthetic_update",
     content: [
       {
         type: "resource",
-        resource: { ...current2, text: patch },
+        resource: { ...current2, text: patchText },
         _meta: toMetaRecord(meta)
       }
     ],
@@ -85257,9 +85512,21 @@ function parseTaskResourceUri(uri) {
   }
   return taskId;
 }
-var TASK_LIST_PREAMBLE = `This is your live task list, managed via the TaskCreate, TaskUpdate, TaskList, and TaskGet tools. Mark tasks in_progress when you start them and completed when you finish. Use TaskCreate to add tasks that emerge during the work. Wire dependencies via TaskUpdate's addBlockedBy / addBlocks. The list auto-refreshes as you update it.
+var TASK_LIST_PREAMBLE = `This is your live task list, managed via the TaskCreate, TaskUpdate, TaskList, TaskGet tools. Mark in_progress when you start, completed when you finish.
+
+**Append-only.** Tasks once created stay in the list \u2014 status and dependencies can be updated, but items are not removed. New tasks are added via TaskCreate.
+
+When you see an update diff to this resource, treat it as a state refresh: re-read and adjust your plans if a task was inserted, a status changed, or a dependency edge shifted.
 
-This is a suggested workflow, not a rigid script. Merge, split, reorder, or skip steps as the situation demands. Use whatever skills and tools you actually have available \u2014 the goal is the outcome, not following the template.`;
+This is a suggested workflow, not a rigid script. Merge, split, reorder, or skip steps as the situation demands.`;
+var SKILL_EXAMPLES_BLOCK = `Some of your steps may map well to skills you have available. Examples:
+
+- A "research" or "investigate" step might map to a research-style skill if you have one (e.g. /deep-research).
+- A "ship" or "open PR" step might map to a shipping skill (e.g. /ship).
+- A "review" or "QA" step might map to a review skill (e.g. /qa).
+
+Use whatever's actually available. If no skill fits a step, leave it unprefixed.`;
+var BEFORE_YOU_START_BLOCK = `**Before you start:** Look at your available skills. For each item in this list that clearly maps to a skill you have, call TaskUpdate to prefix its title with that slash-command (e.g. a "research" step might become "/deep-research Research the task" if /deep-research is available). Items with no clear skill fit stay unprefixed \u2014 do not force a match. Placeholder items are still replaced per their description. If a step already carries a slash-command prefix, skip it \u2014 this is idempotent.`;
 function buildBlocksMap(entries) {
   const blocksMap = /* @__PURE__ */ new Map();
   for (const task of entries) {
@@ -85306,6 +85573,12 @@ function formatForAgent(ctx) {
   }
   lines.push(TASK_LIST_PREAMBLE);
   lines.push("");
+  if (appliedTemplate) {
+    lines.push(SKILL_EXAMPLES_BLOCK);
+    lines.push("");
+    lines.push(BEFORE_YOU_START_BLOCK);
+    lines.push("");
+  }
   if (entries.length === 0) {
     lines.push("No tasks yet \u2014 create some with TaskCreate as the work emerges.");
   } else {
@@ -86373,6 +86646,7 @@ var SideThreadRegistry = class {
           forkPointMessageUuid: params.forkPointMessageUuid
         } : { kind: "fresh" },
         humanParticipantId: params.humanParticipantId,
+        ownerParticipantId: this.#deps.ownerParticipantId,
         permissionTaskId: this.#deps.taskId,
         permissionThreadId: params.threadId,
         sendControlMessage: params.sendControlMessage,
@@ -88623,6 +88897,8 @@ var Task = class {
   #broadcastToAllPeers;
   #permissionQueue = [];
   #disposed = false;
+  /** One-shot: awaited before the first #handleBeforeSpawn resolves. Cleared after use. */
+  #hydrationPromise;
   /** Guard: prevents re-entry when stop() triggers further status callbacks. */
   #scheduledAutoCompleted = false;
   #explicitlyStopped = false;
@@ -88672,6 +88948,7 @@ var Task = class {
     this.#costBaseline = deps.costBaseline;
     this.#lastTurnStats = deps.initialTurnStats ?? null;
     this.#tokenCountResult = deps.initialTokenCount ?? null;
+    this.#hydrationPromise = deps.hydrationPromise ?? null;
     this.#telemetry = new TaskTelemetry({
       taskId: deps.taskId,
       metricsCollector: deps.metricsCollector,
@@ -88886,6 +89163,7 @@ var Task = class {
         spawnMode,
         humanParticipantId: deps.humanParticipantId,
         ownerDisplayName: deps.ownerDisplayName,
+        ownerParticipantId: deps.ownerParticipantId,
         permissionTaskId: deps.taskId,
         permissionThreadId: void 0,
         sendControlMessage: deps.sendControlMessage,
@@ -88944,6 +89222,7 @@ var Task = class {
     this.#sideThreads = new SideThreadRegistry({
       taskId: deps.taskId,
       dataDir: deps.dataDir,
+      ownerParticipantId: deps.ownerParticipantId,
       store: deps.store,
       sessionPersistence: deps.sessionPersistence,
       spawnSubprocess: wrappedSpawn,
@@ -89235,8 +89514,8 @@ var Task = class {
   addStreamDeltaSink(sink) {
     return this.#mainThread.addStreamDeltaSink(sink);
   }
-  handlePermissionResponse(toolUseId, decision, opts) {
-    this.#mainThread.handlePermissionResponse(toolUseId, decision, opts);
+  handlePermissionResponse(toolUseId, decision, opts, senderParticipantId) {
+    this.#mainThread.handlePermissionResponse(toolUseId, decision, opts, senderParticipantId);
   }
   handlePlanContinue(toolUseId, decision, feedback, opts) {
     this.#planHandler.handlePlanContinue(toolUseId, decision, feedback, opts);
@@ -89594,6 +89873,10 @@ var Task = class {
     return arr.shift();
   }
   async #handleBeforeSpawn(initialContent) {
+    if (this.#hydrationPromise) {
+      await this.#hydrationPromise;
+      this.#hydrationPromise = null;
+    }
     await this.#ensureCompactContextFromStore();
     if (this.#needsPromotionContext) {
       this.#needsPromotionContext = false;
@@ -90868,7 +91151,7 @@ var TaskManager = class {
     const task = this.#tasks.get(taskId);
     return task?.orchestrator.latestSettings.permissionMode ?? null;
   }
-  handlePermissionResponse(taskId, toolUseId, decision, opts, threadId) {
+  handlePermissionResponse(taskId, toolUseId, decision, opts, threadId, senderParticipantId) {
     const task = this.#tasks.get(taskId);
     if (!task) {
       this.#deps.log({ event: "permission_response_no_orchestrator", taskId, toolUseId });
@@ -90877,7 +91160,7 @@ var TaskManager = class {
     if (threadId) {
       const thread = task.orchestrator.getSideThread(threadId);
       if (thread) {
-        thread.handlePermissionResponse(toolUseId, decision, opts);
+        thread.handlePermissionResponse(toolUseId, decision, opts, senderParticipantId);
         return;
       }
       this.#deps.log({
@@ -90887,7 +91170,7 @@ var TaskManager = class {
         toolUseId
       });
     }
-    task.orchestrator.handlePermissionResponse(toolUseId, decision, opts);
+    task.orchestrator.handlePermissionResponse(toolUseId, decision, opts, senderParticipantId);
   }
   /**
    * Request permission for a proxy MCP tool call.
@@ -90914,7 +91197,38 @@ var TaskManager = class {
     if (this.#tasks.has(params.taskId)) return;
     const cwd = params.cwd;
     const mode = params.mode ?? "task";
-    this.#deps.taskStateStore.createTask({ ...params, cwd, mode }).catch((err) => {
+    const storeAndHydrate = async () => {
+      const template = params.templateId ? await this.#deps.templateStore.get(params.templateId) : null;
+      if (params.templateId && !template) {
+        this.#deps.log({
+          event: "task_template_not_found",
+          taskId: params.taskId,
+          templateId: params.templateId
+        });
+      }
+      const now = Date.now();
+      const initialOverlay = template?.items.map((item2) => ({
+        id: item2.id,
+        subject: item2.content,
+        description: item2.description,
+        status: "pending",
+        blocks: [],
+        blockedBy: item2.deps,
+        createdAt: now,
+        updatedAt: now
+      })) ?? [];
+      await this.#deps.taskStateStore.createTask({
+        ...params,
+        cwd,
+        mode,
+        appliedTemplateId: params.templateId,
+        initialOverlay: initialOverlay.length > 0 ? { ...DEFAULT_TASK_OVERLAY, userTasks: initialOverlay } : void 0
+      });
+      if (initialOverlay.length > 0) {
+        this.#deps.notifyTaskResourceChange(params.taskId);
+      }
+    };
+    const hydrationPromise = storeAndHydrate().catch((err) => {
       this.#deps.log({
         event: "task_state_store_create_failed",
         taskId: params.taskId,
@@ -90929,7 +91243,8 @@ var TaskManager = class {
       adoptedSubprocess: claim ?? void 0,
       cwd,
       mode,
-      scheduleId: params.scheduleId
+      scheduleId: params.scheduleId,
+      hydrationPromise
     });
     this.#tasks.set(params.taskId, {
       taskId: params.taskId,
@@ -91264,6 +91579,7 @@ var TaskManager = class {
       channelId,
       humanParticipantId: buildHumanParticipantId(this.#deps.userId),
       ownerDisplayName: this.#deps.displayName,
+      ownerParticipantId: buildHumanParticipantId(this.#deps.userId),
       getCollabParticipants: () => this.#deps.getCollabParticipantsForTask(taskId),
       epoch: this.#deps.epoch,
       store: this.#deps.store,
@@ -91419,7 +91735,8 @@ var TaskManager = class {
       adoptedSubprocess: opts?.adoptedSubprocess,
       mode: opts?.mode ?? "task",
       scheduleId: opts?.scheduleId,
-      collabQueuePersistence: this.#deps.collabQueuePersistence
+      collabQueuePersistence: this.#deps.collabQueuePersistence,
+      hydrationPromise: opts?.hydrationPromise
     });
   }
 };
@@ -91489,7 +91806,17 @@ function buildTaskStateStore(dataDir) {
     get version() {
       return _version;
     },
-    async createTask({ taskId, channelId, title, cwd, mode, scheduleId, scheduleName }, options) {
+    async createTask({
+      taskId,
+      channelId,
+      title,
+      cwd,
+      mode,
+      scheduleId,
+      scheduleName,
+      appliedTemplateId,
+      initialOverlay
+    }, options) {
       const now = Date.now();
       pushBroadcast(options);
       await store.set(taskId, {
@@ -91509,7 +91836,9 @@ function buildTaskStateStore(dataDir) {
         totalOutputTokens: 0,
         mode: mode ?? "task",
         ...scheduleId ? { scheduleId } : {},
-        ...scheduleName ? { scheduleName } : {}
+        ...scheduleName ? { scheduleName } : {},
+        ...appliedTemplateId ? { appliedTemplateId } : {},
+        ...initialOverlay ? { taskOverlay: initialOverlay } : {}
       });
     },
     async updateTaskStatus(taskId, status, options) {
@@ -91524,10 +91853,20 @@ function buildTaskStateStore(dataDir) {
       );
     },
     async updateCwd(taskId, cwd, options) {
-      await safeUpdate(taskId, (task) => ({ ...task, cwd, updatedAt: Date.now() }), options);
+      const now = Date.now();
+      await safeUpdate(
+        taskId,
+        (task) => ({ ...task, cwd, updatedAt: now, lastActivityAt: now }),
+        options
+      );
     },
     async updateMode(taskId, mode, options) {
-      await safeUpdate(taskId, (task) => ({ ...task, mode, updatedAt: Date.now() }), options);
+      const now = Date.now();
+      await safeUpdate(
+        taskId,
+        (task) => ({ ...task, mode, updatedAt: now, lastActivityAt: now }),
+        options
+      );
     },
     async updateTodoProgress(taskId, progress, options) {
       const now = Date.now();
@@ -91578,8 +91917,7 @@ function buildTaskStateStore(dataDir) {
         taskId,
         (task) => ({
           ...task,
-          taskOverlay: overlay,
-          updatedAt: Date.now()
+          taskOverlay: overlay
         }),
         options
       );
@@ -91589,8 +91927,7 @@ function buildTaskStateStore(dataDir) {
         taskId,
         (task) => ({
           ...task,
-          composerSettings: { ...task.composerSettings, ...settings },
-          updatedAt: Date.now()
+          composerSettings: { ...task.composerSettings, ...settings }
         }),
         options
       );
@@ -91601,8 +91938,7 @@ function buildTaskStateStore(dataDir) {
         (task) => ({
           ...task,
           totalCostUsd: stats.totalCostUsd,
-          totalOutputTokens: stats.totalOutputTokens,
-          updatedAt: Date.now()
+          totalOutputTokens: stats.totalOutputTokens
         }),
         options
       );
@@ -91612,8 +91948,7 @@ function buildTaskStateStore(dataDir) {
         taskId,
         (task) => ({
           ...task,
-          lastTurnStats: snapshot,
-          updatedAt: Date.now()
+          lastTurnStats: snapshot
         }),
         options
       );
@@ -91623,8 +91958,7 @@ function buildTaskStateStore(dataDir) {
         taskId,
         (task) => ({
           ...task,
-          lastTokenCount: snapshot,
-          updatedAt: Date.now()
+          lastTokenCount: snapshot
         }),
         options
       );
@@ -91634,8 +91968,7 @@ function buildTaskStateStore(dataDir) {
         taskId,
         (task) => ({
           ...task,
-          lastPlanDetection: detection ?? void 0,
-          updatedAt: Date.now()
+          lastPlanDetection: detection ?? void 0
         }),
         options
       );
@@ -91648,8 +91981,7 @@ function buildTaskStateStore(dataDir) {
           totalCostUsd: 0,
           totalOutputTokens: 0,
           lastTurnStats: void 0,
-          lastTokenCount: void 0,
-          updatedAt: Date.now()
+          lastTokenCount: void 0
         }),
         options
       );
@@ -91657,21 +91989,21 @@ function buildTaskStateStore(dataDir) {
     async setPrUrl(taskId, prUrl, options) {
       await safeUpdate(
         taskId,
-        (task) => task.prUrl === prUrl ? task : { ...task, prUrl, updatedAt: Date.now() },
+        (task) => task.prUrl === prUrl ? task : { ...task, prUrl },
         options
       );
     },
     async setAppliedTemplateId(taskId, templateId, options) {
       await safeUpdate(
         taskId,
-        (task) => task.appliedTemplateId === templateId ? task : { ...task, appliedTemplateId: templateId, updatedAt: Date.now() },
+        (task) => task.appliedTemplateId === templateId ? task : { ...task, appliedTemplateId: templateId },
         options
       );
     },
     async setAbandonedAt(taskId, timestamp, options) {
       await safeUpdate(
         taskId,
-        (task) => task.abandonedAt != null ? task : { ...task, abandonedAt: timestamp, updatedAt: Date.now() },
+        (task) => task.abandonedAt != null ? task : { ...task, abandonedAt: timestamp },
         { broadcast: false, ...options }
       );
     },
@@ -93497,6 +93829,7 @@ async function createDaemon(deps) {
   });
   shipyardResolver.addSubResolver("task", taskResourceResolver);
   const collabParticipantsRef = { current: () => [] };
+  const templateStoreEarly = buildTemplateStore(deps.dataDir);
   const taskManager = new TaskManager({
     userId: deps.auth.userId,
     displayName: deps.auth.displayName,
@@ -93524,7 +93857,8 @@ async function createDaemon(deps) {
     gitCheckpoint,
     workspaceRoot: deps.workspaceRoot,
     notifyTaskResourceChange: (taskId) => taskResourceResolver.notifyChange(taskId),
-    collabQueuePersistence
+    collabQueuePersistence,
+    templateStore: templateStoreEarly
   });
   const proxyRef = { current: null };
   const preWarmManager = new PreWarmManager({
@@ -93544,7 +93878,7 @@ async function createDaemon(deps) {
       logger.error({ err, ...ctx }, "rate-limit store write failed");
     }
   });
-  const templateStore = buildTemplateStore(deps.dataDir);
+  const templateStore = templateStoreEarly;
   {
     const settings = await userSettingsStore.getSettings();
     await seedBuiltInTemplates(
@@ -93794,7 +94128,18 @@ async function createDaemon(deps) {
     log: (entry) => deps.log(entry)
   });
   abandonedSweeper.start();
+  const awarenessSampler = createLoroAwarenessSampler({
+    getRepo: () => repo,
+    listTaskIds: () => taskManager.listManagedTasks().map((t) => t.taskId),
+    buildDocIdsForTask: (taskId) => [
+      buildPlanDocId(taskId, PLAN_EPOCH),
+      buildCanvasDocId(taskId, CANVAS_EPOCH)
+    ],
+    log: deps.log
+  });
+  awarenessSampler.start();
   async function dispose() {
+    awarenessSampler.stop();
     abandonedSweeper.stop();
     scheduleEvaluator.dispose();
     preWarmManager.dispose();
@@ -93845,6 +94190,7 @@ async function createDaemon(deps) {
     rateLimitStore,
     templateStore,
     themeStore,
+    notifyTaskResourceChange: (taskId) => taskResourceResolver.notifyChange(taskId),
     setCollabParticipantsProvider: (provider) => {
       collabParticipantsRef.current = provider;
     },
@@ -94186,6 +94532,7 @@ function filterOutboundForCollab(msg, collabTaskId) {
     case "task_state_update":
     case "task_removed":
     case "permission_request":
+    case "permission_resolved":
     case "pr_action_result":
     case "plan_detected":
     case "plan_continuation_timeout":
@@ -94514,7 +94861,14 @@ function routeMessage(msg, callbacks, log) {
       callbacks.onRemoveWorktree(msg.worktreePath);
       break;
     case "create_task":
-      callbacks.onCreateTask(msg.taskId, msg.channelId, msg.title, msg.cwd, msg.mode);
+      callbacks.onCreateTask(
+        msg.taskId,
+        msg.channelId,
+        msg.title,
+        msg.cwd,
+        msg.mode,
+        msg.templateId
+      );
       break;
     case "promote_task":
       callbacks.onPromoteTask(msg.taskId);
@@ -96157,7 +96511,15 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
     guardedSend,
     {
       onPermissionResponse: (taskId, toolUseId, decision, opts, threadId) => {
-        daemon.taskManager.handlePermissionResponse(taskId, toolUseId, decision, opts, threadId);
+        const senderParticipantId = deps?.peerRoleRegistry && deps?.peerMachineId ? deps.peerRoleRegistry.getParticipantId(deps.peerMachineId) : void 0;
+        daemon.taskManager.handlePermissionResponse(
+          taskId,
+          toolUseId,
+          decision,
+          opts,
+          threadId,
+          senderParticipantId
+        );
       },
       onUpdateSettings: (settings) => {
         if (settings.disabledMcpServers && daemon.capabilities.mcpServers) {
@@ -96189,9 +96551,26 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
         logAdapter({ event: "settings_updated", settings });
       },
       onUpdateTaskSettings: (taskId, settings) => {
-        daemon.taskManager.applyTaskSettings(taskId, settings);
-        handler.sendControl({ type: "settings_ack", settings, taskId });
-        logAdapter({ event: "task_settings_updated", taskId, settings });
+        const enforcedRole = deps?.peerRoleRegistry && deps?.peerMachineId ? deps.peerRoleRegistry.getRole(deps.peerMachineId) : deps?.peerRole;
+        let applied = settings;
+        if (enforcedRole !== void 0 && enforcedRole !== "owner" && settings.permissionMode) {
+          const { permissionMode: _dropped, ...rest } = settings;
+          applied = rest;
+          logAdapter({
+            event: "task_settings_permission_mode_rejected",
+            taskId,
+            role: enforcedRole,
+            requested: settings.permissionMode
+          });
+          handler.sendControl({
+            type: "error",
+            error: "Only the task owner can change permissionMode"
+          });
+        }
+        if (Object.keys(applied).length === 0) return;
+        daemon.taskManager.applyTaskSettings(taskId, applied);
+        handler.sendControl({ type: "settings_ack", settings: applied, taskId });
+        logAdapter({ event: "task_settings_updated", taskId, settings: applied });
       },
       onRequestCapabilities: () => {
         sendCapabilities(handler);
@@ -96601,8 +96980,8 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
         const threads = await daemon.taskManager.listThreads(taskId);
         controlHandler.sendControl({ type: "thread_list", taskId, threads });
       },
-      onCreateTask: (taskId, channelId, title, cwd, mode) => {
-        daemon.taskManager.createTask({ taskId, channelId, title, cwd, mode });
+      onCreateTask: (taskId, channelId, title, cwd, mode, templateId) => {
+        daemon.taskManager.createTask({ taskId, channelId, title, cwd, mode, templateId });
       },
       onPromoteTask: (taskId) => {
         daemon.taskManager.promoteTask(taskId);
@@ -96736,7 +97115,7 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
         });
       },
       onNotifyTemplateApplied: (taskId, templateId) => {
-        daemon.taskStateStore.setAppliedTemplateId(taskId, templateId).catch((err) => {
+        daemon.taskStateStore.setAppliedTemplateId(taskId, templateId).then(() => daemon.notifyTaskResourceChange(taskId)).catch((err) => {
           logAdapter({
             event: "notify_template_applied_failed",
             taskId,
@@ -99907,73 +100286,137 @@ function buildCollabRoomManager(deps) {
         log.info("Collab browser preview URL channel wired");
       },
       onFileIOChannel: (_machineId, rawChannel) => {
-        const peerRole = peerRoleRegistry.getRole(_machineId);
-        if (peerRole !== "owner" && peerRole !== "collaborator-full") {
-          log.warn(
-            { role: peerRole },
-            "Collab peer with insufficient role attempted file I/O access"
-          );
+        const wireFileIo = () => {
+          const channelState = narrow(rawChannel).readyState;
+          if (channelState === "closed" || channelState === "closing") {
+            log.info("Collab file I/O raw channel closed before peer registered \u2014 skipping wire");
+            return;
+          }
+          const peerRole = peerRoleRegistry.getRole(_machineId);
+          if (peerRole !== "owner" && peerRole !== "collaborator-full") {
+            log.warn(
+              { role: peerRole },
+              "Collab peer with insufficient role attempted file I/O access"
+            );
+            return;
+          }
+          const dc = narrow(rawChannel);
+          const cwd = daemon.taskManager.getTaskCwd(collabTaskId) ?? workspaceRoot;
+          setupFileIOChannel({
+            dc,
+            cwd,
+            label: "file-io-collab",
+            logAdapter,
+            fileWatcherPool,
+            fileIOHandlers,
+            handlerDeps: {
+              diffTurn: (taskId, turnIndex) => daemon.taskManager.diffTurn(taskId, turnIndex),
+              diffTurnFile: (taskId, turnIndex, path2) => daemon.taskManager.diffTurnFile(taskId, turnIndex, path2),
+              revertTurn: (taskId, turnIndex, mode, filePath) => daemon.taskManager.revertTurn(taskId, turnIndex, mode, filePath),
+              /**
+               * Scope the collab peer's `set_cwd` allowlist to THIS task's
+               * cwd only — not the global set. Without this, a collaborator-full
+               * peer for task X could redirect to task Y's cwd and cross
+               * task-isolation boundaries.
+               */
+              isAllowedCwd: (abs) => {
+                const taskCwd = daemon.taskManager.getTaskCwd(collabTaskId);
+                if (!taskCwd) return false;
+                return isUnderAllowedRoot2(abs, [taskCwd]);
+              }
+            }
+          });
+          log.info("Collab file I/O channel wired");
+        };
+        if (peerRoleRegistry.isRegistered(_machineId)) {
+          wireFileIo();
           return;
         }
-        const dc = narrow(rawChannel);
-        const cwd = daemon.taskManager.getTaskCwd(collabTaskId) ?? workspaceRoot;
-        setupFileIOChannel({
-          dc,
-          cwd,
-          label: "file-io-collab",
-          logAdapter,
-          fileWatcherPool,
-          fileIOHandlers,
-          handlerDeps: {
-            diffTurn: (taskId, turnIndex) => daemon.taskManager.diffTurn(taskId, turnIndex),
-            diffTurnFile: (taskId, turnIndex, path2) => daemon.taskManager.diffTurnFile(taskId, turnIndex, path2),
-            revertTurn: (taskId, turnIndex, mode, filePath) => daemon.taskManager.revertTurn(taskId, turnIndex, mode, filePath),
-            /**
-             * Scope the collab peer's `set_cwd` allowlist to THIS task's
-             * cwd only — not the global set. Without this, a collaborator-full
-             * peer for task X could redirect to task Y's cwd and cross
-             * task-isolation boundaries.
-             */
-            isAllowedCwd: (abs) => {
-              const taskCwd = daemon.taskManager.getTaskCwd(collabTaskId);
-              if (!taskCwd) return false;
-              return isUnderAllowedRoot2(abs, [taskCwd]);
-            }
-          }
+        log.info("Collab file I/O channel open deferred \u2014 peer not yet registered");
+        let done = false;
+        const finish = () => {
+          if (done) return;
+          done = true;
+          clearTimeout(timer);
+          unsubscribe();
+        };
+        const unsubscribe = peerRoleRegistry.onRegister((peerId) => {
+          if (peerId !== _machineId) return;
+          if (done) return;
+          finish();
+          wireFileIo();
         });
-        log.info("Collab file I/O channel wired");
+        const timer = setTimeout(() => {
+          finish();
+          log.warn(
+            { machineId: _machineId },
+            "Collab file I/O channel buffer expired \u2014 peer never registered"
+          );
+        }, 5e3);
       },
       onTerminalChannel: (_machineId, rawChannel, taskId, terminalId) => {
-        const peerRole = peerRoleRegistry.getRole(_machineId);
-        if (peerRole !== "owner" && peerRole !== "collaborator-full") {
-          log.warn(
-            { role: peerRole },
-            "Collab peer with insufficient role attempted terminal access"
+        const wireTerminal = () => {
+          const channelState = narrow(rawChannel).readyState;
+          if (channelState === "closed" || channelState === "closing") {
+            log.info("Collab terminal raw channel closed before peer registered \u2014 skipping wire");
+            return;
+          }
+          const peerRole = peerRoleRegistry.getRole(_machineId);
+          if (peerRole !== "owner" && peerRole !== "collaborator-full") {
+            log.warn(
+              { role: peerRole },
+              "Collab peer with insufficient role attempted terminal access"
+            );
+            return;
+          }
+          const dc = narrow(rawChannel);
+          const guarded = new GuardedChannel(toGuardedDataChannel5(dc), {
+            label: "terminal-collab",
+            policy: "drop",
+            logAdapter
+          });
+          const handler = handleTerminalChannel(
+            taskId,
+            terminalId,
+            workspaceRoot,
+            (data) => {
+              guarded.send(data);
+            },
+            logAdapter,
+            { ptys: terminalPtys }
           );
+          dc.onmessage = (ev) => handler.onMessage(typeof ev.data === "string" ? ev.data : String(ev.data));
+          dc.onclose = () => {
+            handler.dispose();
+            guarded.dispose();
+          };
+          log.info({ taskId, terminalId }, "Collab terminal channel wired");
+        };
+        if (peerRoleRegistry.isRegistered(_machineId)) {
+          wireTerminal();
           return;
         }
-        const dc = narrow(rawChannel);
-        const guarded = new GuardedChannel(toGuardedDataChannel5(dc), {
-          label: "terminal-collab",
-          policy: "drop",
-          logAdapter
-        });
-        const handler = handleTerminalChannel(
-          taskId,
-          terminalId,
-          workspaceRoot,
-          (data) => {
-            guarded.send(data);
-          },
-          logAdapter,
-          { ptys: terminalPtys }
-        );
-        dc.onmessage = (ev) => handler.onMessage(typeof ev.data === "string" ? ev.data : String(ev.data));
-        dc.onclose = () => {
-          handler.dispose();
-          guarded.dispose();
+        log.info("Collab terminal channel open deferred \u2014 peer not yet registered");
+        let done = false;
+        const finish = () => {
+          if (done) return;
+          done = true;
+          clearTimeout(timer);
+          unsubscribe();
         };
-        log.info({ taskId, terminalId }, "Collab terminal channel wired");
+        const unsubscribe = peerRoleRegistry.onRegister((peerId) => {
+          if (peerId !== _machineId) return;
+          if (done) return;
+          finish();
+          wireTerminal();
+        });
+        const timer = setTimeout(() => {
+          finish();
+          log.warn(
+            { machineId: _machineId },
+            "Collab terminal channel buffer expired \u2014 peer never registered"
+          );
+        }, 5e3);
       },
       onThreadMessageChannel: (machineId, rawChannel, taskId, threadId) => {
         if (!isTaskMessageChannelAllowed(taskId, collabTaskId)) {
@@ -101605,4 +102048,4 @@ export {
   _testing,
   serve
 };
-//# sourceMappingURL=serve-FOWLAISV.js.map
+//# sourceMappingURL=serve-3EFFP3PN.js.map