@ycodium-ai/plugin-team 0.2.3250 → 0.2.3254

package/dist/index.js

@@ -1182,8 +1182,8 @@ var succeed = (success) => {
 };
 
 // ../../node_modules/.pnpm/effect@4.0.0-beta.103_patch_hash=78523ded7c3dfc3efd3cec0247f4960d00eaa3d3c96a2077457694a4d8b453c6/node_modules/effect/dist/Order.js
-function make(compare2) {
-  return (self, that) => self === that ? 0 : compare2(self, that);
+function make(compare3) {
+  return (self, that) => self === that ? 0 : compare3(self, that);
 }
 var Number2 = /* @__PURE__ */ make((self, that) => {
   if (globalThis.Number.isNaN(self) && globalThis.Number.isNaN(that)) return 0;
@@ -7205,12 +7205,13 @@ function leadBrief(goal, roster) {
     LEAD_OWN_ITEM_RULE,
     LEAD_SEND_BACK_RULE,
     LEAD_STUCK_RULE,
-    `Only after all dependencies are recorded, assign each item to exactly one member with work_update_item. For local members use assignees: [{ "kind": "agent", "threadId": "<threadId from the table>" }]. A local member is told about an item as soon as it is assigned, so assigning before the dependencies exist starts blocked work early. ${LEAD_NO_MEMBER_TASKS}`,
+    `Only after all dependencies are recorded, assign each item to exactly one member with work_update_item. For local members use assignees: [{ "kind": "agent", "threadId": "<threadId from the table>" }]. Assign work to members with no item in progress first; do not give one member two items while another is idle. An item assigned to a local member who already has work waits in line and wakes them after their current item is finished. Record dependencies before assigning so blocked work waits until it can start. ${LEAD_NO_MEMBER_TASKS}`,
     ...remoteMembers.length === 0 ? [] : [
       'Remote members are on another machine. To give them work, assign the work item to them with work_update_item and assignees: [{ "kind": "remote-agent", "principalId": "<principalId from the table>" }]; they pick it up from their own machine. Do not create conversations, start turns, or send wake-up signals for them on this machine.',
       "A comment that mentions a remote member, or replies to one of their comments, wakes them on their machine, so you can ask or answer them in work item comments. Once they mark an item done they stop working on it, so to send work back to a remote member you still reopen the item as described above."
     ],
     "Use work_list_items to check progress. When all work is complete, summarize the results here in one or two sentences.",
+    "Members' worktrees and branches remain after the goal ends. After their work is merged into the main line, they can be deleted from the source control panel.",
     PERSON_MESSAGE_RULE,
     "If the work item tools are unavailable, tell the user directly that this project needs the board and project memory switches turned on first."
   ].join("\n\n");
@@ -7218,6 +7219,7 @@ function leadBrief(goal, roster) {
 
 // src/domain/goals.ts
 var REQUEST_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+var isTeamRequestId = (requestId) => REQUEST_ID_PATTERN.test(requestId);
 var GOAL_MAX_LENGTH = 4e3;
 var goalText = (raw) => {
   const text = raw.trim();
@@ -7333,7 +7335,7 @@ function createGoalService(ctx, rosterService, options = {}) {
     const input = decoded.value;
     const text = goalText(input.goal);
     if (text === null) return rejectGoal("invalid-goal");
-    if (!REQUEST_ID_PATTERN.test(input.requestId)) return rejectGoal("invalid-request-id");
+    if (!isTeamRequestId(input.requestId)) return rejectGoal("invalid-request-id");
     const roster = await rosterService.read(input.projectId);
     if (roster === null) return rejectGoal("no-roster");
     const project2 = await ctx.projects.get({ projectId: input.projectId });
@@ -8189,9 +8191,74 @@ function createRosterService(ctx, options = {}) {
   };
 }
 
+// src/runtime/wakeQueries.ts
+function memberWorktreeFor(goals, project2, projectId, recipient) {
+  if (!("threadId" in recipient) || project2 === void 0 || !project2.threads.includes(recipient.threadId) || project2.leadThreads?.includes(recipient.threadId))
+    return;
+  const { threadId } = recipient;
+  const leadThreadId = project2.leadThreads?.[0];
+  if (leadThreadId === void 0) return;
+  return {
+    leadThreadId,
+    failure: project2.worktreeFailures?.[threadId],
+    // 只在要建树或报失败时读目标取名字，叫醒的热路径不多读。
+    name: async () => (await goals.read(projectId))?.members.find((member) => member.threadId === threadId)?.name ?? project2.memberIds?.[threadId] ?? threadId
+  };
+}
+var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var compareWakeItems = (a, b) => a.sequenceId - b.sequenceId || compare(a.workItemId, b.workItemId);
+var isClosed = (item) => item?.stateGroup === "completed" || item?.stateGroup === "cancelled";
+var hasOpenBlocker = (project2, workItemId) => (readFact(project2.blockers, workItemId) ?? []).some(
+  (blocker) => !isClosed(readFact(project2.items, blocker))
+);
+var isAssignedOpen = (project2, workItemId, threadId) => {
+  const item = readFact(project2.items, workItemId);
+  return item !== null && item !== void 0 && !isClosed(item) && item.assigneeThreads.includes(threadId);
+};
+var isWorkable = (project2, workItemId) => !isClosed(readFact(project2.items, workItemId)) && !hasOpenBlocker(project2, workItemId);
+var isOpenWorkFor = (project2, workItemId, threadId) => isAssignedOpen(project2, workItemId, threadId) && !hasOpenBlocker(project2, workItemId);
+var isMember = (project2, recipient) => "threadId" in recipient ? project2.threads.includes(recipient.threadId) : project2.remoteMembers.includes(recipient.principalId);
+var isQueuedUnclaimed = (item, threadId) => item.wakeStatus?.[threadId] === "pending" && !item.claimedBy.includes(threadId);
+var isDeferredWake = (project2, item, threadId) => project2.threads.includes(threadId) && !project2.leadThreads?.includes(threadId) && item.assigneeThreads.includes(threadId) && isQueuedUnclaimed(item, threadId) && !isClosed(item);
+function countDeferredWakes(project2, threadId) {
+  let count = 0;
+  for (const workItemId in project2.items) {
+    const item = readFact(project2.items, workItemId);
+    if (item !== null && isDeferredWake(project2, item, threadId)) count++;
+  }
+  return count;
+}
+
 // src/runtime/deliver.ts
 import * as NodeCrypto from "node:crypto";
 var stableHash = (key) => NodeCrypto.createHash("sha256").update(key).digest("hex").slice(0, 32);
+var memberWorktreeBranch = (name, threadId) => {
+  const slug = Array.from(
+    name.normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "-")
+  ).slice(0, 32).join("").replace(/^-+|-+$/g, "") || "member";
+  return `team/${slug}-${stableHash(threadId).slice(0, 16)}`;
+};
+var createMemberWorktreeLane = (state, events) => {
+  const tails = /* @__PURE__ */ new Map();
+  return {
+    state,
+    events,
+    serialize: (threadId, run3) => {
+      const next = (tails.get(threadId) ?? Promise.resolve()).then(run3);
+      const tail = next.then(
+        () => void 0,
+        () => void 0
+      );
+      tails.set(threadId, tail);
+      void tail.then(() => {
+        if (tails.get(threadId) === tail) tails.delete(threadId);
+      });
+      return next;
+    }
+  };
+};
+var shortReason = (error) => (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim().slice(0, 240) || "Worktree preparation failed";
+var FALLBACK_SUFFIX = ":worktree-fallback";
 async function deliverWake(ctx, input) {
   const { recipient } = input;
   if ("principalId" in recipient) {
@@ -8205,26 +8272,406 @@ async function deliverWake(ctx, input) {
   } else {
     const execution = await ctx.projections.getThreadExecution(recipient.threadId);
     if (execution === null || execution.archivedAt !== null) return false;
-    await ctx.threads.turns.start({
-      requestId: input.requestId,
-      threadId: recipient.threadId,
+    const { threadId } = recipient;
+    const text = typeof input.text === "string" ? input.text : await input.text();
+    const worktree = input.memberWorktree;
+    const turn = {
+      threadId,
       message: {
         messageId: input.messageId,
         role: "user",
-        text: typeof input.text === "string" ? input.text : await input.text(),
+        text,
         attachments: []
       },
       modelSelection: execution.modelSelection,
       runtimeMode: execution.runtimeMode,
       interactionMode: execution.interactionMode
+    };
+    const startTurn = (suffix) => ctx.threads.turns.start({
+      ...turn,
+      requestId: `${input.requestId}${suffix}`,
+      message: { ...turn.message, messageId: `${input.messageId}${suffix}` }
     });
+    let failure = worktree?.failure;
+    let delivered = false;
+    if (worktree !== void 0 && failure === void 0 && !execution.worktreePath) {
+      const { lane } = worktree;
+      const first = await lane.serialize(threadId, async () => {
+        const current = await ctx.projections.getThreadExecution(threadId);
+        if (current?.worktreePath) return { kind: "registered" };
+        const recorded = (await lane.state.get())[input.projectId]?.worktreeFailures?.[threadId];
+        if (recorded !== void 0) return { kind: "failed", failure: recorded };
+        const branch = memberWorktreeBranch(await worktree.name(), threadId);
+        try {
+          await ctx.threads.turns.start({
+            ...turn,
+            requestId: input.requestId,
+            message: {
+              ...turn.message,
+              text: `${text}
+
+You are in your own newly created worktree on branch ${branch}. Install dependencies according to the project's instructions before starting work.`
+            },
+            bootstrap: {
+              prepareWorktree: {
+                // bootstrapTurnStart 将它传作 refName；gitDriver/worktrees 用 cwd 下的 HEAD 执行 git worktree add -b。
+                baseBranch: "HEAD",
+                branch,
+                startFromOrigin: false
+              }
+            }
+          });
+        } catch (error) {
+          await startTurn(FALLBACK_SUFFIX);
+          const reason = shortReason(error);
+          const receipt = await lane.events.append({
+            commandId: `team-worktree-failed:${threadId}`,
+            name: "member-worktree-failed",
+            aggregate: { kind: "project", id: input.projectId },
+            data: { version: 1, projectId: input.projectId, threadId, reason }
+          });
+          const persisted = (await lane.state.get({ throughSequence: receipt.sequence }))[input.projectId]?.worktreeFailures?.[threadId];
+          return { kind: "fallback", failure: persisted ?? { reason } };
+        }
+        return { kind: "worktree" };
+      });
+      if (first.kind === "worktree") return true;
+      if (first.kind !== "registered") failure = first.failure;
+      delivered = first.kind === "fallback";
+    }
+    if (!delivered) await startTurn(failure === void 0 ? "" : FALLBACK_SUFFIX);
+    if (worktree !== void 0 && failure !== void 0 && failure.reported !== true) {
+      const reported = await deliverWake(ctx, {
+        projectId: input.projectId,
+        recipient: { threadId: worktree.leadThreadId },
+        requestId: `team-worktree-report:${threadId}`,
+        messageId: `team-worktree-report-msg:${threadId}`,
+        text: `Could not create a worktree for member ${await worktree.name()} (threadId ${threadId}): ${failure.reason}. They will work in the project folder for now.`
+      });
+      if (!reported) throw new Error("Member worktree failure could not be reported to the lead");
+      const receipt = await worktree.lane.events.append({
+        commandId: `team-worktree-reported:${threadId}`,
+        name: "member-worktree-reported",
+        aggregate: { kind: "project", id: input.projectId },
+        data: { version: 1, projectId: input.projectId, threadId }
+      });
+      await worktree.lane.state.get({ throughSequence: receipt.sequence });
+    }
   }
   return true;
 }
 
+// src/runtime/recoveryState.ts
+var RecoveryPlan = Struct({
+  action: Literals(["resume", "lead", "remind", "stall-lead"]),
+  recipientThreadId: String4,
+  text: String4,
+  workItemIds: ArraySchema(String4),
+  resumeQueue: optionalKey2(Literal2(true))
+});
+var REQUESTED = "team/member-recovery-requested";
+var DELIVERED = "team/member-recovery-delivered";
+var decodeRecoveryFact = decodeUnknownOption2(
+  Struct({
+    pluginId: Literal2("team"),
+    name: Literals([REQUESTED, DELIVERED])
+  })
+);
+var isRecoveryFact = (event) => event.type === "plugin.event-appended" && isSome2(decodeRecoveryFact(event.payload));
+var decodeGoal = decodeUnknownOption2(
+  Struct({
+    pluginId: Literal2("team"),
+    name: Literal2("team/goal-started"),
+    data: GoalStartedFact
+  })
+);
+var decodeDelivered = decodeUnknownOption2(
+  Struct({
+    pluginId: Literal2("team"),
+    name: Literal2(DELIVERED),
+    data: Struct({
+      version: Literal2(1),
+      projectId: String4,
+      threadId: String4,
+      turnId: String4,
+      failureSequence: Number5,
+      action: RecoveryPlan.fields.action,
+      workItemIds: ArraySchema(String4)
+    })
+  })
+);
+var decodeRequested = decodeUnknownOption2(
+  Struct({
+    pluginId: Literal2("team"),
+    name: Literal2(REQUESTED),
+    data: Struct({
+      version: Literal2(1),
+      projectId: String4,
+      threadId: String4,
+      turnId: String4,
+      failureSequence: Number5,
+      plan: RecoveryPlan
+    })
+  })
+);
+var decodeSession = decodeUnknownOption2(
+  Struct({
+    threadId: String4,
+    session: Struct({
+      status: String4,
+      activeTurnId: NullOr(String4),
+      failureCategory: optionalKey2(String4)
+    })
+  })
+);
+var decodeWork = decodeUnknownOption2(
+  Struct({
+    projectId: String4,
+    workItemId: String4,
+    actor: optionalKey2(
+      Struct({ kind: String4, threadId: optionalKey2(String4) })
+    )
+  })
+);
+function recoveryEventScopeOf(event) {
+  if (event.aggregateKind === "project") return { kind: "project", projectId: event.aggregateId };
+  if (event.aggregateKind === "thread") return { kind: "thread", threadId: event.aggregateId };
+}
+function foldRecovery(state, event, previous) {
+  if (event.type === "plugin.event-appended") {
+    const goalFact = decodeGoal(event.payload);
+    if (isSome2(goalFact)) {
+      const { goal } = goalFact.value.data;
+      const project2 = readFact(state, goal.projectId);
+      if (project2 === null) return state;
+      const recovery = {};
+      for (const threadId of project2.threads) {
+        if ((project2.leadThreads ?? []).includes(threadId)) continue;
+        recovery[threadId] = {
+          turnId: null,
+          status: null,
+          retriedItemIds: [],
+          handledTurnIds: [],
+          pending: null
+        };
+      }
+      return { ...state, [goal.projectId]: { ...project2, recovery } };
+    }
+    const requested = decodeRequested(event.payload);
+    if (isSome2(requested)) {
+      const fact = requested.value.data;
+      const project2 = readFact(state, fact.projectId);
+      const member = project2?.recovery?.[fact.threadId];
+      if (project2 === null || member === void 0 || member.pending?.turnId !== fact.turnId)
+        return state;
+      const retriedItemIds = fact.plan.action === "resume" ? [.../* @__PURE__ */ new Set([...member.retriedItemIds, ...fact.plan.workItemIds])].filter(
+        (id) => isAssignedOpen(project2, id, fact.threadId)
+      ) : member.retriedItemIds;
+      return {
+        ...state,
+        [fact.projectId]: {
+          ...project2,
+          recovery: {
+            ...project2.recovery,
+            [fact.threadId]: {
+              ...member,
+              retriedItemIds,
+              ...fact.plan.action === "resume" ? {
+                unprogressedRetryItemIds: [
+                  .../* @__PURE__ */ new Set([
+                    ...member.unprogressedRetryItemIds ?? [],
+                    ...fact.plan.workItemIds
+                  ])
+                ]
+              } : {},
+              ...fact.plan.action === "remind" ? {
+                remindedItemIds: [
+                  .../* @__PURE__ */ new Set([...member.remindedItemIds ?? [], ...fact.plan.workItemIds])
+                ]
+              } : {},
+              ...fact.plan.action === "stall-lead" ? {
+                escalatedItemIds: [
+                  .../* @__PURE__ */ new Set([...member.escalatedItemIds ?? [], ...fact.plan.workItemIds])
+                ]
+              } : {},
+              pending: { ...member.pending, plan: fact.plan }
+            }
+          }
+        }
+      };
+    }
+    const delivered = decodeDelivered(event.payload);
+    if (isSome2(delivered)) {
+      const fact = delivered.value.data;
+      const project2 = readFact(state, fact.projectId);
+      const member = project2?.recovery?.[fact.threadId];
+      if (project2 === null || member === void 0 || member.handledTurnIds.includes(fact.turnId))
+        return state;
+      return {
+        ...state,
+        [fact.projectId]: {
+          ...project2,
+          recovery: {
+            ...project2.recovery,
+            [fact.threadId]: {
+              ...member,
+              handledTurnIds: [...member.handledTurnIds, fact.turnId],
+              pending: member.pending?.turnId === fact.turnId ? null : member.pending
+            }
+          }
+        }
+      };
+    }
+  }
+  if (event.type === "thread.session-set") {
+    const decoded = decodeSession(event.payload);
+    if (isNone2(decoded)) return state;
+    const { threadId, session } = decoded.value;
+    for (const [projectId, project2] of Object.entries(state)) {
+      const member = project2.recovery?.[threadId];
+      if (member === void 0 || !isMember(project2, { threadId })) continue;
+      const turnId = session.activeTurnId ?? member.turnId;
+      if (session.status !== "running" && turnId !== null && member.handledTurnIds.includes(turnId))
+        return state;
+      const succeeded = (session.status === "ready" || session.status === "idle") && member.status === "running";
+      const failed = session.status === "error" && turnId !== null;
+      if (member.status === session.status && member.turnId === turnId && !failed) return state;
+      const hasStarted = Object.values(project2.items).some(
+        (item) => item.stateGroup === "started" && item.assigneeThreads.includes(threadId)
+      );
+      const hasOpenWork = Object.keys(project2.items).some(
+        (id) => isOpenWorkFor(project2, id, threadId)
+      );
+      const queuedContinuation = member.pending?.plan?.resumeQueue === true && !failed;
+      const pending = queuedContinuation ? member.pending : failed && hasOpenWork ? member.pending?.turnId === turnId && member.pending.kind !== "stall" ? { ...member.pending, category: session.failureCategory ?? member.pending.category } : { turnId, category: session.failureCategory ?? "unknown", sequence: event.sequence } : succeeded && turnId !== null && hasStarted ? {
+        turnId,
+        category: "normal-end",
+        kind: "stall",
+        sequence: event.sequence,
+        continuedItemIds: member.unprogressedRetryItemIds ?? []
+      } : session.status === "running" || succeeded ? null : member.pending;
+      return {
+        ...state,
+        [projectId]: {
+          ...project2,
+          recovery: {
+            ...project2.recovery,
+            [threadId]: {
+              ...member,
+              turnId,
+              status: session.status,
+              retriedItemIds: succeeded ? [] : member.retriedItemIds,
+              ...succeeded ? { unprogressedRetryItemIds: [] } : {},
+              handledTurnIds: failed && !hasOpenWork ? [...member.handledTurnIds, turnId] : session.status === "running" && member.pending?.plan !== void 0 && !queuedContinuation ? [.../* @__PURE__ */ new Set([...member.handledTurnIds, member.pending.turnId])] : member.handledTurnIds,
+              pending
+            }
+          }
+        }
+      };
+    }
+  }
+  if (event.type === "work.item-updated" || event.type === "work.item-claimed" || event.type === "work.comment-posted") {
+    const decoded = decodeWork(event.payload);
+    if (isNone2(decoded)) return state;
+    const work = decoded.value;
+    const project2 = readFact(state, work.projectId);
+    if (project2 === null) return state;
+    const members = Object.entries(project2.recovery ?? {}).filter(
+      ([, member]) => member.pending !== null || member.retriedItemIds.length > 0 || (member.remindedItemIds?.length ?? 0) > 0 || (member.escalatedItemIds?.length ?? 0) > 0 || (member.unprogressedRetryItemIds?.length ?? 0) > 0
+    );
+    if (members.length === 0) return state;
+    const pendingThreads = new Set(
+      members.filter(([, member]) => member.pending !== null).map(([threadId]) => threadId)
+    );
+    const startedThreads = /* @__PURE__ */ new Set();
+    const openWorkThreads = /* @__PURE__ */ new Set();
+    if (pendingThreads.size > 0) {
+      for (const [workItemId, item] of Object.entries(project2.items)) {
+        const pendingAssignees = item.assigneeThreads.filter((id) => pendingThreads.has(id));
+        if (pendingAssignees.length === 0) continue;
+        const workable = isWorkable(project2, workItemId);
+        for (const threadId of pendingAssignees) {
+          if (item.stateGroup === "started") startedThreads.add(threadId);
+          if (workable) openWorkThreads.add(threadId);
+        }
+      }
+    }
+    const before = previous[work.projectId]?.items[work.workItemId];
+    const after = project2.items[work.workItemId];
+    const recovery = { ...project2.recovery };
+    let changed = false;
+    for (const [threadId, member] of members) {
+      const progress = event.type === "work.comment-posted" ? work.actor !== void 0 && !(work.actor.kind === "agent" && work.actor.threadId === threadId) : before?.stateGroup !== after?.stateGroup || before?.stateId !== after?.stateId;
+      const assignedOpen = (id) => isAssignedOpen(project2, id, threadId);
+      const retain = (id) => assignedOpen(id) && !(progress && id === work.workItemId);
+      const remindedItemIds = (member.remindedItemIds ?? []).filter(retain);
+      const escalatedItemIds = (member.escalatedItemIds ?? []).filter(retain);
+      const unprogressedRetryItemIds = (member.unprogressedRetryItemIds ?? []).filter(retain);
+      const retriedItemIds = member.retriedItemIds.filter(assignedOpen);
+      const keepsPending = (member.pending?.kind === "stall" ? startedThreads : openWorkThreads).has(threadId);
+      let pending = keepsPending ? member.pending : null;
+      if (pending?.continuedItemIds !== void 0) {
+        const continuedItemIds = pending.continuedItemIds.filter(retain);
+        if (continuedItemIds.length !== pending.continuedItemIds.length)
+          pending = { ...pending, continuedItemIds };
+      }
+      if (retriedItemIds.length === member.retriedItemIds.length && pending === member.pending && remindedItemIds.length === (member.remindedItemIds?.length ?? 0) && escalatedItemIds.length === (member.escalatedItemIds?.length ?? 0) && unprogressedRetryItemIds.length === (member.unprogressedRetryItemIds?.length ?? 0))
+        continue;
+      changed = true;
+      recovery[threadId] = {
+        ...member,
+        retriedItemIds,
+        remindedItemIds,
+        escalatedItemIds,
+        unprogressedRetryItemIds,
+        pending,
+        handledTurnIds: pending === null && member.pending !== null ? [.../* @__PURE__ */ new Set([...member.handledTurnIds, member.pending.turnId])] : member.handledTurnIds
+      };
+    }
+    return changed ? { ...state, [work.projectId]: { ...project2, recovery } } : state;
+  }
+  return state;
+}
+function dueRecoveries(state, changedThreadId) {
+  return Object.entries(state).flatMap(
+    ([projectId, project2]) => Object.entries(project2.recovery ?? {}).flatMap(([threadId, member]) => {
+      const memberId = project2.memberIds?.[threadId];
+      const leadThreadId = project2.leadThreads?.[0];
+      if (member.pending === null || changedThreadId !== void 0 && threadId !== changedThreadId && member.pending.plan?.recipientThreadId !== changedThreadId || memberId === void 0 || leadThreadId === void 0 || threadId === leadThreadId || !isMember(project2, { threadId }))
+        return [];
+      const stalled = member.pending.kind === "stall";
+      if (member.handledTurnIds.includes(member.pending.turnId)) return [];
+      const items = Object.entries(project2.items).filter(
+        ([workItemId, item]) => (stalled ? item.stateGroup === "started" && item.assigneeThreads.includes(threadId) : isOpenWorkFor(project2, workItemId, threadId) && !isQueuedUnclaimed(item, threadId)) && (!stalled || (member.pending?.plan?.workItemIds.includes(workItemId) || !(member.escalatedItemIds ?? []).includes(workItemId)) && !hasOpenBlocker(project2, workItemId))
+      ).map(([workItemId, item]) => ({
+        workItemId,
+        sequenceId: item.sequenceId,
+        lastCommentId: item.lastCommentId,
+        waitingForReply: item.lastActionCommentThreadId === threadId
+      })).sort((a, b) => a.sequenceId - b.sequenceId);
+      const deferredWakeCount = countDeferredWakes(project2, threadId);
+      return items.length === 0 ? [] : [
+        {
+          ...member.pending,
+          projectId,
+          threadId,
+          memberId,
+          leadThreadId,
+          key: JSON.stringify([threadId, member.pending.turnId]),
+          alreadyRetried: items.some(
+            (item) => member.retriedItemIds.includes(item.workItemId) || (member.remindedItemIds ?? []).includes(item.workItemId) || (member.escalatedItemIds ?? []).includes(item.workItemId) || (member.pending?.continuedItemIds ?? []).includes(item.workItemId)
+          ),
+          items,
+          ...deferredWakeCount > 0 ? { deferredWakeCount } : {}
+        }
+      ];
+    })
+  );
+}
+
 // src/runtime/wakeState.ts
 var WAKE_STATE_KEY = "wakes";
-var WAKE_STATE_VERSION = 5;
+var WAKE_STATE_VERSION = 7;
 var WAKE_EVENTS = [
   "work.item-created",
   "work.item-updated",
@@ -8232,7 +8679,8 @@ var WAKE_EVENTS = [
   "work.relation-added",
   "work.relation-removed",
   "work.comment-posted",
-  "plugin.event-appended"
+  "plugin.event-appended",
+  "thread.session-set"
 ];
 var MemberWokenFact = Struct({
   version: Literal2(1),
@@ -8241,6 +8689,12 @@ var MemberWokenFact = Struct({
   threadId: optionalKey2(String4),
   principalId: optionalKey2(String4)
 });
+var MemberWorktreeFailedFact = Struct({
+  version: Literal2(1),
+  projectId: String4,
+  threadId: String4,
+  reason: String4
+});
 var emptyProject = () => ({
   threads: [],
   leadThreads: [],
@@ -8254,9 +8708,6 @@ var emptyProject = () => ({
 });
 var itemWakeKey = (workItemId, threadId, generation) => generation === 0 ? `item:${workItemId}:${threadId}` : `item:${workItemId}:${threadId}#${generation}`;
 var unblockedWakeKey = (workItemId, threadId, generation) => `unblocked:${workItemId}:${threadId}#${generation}`;
-var hasOpenBlocker = (project2, workItemId) => (readFact(project2.blockers, workItemId) ?? []).some(
-  (blocker) => readFact(project2.items, blocker)?.closed !== true
-);
 var markBlockedAfterClaim = (project2, workItemId) => ({
   ...project2,
   blockedAfterClaim: {
@@ -8275,6 +8726,20 @@ var decodeEnvelope2 = decodeUnknownOption2(
       pluginId: Literal2("team"),
       name: Literal2("team/member-woken"),
       data: MemberWokenFact
+    }),
+    Struct({
+      pluginId: Literal2("team"),
+      name: Literal2("team/member-worktree-failed"),
+      data: MemberWorktreeFailedFact
+    }),
+    Struct({
+      pluginId: Literal2("team"),
+      name: Literal2("team/member-worktree-reported"),
+      data: Struct({
+        version: Literal2(1),
+        projectId: String4,
+        threadId: String4
+      })
     })
   ])
 );
@@ -8288,8 +8753,10 @@ var Actor = Union2([
   Struct({ kind: Literal2("plugin"), pluginId: String4 }),
   Struct({ kind: Literals(["local-cli", "seat", "system"]) })
 ]);
-var StateRef = Struct({ group: String4 });
-var isClosed = (state) => state.group === "completed" || state.group === "cancelled";
+var StateRef = Struct({
+  group: String4,
+  stateId: optionalKey2(String4)
+});
 var itemFields = { projectId: String4, workItemId: String4 };
 var relationFields = {
   ...itemFields,
@@ -8346,7 +8813,6 @@ var decodeWorkEvent = decodeUnknownOption2(
 var agentThreads = (principals) => [
   ...new Set(principals.flatMap((p) => p.kind === "agent" ? [p.threadId] : []))
 ];
-var isMember = (project2, recipient) => "threadId" in recipient ? project2.threads.includes(recipient.threadId) : project2.remoteMembers.includes(recipient.principalId);
 var commentRecipients = (project2, actor, people) => {
   const recipients = /* @__PURE__ */ new Map();
   for (const person of people) {
@@ -8358,7 +8824,7 @@ var commentRecipients = (project2, actor, people) => {
   return [...recipients.values()].filter((recipient) => isMember(project2, recipient));
 };
 var commentWakeKey = (commentId, recipient) => "threadId" in recipient ? `comment:${commentId}:${recipient.threadId}` : `comment:${commentId}:principal:${recipient.principalId}`;
-function foldWakes(state, event) {
+function foldWorkWakes(state, event) {
   if (event.type === "plugin.event-appended") {
     const decoded2 = decodeEnvelope2(event.payload);
     if (isNone2(decoded2)) return state;
@@ -8376,7 +8842,16 @@ function foldWakes(state, event) {
         )
       ];
       const leadThreads = goal.threads.filter((thread) => thread.memberId === goal.leadMemberId).map((thread) => thread.threadId);
-      const next2 = { ...project4, threads, leadThreads, remoteMembers };
+      const memberIds = Object.fromEntries(
+        goal.threads.map((member) => [member.threadId, member.memberId])
+      );
+      const next2 = {
+        ...project4,
+        memberIds,
+        threads,
+        leadThreads,
+        remoteMembers
+      };
       return {
         ...state,
         [goal.projectId]: {
@@ -8385,6 +8860,20 @@ function foldWakes(state, event) {
         }
       };
     }
+    if (fact.name === "team/member-worktree-failed" || fact.name === "team/member-worktree-reported") {
+      const { projectId: projectId3, threadId } = fact.data;
+      const project4 = readFact(state, projectId3) ?? emptyProject();
+      const previous = project4.worktreeFailures?.[threadId];
+      const failure = fact.name === "team/member-worktree-failed" ? previous ?? { reason: fact.data.reason } : previous === void 0 ? void 0 : { ...previous, reported: true };
+      if (failure === void 0 || failure === previous) return state;
+      return {
+        ...state,
+        [projectId3]: {
+          ...project4,
+          worktreeFailures: { ...project4.worktreeFailures, [threadId]: failure }
+        }
+      };
+    }
     const { projectId: projectId2, key } = fact.data;
     const project3 = readFact(state, projectId2) ?? emptyProject();
     if (project3.pendingComments.some((comment) => comment.key === key)) {
@@ -8397,7 +8886,18 @@ function foldWakes(state, event) {
       };
     }
     if (project3.woken.includes(key)) return state;
-    return { ...state, [projectId2]: { ...project3, woken: [...project3.woken, key] } };
+    const items = { ...project3.items };
+    for (const [workItemId2, item] of Object.entries(items)) {
+      for (const threadId of item.assigneeThreads) {
+        if (item.wakeStatus?.[threadId] !== "released" && isWorkable(project3, workItemId2) && key === itemWakeKey(
+          workItemId2,
+          threadId,
+          readFact(project3.rearms, `${workItemId2}:${threadId}`) ?? 0
+        ))
+          items[workItemId2] = { ...item, wakeStatus: { ...item.wakeStatus, [threadId]: "active" } };
+      }
+    }
+    return { ...state, [projectId2]: { ...project3, items, woken: [...project3.woken, key] } };
   }
   const decoded = decodeWorkEvent(event);
   if (isNone2(decoded)) return state;
@@ -8415,8 +8915,15 @@ function foldWakes(state, event) {
           [workItemId]: {
             sequenceId: work.payload.sequenceId,
             assigneeThreads: agentThreads(work.payload.assignees),
+            wakeStatus: Object.fromEntries(
+              agentThreads(work.payload.assignees).map((threadId) => [
+                threadId,
+                "pending"
+              ])
+            ),
             claimedBy: [],
-            closed: isClosed(work.payload.state)
+            stateGroup: work.payload.state.group,
+            ...work.payload.state.stateId === void 0 ? {} : { stateId: work.payload.state.stateId }
           }
         }
       };
@@ -8430,6 +8937,22 @@ function foldWakes(state, event) {
           ...agentThreads([work.payload.assignee])
         ])
       ];
+      const wakeStatus = { ...currentItem.wakeStatus };
+      for (const threadId of currentItem.assigneeThreads)
+        if (!assigneeThreads.includes(threadId)) wakeStatus[threadId] = "released";
+      for (const threadId of assigneeThreads) {
+        if (!currentItem.assigneeThreads.includes(threadId)) {
+          const generation = readFact(project2.rearms, `${workItemId}:${threadId}`) ?? 0;
+          wakeStatus[threadId] = project2.woken.includes(
+            itemWakeKey(workItemId, threadId, generation)
+          ) ? "released" : "pending";
+        }
+        if (wakeStatus[threadId] === "active" && (isClosed({ stateGroup: work.payload.state?.group ?? currentItem.stateGroup }) || work.payload.state?.group === "unstarted" || work.payload.state?.group === "backlog"))
+          wakeStatus[threadId] = "released";
+      }
+      if (work.type === "work.item-claimed" && hasOpenBlocker(project2, workItemId))
+        for (const threadId of agentThreads([work.payload.assignee]))
+          wakeStatus[threadId] = "released";
       next = {
         ...project2,
         items: {
@@ -8437,8 +8960,11 @@ function foldWakes(state, event) {
           [workItemId]: {
             ...currentItem,
             assigneeThreads,
+            wakeStatus,
             claimedBy: work.type === "work.item-claimed" ? [.../* @__PURE__ */ new Set([...currentItem.claimedBy, ...agentThreads([work.payload.assignee])])] : currentItem.claimedBy,
-            closed: work.payload.state === void 0 ? currentItem.closed : isClosed(work.payload.state)
+            ...work.payload.state === void 0 ? {} : { stateGroup: work.payload.state.group },
+            ...work.payload.state?.stateId === void 0 ? {} : { stateId: work.payload.state.stateId },
+            lastActionCommentThreadId: null
           }
         }
       };
@@ -8458,16 +8984,26 @@ function foldWakes(state, event) {
           [workItemId]: work.type === "work.relation-added" ? [.../* @__PURE__ */ new Set([...blockers, related])] : blockers.filter((blocker) => blocker !== related)
         }
       };
-      if (work.type === "work.relation-added" && currentItem !== null && readFact(project2.items, related)?.closed !== true) {
+      if (work.type === "work.relation-added" && currentItem !== null && !isClosed(readFact(project2.items, related))) {
         const woken = new Set(project2.woken);
         const rearms = { ...project2.rearms };
+        const wakeStatus = { ...currentItem.wakeStatus };
         for (const threadId of currentItem.assigneeThreads) {
-          if (currentItem.claimedBy.includes(threadId)) continue;
+          if (currentItem.claimedBy.includes(threadId)) {
+            wakeStatus[threadId] = "released";
+            continue;
+          }
           const generation = rearms[`${workItemId}:${threadId}`] ?? 0;
-          if (woken.has(itemWakeKey(workItemId, threadId, generation)))
+          if (woken.has(itemWakeKey(workItemId, threadId, generation))) {
             rearms[`${workItemId}:${threadId}`] = generation + 1;
+            if (wakeStatus[threadId] !== "released") wakeStatus[threadId] = "pending";
+          }
         }
-        next = { ...next, rearms };
+        next = {
+          ...next,
+          rearms,
+          items: { ...next.items, [workItemId]: { ...currentItem, wakeStatus } }
+        };
         if (currentItem.claimedBy.length > 0 && !hasOpenBlocker(project2, workItemId))
           next = markBlockedAfterClaim(next, workItemId);
       }
@@ -8487,45 +9023,104 @@ function foldWakes(state, event) {
       })).filter(
         (comment) => !project2.pendingComments.some((pending) => pending.key === comment.key)
       );
-      if (comments.length === 0) return state;
-      next = { ...project2, pendingComments: [...project2.pendingComments, ...comments] };
+      next = {
+        ...project2,
+        pendingComments: [...project2.pendingComments, ...comments],
+        items: currentItem === null ? project2.items : {
+          ...project2.items,
+          [workItemId]: {
+            ...currentItem,
+            lastCommentId: commentId,
+            lastActionCommentThreadId: actor.kind === "agent" ? actor.threadId : null
+          }
+        }
+      };
       break;
     }
   }
   return { ...state, [projectId]: next };
 }
-var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function foldWakes(state, event) {
+  return foldRecovery(foldWorkWakes(state, event), event, state);
+}
+var compare2 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var itemWakeCandidate = (projectId, project2, workItemId, item, threadId, woken) => {
+  if (!project2.threads.includes(threadId) || !isWorkable(project2, workItemId)) return null;
+  const unblocked = readFact(project2.blockedAfterClaim, workItemId) ?? 0;
+  const finishing = unblocked > 0 && item.claimedBy.includes(threadId);
+  if (!finishing && !item.assigneeThreads.includes(threadId)) return null;
+  const lead = project2.leadThreads?.includes(threadId) === true;
+  const key = finishing ? unblockedWakeKey(workItemId, threadId, unblocked) : itemWakeKey(workItemId, threadId, readFact(project2.rearms, `${workItemId}:${threadId}`) ?? 0);
+  if (woken.has(key) || !finishing && !lead && item.wakeStatus?.[threadId] === "released")
+    return null;
+  return {
+    key,
+    projectId,
+    threadId,
+    kind: finishing ? "unblocked" : "item",
+    workItemId,
+    sequenceId: item.sequenceId,
+    // 成员的叫醒话里点名负责人（卡住时找谁）；带队自己和解挡续做不带。
+    ...lead ? { lead: true } : finishing || project2.leadThreads?.[0] === void 0 ? {} : { leadThreadId: project2.leadThreads[0] }
+  };
+};
+var needsMemberSlot = (wake) => wake.kind === "item" && wake.lead !== true;
+function memberItemSlots(projectId, project2, woken, onlyThreadId) {
+  const busy = /* @__PURE__ */ new Set();
+  const slots = /* @__PURE__ */ new Map();
+  for (const [workItemId, item] of Object.entries(project2.items)) {
+    if (onlyThreadId !== void 0 && !item.assigneeThreads.includes(onlyThreadId)) continue;
+    if (!isWorkable(project2, workItemId)) continue;
+    for (const threadId of item.assigneeThreads) {
+      if (onlyThreadId !== void 0 && threadId !== onlyThreadId || project2.leadThreads?.includes(threadId) || !project2.threads.includes(threadId))
+        continue;
+      if (item.wakeStatus?.[threadId] === "active") busy.add(threadId);
+      const candidate = itemWakeCandidate(projectId, project2, workItemId, item, threadId, woken);
+      if (candidate === null || !needsMemberSlot(candidate)) continue;
+      const first = slots.get(threadId);
+      if (first === void 0 || compareWakeItems(candidate, first) < 0)
+        slots.set(threadId, candidate);
+    }
+  }
+  for (const threadId of busy) slots.delete(threadId);
+  return slots;
+}
+function isWakeDue(state, wake) {
+  const project2 = readFact(state, wake.projectId);
+  if (project2 === null) return false;
+  if (wake.kind === "comment")
+    return project2.pendingComments.some((comment) => comment.key === wake.key);
+  if (!("threadId" in wake)) return false;
+  const item = readFact(project2.items, wake.workItemId);
+  if (item === null) return false;
+  const woken = new Set(project2.woken);
+  const candidate = itemWakeCandidate(
+    wake.projectId,
+    project2,
+    wake.workItemId,
+    item,
+    wake.threadId,
+    woken
+  );
+  if (candidate?.key !== wake.key) return false;
+  return !needsMemberSlot(candidate) || memberItemSlots(wake.projectId, project2, woken, wake.threadId).get(wake.threadId)?.key === wake.key;
+}
 function dueWakes(state) {
   const due = [];
   for (const [projectId, project2] of Object.entries(state)) {
     const woken = new Set(project2.woken);
-    const threads = new Set(project2.threads);
-    const leads = new Set(project2.leadThreads ?? []);
+    const slots = memberItemSlots(projectId, project2, woken);
     for (const [workItemId, item] of Object.entries(project2.items)) {
-      if (item.closed || hasOpenBlocker(project2, workItemId)) continue;
       const unblocked = readFact(project2.blockedAfterClaim, workItemId) ?? 0;
       const recipients = /* @__PURE__ */ new Set([
         ...item.assigneeThreads,
         ...unblocked > 0 ? item.claimedBy : []
       ]);
       for (const threadId of recipients) {
-        if (!threads.has(threadId)) continue;
-        const finishing = unblocked > 0 && item.claimedBy.includes(threadId);
-        const key = finishing ? unblockedWakeKey(workItemId, threadId, unblocked) : itemWakeKey(
-          workItemId,
-          threadId,
-          readFact(project2.rearms, `${workItemId}:${threadId}`) ?? 0
-        );
-        if (woken.has(key)) continue;
-        due.push({
-          key,
-          projectId,
-          threadId,
-          kind: finishing ? "unblocked" : "item",
-          workItemId,
-          sequenceId: item.sequenceId,
-          ...leads.has(threadId) ? { lead: true } : finishing || project2.leadThreads?.[0] === void 0 ? {} : { leadThreadId: project2.leadThreads[0] }
-        });
+        const candidate = itemWakeCandidate(projectId, project2, workItemId, item, threadId, woken);
+        if (candidate === null) continue;
+        if (needsMemberSlot(candidate) && slots.get(threadId)?.key !== candidate.key) continue;
+        due.push(candidate);
       }
     }
     for (const comment of project2.pendingComments) {
@@ -8537,7 +9132,7 @@ function dueWakes(state) {
       });
     }
   }
-  return due.sort((a, b) => compare(a.projectId, b.projectId) || compare(a.key, b.key));
+  return due.sort((a, b) => compare2(a.projectId, b.projectId) || compare2(a.key, b.key));
 }
 
 // src/runtime/wake.ts
@@ -8549,14 +9144,19 @@ var descriptionStart = (description) => {
   if (first === "") return "";
   const points = Array.from(first);
   const summary = points.length > ITEM_SUMMARY_MAX_CHARS ? `${points.slice(0, ITEM_SUMMARY_MAX_CHARS).join("")}\u2026` : first;
-  return ` Its description starts: ${summary}`;
+  return `Its description starts: ${summary}`;
+};
+var itemHeadline = (sequenceId, item) => {
+  const title = item?.title ? `${sequenceId === void 0 ? "Work item" : `W${sequenceId}`}: ${item.title}.` : "";
+  const parts = [title, descriptionStart(item?.description)].filter((part) => part !== "");
+  return parts.length === 0 ? "" : `${parts.join(" ")} `;
 };
-var itemText = (workItemId, sequenceId, item, leadThreadId) => `You have ${titled(workItemId, sequenceId, item?.title)}.${descriptionStart(item?.description)} Read it with work_read_items, passing workItemIds: ["${workItemId}"]. If it is blocked by items that are not done yet, do not start it; you will be told again when they are done. Otherwise claim it with work_claim_item. Before you change anything, search this repository's rules and checks with memory_search and follow what applies. Then work on it. ${MEMBER_CHECKS_RULE} ${memberStuckRule(leadThreadId)} ${handbookMessage("memberBrief")} ${PERSON_MESSAGE_RULE}`;
+var itemText = (workItemId, sequenceId, item, leadThreadId) => `${itemHeadline(sequenceId, item)}You have ${workLabel(workItemId, sequenceId)}. Read it with work_read_items, passing workItemIds: ["${workItemId}"]. If it is blocked by items that are not done yet, do not start it; you will be told again when they are done. Otherwise claim it with work_claim_item. Before you change anything, search this repository's rules and checks with memory_search and follow what applies. Then work on it. ${MEMBER_CHECKS_RULE} ${memberStuckRule(leadThreadId)} ${handbookMessage("memberBrief")} ${PERSON_MESSAGE_RULE}`;
 var leadItemText = (workItemId, sequenceId, title) => `You have ${titled(workItemId, sequenceId, title)}. You lead this team, so this item is the goal itself: do not claim it or do its work yourself. Read it with work_read_items, passing workItemIds: ["${workItemId}"]. If it has no work items yet, split it as your team brief says. ${LEAD_SPLIT_RULE} ${LEAD_OWN_ITEM_RULE} Record dependencies and assign each item to one member as the brief describes. ${LEAD_NO_MEMBER_TASKS} ${PERSON_MESSAGE_RULE}`;
 var leadUnblockedText = (workItemId, sequenceId, title) => `Everything blocking ${titled(workItemId, sequenceId, title)} is done now. Read those items with work_read_items and check the results. ${LEAD_SEND_BACK_RULE} When all of them are acceptable, mark this item done with work_update_item. ${LEAD_NO_MEMBER_TASKS}`;
 var unblockedText = (workItemId, sequenceId, title) => `Everything blocking ${titled(workItemId, sequenceId, title)} is done now. Read those items with work_read_items, finish this one, and mark it done with work_update_item.`;
 var commentText2 = (workItemId, sequenceId) => `There is a new comment for you on ${workLabel(workItemId, sequenceId)}. Read it with work_list_comments, passing workItemId: "${workItemId}", and reply there if needed.`;
-function startWakeRuntime(ctx, options = {}) {
+function startWakeRuntime(ctx, goals, options = {}) {
   const wakes = ctx.derivedState({
     key: WAKE_STATE_KEY,
     version: WAKE_STATE_VERSION,
@@ -8564,6 +9164,7 @@ function startWakeRuntime(ctx, options = {}) {
     init: () => ({}),
     apply: foldWakes
   });
+  const worktrees = createMemberWorktreeLane(wakes, ctx.events);
   const hash2 = options.hash ?? stableHash;
   let pending = Promise.resolve();
   const readItem = async (projectId, workItemId) => {
@@ -8571,15 +9172,18 @@ function startWakeRuntime(ctx, options = {}) {
     return result2.items.find((item) => item.workItemId === workItemId);
   };
   const execute = async () => {
-    const state = await wakes.get();
+    let state = await wakes.get();
     for (const wake of dueWakes(state)) {
+      if (!isWakeDue(state, wake)) continue;
       try {
         const id = hash2(wake.key);
+        const worktree = memberWorktreeFor(goals, state[wake.projectId], wake.projectId, wake);
         const delivered = await deliverWake(ctx, {
           projectId: wake.projectId,
           recipient: wake,
           requestId: `team-wake:${id}`,
           messageId: `team-wake-msg:${id}`,
+          memberWorktree: worktree === void 0 ? void 0 : { ...worktree, lane: worktrees },
           text: async () => {
             if ("principalId" in wake || wake.kind === "comment")
               return commentText2(wake.workItemId, wake.sequenceId);
@@ -8606,7 +9210,7 @@ function startWakeRuntime(ctx, options = {}) {
             ..."principalId" in wake ? { principalId: wake.principalId } : { threadId: wake.threadId }
           }
         });
-        await wakes.get({ throughSequence: receipt.sequence });
+        state = await wakes.get({ throughSequence: receipt.sequence });
       } catch (error) {
         ctx.log?.warn("team member wake failed", { key: wake.key, error });
       }
@@ -8620,10 +9224,216 @@ function startWakeRuntime(ctx, options = {}) {
     );
     return result2;
   };
-  ctx.reactor({ name: "team-wake", events: WAKE_EVENTS, handle: () => flush() });
+  ctx.reactor({
+    name: "team-wake",
+    events: WAKE_EVENTS,
+    handle: (event) => event.type === "thread.session-set" || isRecoveryFact(event) ? Promise.resolve() : flush()
+  });
   const ready = flush();
   void ready.catch((error) => ctx.log?.warn("team wake catch-up failed", { error }));
-  return { flush, ready };
+  return { flush, ready, state: wakes, worktrees };
+}
+
+// src/runtime/recovery.ts
+var readStallExecution = async (ctx, threadId) => {
+  const shell = await ctx.threads.get({ threadId });
+  const summary = await ctx.threads.execution.summary({ threadId, limit: 1 });
+  return { ...shell, queuePaused: summary.queuePaused, summary };
+};
+var itemLabel = (item) => `W${item.sequenceId} (workItemId ${item.workItemId})`;
+var deferredText = (recovery) => recovery.deferredWakeCount === void 0 ? "" : `They also have ${recovery.deferredWakeCount} assigned ${recovery.deferredWakeCount === 1 ? "item that has" : "items that have"} not been woken yet. `;
+var leadText = (recovery, name, paused) => `Member ${name} (threadId ${recovery.threadId}) stopped because of an upstream error (${recovery.category}). ${recovery.items.map(itemLabel).join(", ")} ${recovery.items.length === 1 ? "is" : "are"} still open. ${deferredText(recovery)}${recovery.alreadyRetried ? "An automatic continuation has already been attempted for this work during these consecutive failures. " : ""}${leadInstructions(paused)}`;
+var commentInstructions = (recovery) => recovery.items.map(
+  (item) => item.lastCommentId === void 0 ? `${itemLabel(item)} has no comments yet. Continue from your existing workspace changes and turn history.` : `For ${itemLabel(item)}, the latest comment is commentId ${item.lastCommentId}. Read work_list_comments with workItemId: "${item.workItemId}" and continue from that comment and your existing workspace changes; do not start over.`
+).join("\n");
+var leadInstructions = (paused = false) => `${paused ? "Their sending is paused; a person needs to click Resume sending. " : ""}You can post a comment mentioning the member with work_post_comment to ask them to continue (the comment wakes them), reassign the work with work_update_item, or report the problem to the person.${paused ? " A comment will wait until the person resumes sending." : ""}`;
+var resumeText = (recovery) => `Your previous turn was interrupted by an upstream error (${recovery.category}). Continue ${recovery.items.map(itemLabel).join(", ")} from where you stopped.
+${commentInstructions(recovery)}`;
+var remindText = (recovery) => `Your turn ended normally, but ${recovery.items.map(itemLabel).join(", ")} ${recovery.items.length === 1 ? "is" : "are"} still in progress. If finished, mark the work done with work_update_item. If blocked, explain where you are stuck on the item with work_post_comment. Otherwise continue from where you stopped; do not start over.
+${commentInstructions(recovery)}`;
+var stallLeadText = (recovery, name) => `Member ${name} (threadId ${recovery.threadId}) ended this turn normally, but ${recovery.items.map(itemLabel).join(", ")} ${recovery.items.length === 1 ? "is" : "are"} still open. ${deferredText(recovery)}${recovery.alreadyRetried ? "They have already been reminded once to continue this work, with no progress since. " : ""}${recovery.items.filter((item) => item.waitingForReply).map(
+  (item) => `Their last action on ${itemLabel(item)} was their own comment (commentId ${item.lastCommentId}); reply to it or arrange another member to help. `
+).join("")}${leadInstructions()}`;
+function startRecoveryRuntime(ctx, goals, state, worktrees) {
+  let pending = Promise.resolve();
+  let disposed = false;
+  const execute = async (scope2) => {
+    if (disposed) return;
+    const current = await state.get();
+    let projects = current;
+    if (scope2?.kind === "project") {
+      const project2 = readFact(current, scope2.projectId);
+      projects = project2 === null ? {} : { [scope2.projectId]: project2 };
+    } else if (scope2?.kind === "thread") {
+      projects = Object.fromEntries(
+        Object.entries(current).filter(
+          ([, project2]) => Object.entries(project2.recovery ?? {}).some(
+            ([threadId, member]) => threadId === scope2.threadId || member.pending?.plan?.recipientThreadId === scope2.threadId
+          )
+        )
+      );
+    }
+    const recoveries = dueRecoveries(
+      projects,
+      scope2?.kind === "thread" ? scope2.threadId : void 0
+    );
+    const wakingThreads = new Set(
+      recoveries.some((recovery) => recovery.kind === "stall") ? dueWakes(projects).flatMap((wake) => "threadId" in wake ? [wake.threadId] : []) : []
+    );
+    for (const recovery of recoveries) {
+      try {
+        const stalled = recovery.kind === "stall";
+        const execution = stalled ? await readStallExecution(ctx, recovery.threadId) : await ctx.projections.getThreadExecution(recovery.threadId);
+        const queuedContinuation = recovery.plan?.resumeQueue === true;
+        if (execution === null || execution.archivedAt !== null || execution.session == null || !queuedContinuation && (execution.session.activeTurnId !== null || execution.latestTurn?.turnId !== recovery.turnId || (stalled ? !["ready", "idle", "stopped"].includes(execution.session.status) || execution.latestTurn.state !== "completed" || execution.latestTurn.completedAt === null : execution.session.status !== "error" || execution.latestTurn.state !== "error")))
+          continue;
+        if ("summary" in execution) {
+          if (execution.summary.queuePaused || execution.summary.pendingApprovalCount > 0 || execution.summary.pendingUserInputCount > 0 || execution.summary.queue.length > 0 || (execution.pendingAsyncQuestionCount ?? 0) > 0 || // 成员给人发了消息、人还没回：他在等回答，不提醒也不叫负责人。
+          (execution.awaitingPersonReplyCount ?? 0) > 0)
+            continue;
+          if (wakingThreads.has(recovery.threadId) || Object.values(projects).some(
+            (project2) => Object.values(project2.recovery ?? {}).some(
+              (member) => member.pending?.plan?.recipientThreadId === recovery.threadId && member.pending !== current[recovery.projectId]?.recovery?.[recovery.threadId]?.pending
+            )
+          ))
+            continue;
+        }
+        const id = stableHash(recovery.key);
+        let plan = recovery.plan;
+        let tryQueueResume = false;
+        const requestPlan = async (next) => {
+          const receipt2 = await ctx.events.append({
+            commandId: `team-recovery-requested:${id}:${next.action}${next.resumeQueue === true ? "-queue" : ""}`,
+            name: "member-recovery-requested",
+            aggregate: { kind: "project", id: recovery.projectId },
+            data: {
+              version: 1,
+              projectId: recovery.projectId,
+              threadId: recovery.threadId,
+              turnId: recovery.turnId,
+              failureSequence: recovery.sequence,
+              plan: next
+            }
+          });
+          await state.get({ throughSequence: receipt2.sequence });
+        };
+        if (plan === void 0 || plan.action === "resume" && execution.queuePaused && plan.resumeQueue !== true) {
+          const resume = !stalled && (!recovery.alreadyRetried || plan?.action === "resume") && (recovery.category === "transport" || recovery.category === "rate-limit" && !execution.queuePaused);
+          const remind = stalled && !recovery.alreadyRetried && !recovery.items.some((item) => item.waitingForReply);
+          const goal = resume || remind ? null : await goals.read(recovery.projectId);
+          const name = goal?.members.find((member) => member.threadId === recovery.threadId)?.name ?? recovery.memberId;
+          plan = {
+            action: stalled ? remind ? "remind" : "stall-lead" : resume ? "resume" : "lead",
+            recipientThreadId: resume || remind ? recovery.threadId : recovery.leadThreadId,
+            text: stalled ? remind ? remindText(recovery) : stallLeadText(recovery, name) : resume ? resumeText(recovery) : leadText(recovery, name, execution.queuePaused),
+            workItemIds: recovery.items.map((item) => item.workItemId),
+            ...resume && execution.queuePaused ? { resumeQueue: true } : {}
+          };
+          await requestPlan(plan);
+          tryQueueResume = plan.resumeQueue === true;
+        }
+        if (plan.resumeQueue === true && execution.queuePaused) {
+          const project2 = (await state.get())[recovery.projectId];
+          if (project2 === void 0 || !isMember(project2, { threadId: recovery.threadId }) || project2.leadThreads?.includes(recovery.threadId) || project2.recovery?.[recovery.threadId]?.pending?.turnId !== recovery.turnId)
+            continue;
+          let resumed = false;
+          let outcome = "already-attempted";
+          if (tryQueueResume) {
+            try {
+              const receipt2 = await ctx.threads.turnQueue.resume({
+                requestId: `team-recovery-queue:${id}`,
+                threadId: recovery.threadId
+              });
+              resumed = receipt2.status === "accepted";
+              outcome = "noop";
+            } catch {
+              outcome = "rejected";
+            }
+          }
+          if (!resumed) {
+            const latest = await ctx.projections.getThreadExecution(recovery.threadId).catch(() => null);
+            resumed = latest?.queuePaused === false;
+            ctx.log.warn("team member queue recovery refused", {
+              threadId: recovery.threadId,
+              turnId: recovery.turnId,
+              outcome,
+              queuePaused: !resumed
+            });
+          }
+          if (!resumed) {
+            const goal = await goals.read(recovery.projectId);
+            const name = goal?.members.find((member) => member.threadId === recovery.threadId)?.name ?? recovery.memberId;
+            plan = {
+              action: "lead",
+              recipientThreadId: recovery.leadThreadId,
+              text: leadText(recovery, name, true),
+              workItemIds: plan.workItemIds
+            };
+            await requestPlan(plan);
+          }
+        }
+        const worktree = memberWorktreeFor(goals, current[recovery.projectId], recovery.projectId, {
+          threadId: plan.recipientThreadId
+        });
+        const delivered = await deliverWake(ctx, {
+          projectId: recovery.projectId,
+          recipient: { threadId: plan.recipientThreadId },
+          requestId: `team-recovery:${id}:${plan.action}`,
+          messageId: `team-recovery-msg:${id}:${plan.action}`,
+          text: plan.text,
+          memberWorktree: worktree === void 0 ? void 0 : { ...worktree, lane: worktrees }
+        });
+        if (!delivered) continue;
+        const receipt = await ctx.events.append({
+          commandId: `team-recovered:${id}:${plan.action}`,
+          name: "member-recovery-delivered",
+          aggregate: { kind: "project", id: recovery.projectId },
+          data: {
+            version: 1,
+            projectId: recovery.projectId,
+            threadId: recovery.threadId,
+            turnId: recovery.turnId,
+            failureSequence: recovery.sequence,
+            action: plan.action,
+            workItemIds: plan.workItemIds
+          }
+        });
+        await state.get({ throughSequence: receipt.sequence });
+      } catch (error) {
+        ctx.log.warn("team member recovery failed", { key: recovery.key, error });
+      }
+    }
+  };
+  const flush = (scope2) => {
+    const result2 = pending.then(() => execute(scope2));
+    pending = result2.catch(() => void 0);
+    return result2;
+  };
+  ctx.reactor({
+    name: "team-member-recovery",
+    events: [
+      "thread.session-set",
+      "thread.turn-queue-paused",
+      "plugin.event-appended",
+      "work.item-updated",
+      "work.item-claimed",
+      "work.comment-posted",
+      "work.relation-added",
+      "work.relation-removed",
+      "thread.turn-intent-queued",
+      "thread.turn-intent-transitioned",
+      "thread.turn-queue-updated",
+      "thread.request-resolved",
+      "thread.user-input-pending"
+    ],
+    handle: (event) => flush(recoveryEventScopeOf(event))
+  });
+  ctx.onDispose(() => {
+    disposed = true;
+  });
+  const ready = flush();
+  void ready.catch((error) => ctx.log.warn("team member recovery catch-up failed", { error }));
+  return { ready, flush };
 }
 
 // src/handbook/content.ts
@@ -8916,7 +9726,7 @@ var terminalFailure = (error) => {
   if (!rejected && !invalid2) return null;
   return error instanceof Error ? error.message : "detail" in error ? String(error.detail) : String(reason);
 };
-function startHandbookRuntime(ctx) {
+function startHandbookRuntime(ctx, worktrees) {
   const state = ctx.derivedState({
     key: "handbook",
     version: 5,
@@ -8995,16 +9805,24 @@ function startHandbookRuntime(ctx) {
   };
   const remind = async () => {
     const snapshot = await state.get();
+    const wakeState = Object.keys(snapshot.pendingReminders).length === 0 ? void 0 : await worktrees.lane.state.get();
     for (const [key, reminder] of Object.entries(snapshot.pendingReminders)) {
       const { projectId, release, member } = reminder;
       try {
         const id = stableHash(key);
+        const worktree = memberWorktreeFor(
+          worktrees.goals,
+          wakeState?.[projectId],
+          projectId,
+          member.recipient
+        );
         const delivered = await deliverWake(ctx, {
           projectId,
           recipient: member.recipient,
           requestId: `team-handbook:${id}`,
           messageId: `team-handbook-msg:${id}`,
-          text: handbookMessage("reminder", release)
+          text: handbookMessage("reminder", release),
+          memberWorktree: worktree === void 0 ? void 0 : { ...worktree, lane: worktrees.lane }
         });
         if (!delivered) continue;
         const previousKey = JSON.stringify([release, member.memberId]);
@@ -9329,7 +10147,7 @@ function registerHandbookPanel(ctx, runtime) {
 // src/index.ts
 var index_default = definePlugin({
   id: "team",
-  apiVersion: 28,
+  apiVersion: 30,
   activate(ctx) {
     const rosters = createRosterService(ctx);
     registerRosterCommands(ctx, rosters);
@@ -9337,8 +10155,9 @@ var index_default = definePlugin({
     registerGoalCommands(ctx, goals);
     registerBoardCommands(ctx, goals, rosters);
     registerDetailCommands(ctx, goals);
-    startWakeRuntime(ctx);
-    const handbook = startHandbookRuntime(ctx);
+    const wakes = startWakeRuntime(ctx, goals);
+    startRecoveryRuntime(ctx, goals, wakes.state, wakes.worktrees);
+    const handbook = startHandbookRuntime(ctx, { lane: wakes.worktrees, goals });
     registerHandbook(ctx, handbook);
     registerHandbookPanel(ctx, handbook);
   }