@ycodium-ai/plugin-team 0.2.3244 → 0.2.3252

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;
@@ -7065,6 +7065,7 @@ var en_default = {
     toolkitsOff: "The lead needs the board and project memory. Turn on both switches above.",
     toolkitsOn: "The board and project memory are on for this project.",
     staleRevision: "The roster was changed elsewhere and has been reloaded.",
+    updatedElsewhere: "The roster was changed elsewhere. Saving now discards your unsaved edits \u2014 copy them somewhere safe first.",
     loadFailed: "The roster could not be loaded. Try reloading it.",
     saveFailed: "The roster could not be saved. Try again.",
     invalidPayload: "Check the roster fields and try again.",
@@ -7165,7 +7166,14 @@ function handbookMessage(key, release) {
 }
 
 // src/domain/leadBrief.ts
-var PERSON_MESSAGE_RULE = "Send a message to the person only when you need their answer; put progress and updates in work item comments with work_post_comment instead.";
+var PERSON_MESSAGE_RULE = "Send a message to the person only for a product decision you cannot make yourself; put progress, updates and technical problems in work item comments with work_post_comment instead.";
+var MEMBER_CHECKS_RULE = "Before you mark an item done, run the checks that this project's rules name for the code you changed, and fix every failure. Do not mark an item done while a check still fails; say in a work item comment what still fails instead.";
+var memberStuckRule = (leadThreadId) => {
+  const mention = leadThreadId === void 0 ? "" : ` that mentions your lead (mentions: [{ "kind": "agent", "threadId": "${leadThreadId}" }])`;
+  const reply = leadThreadId === void 0 ? "" : " Your lead will reply or change the plan.";
+  return `If the same error still fails after you have tried to fix it twice, stop and post a work item comment with work_post_comment${mention} saying what fails and what you tried.${reply}`;
+};
+var LEAD_STUCK_RULE = "When a member mentions you in a comment because they are stuck, answer in that item's comments: give a direction, split the item, or reassign it.";
 var LEAD_SPLIT_RULE = "Use work_create_item to split the goal into a few work items: one item per task, with a clear action in the title. Members do not see this conversation or your goal, so put everything a member needs into the description: the deliverable, the constraints, and how to hand the work in. Create them without assignees.";
 var LEAD_OWN_ITEM_RULE = "If a work item for this goal is assigned to you, also record it as blocked by every item you create. When they are all done you will be told; then check the results and mark that item done with work_update_item.";
 var LEAD_SEND_BACK_RULE = "If a finished item is not acceptable, send it back: use work_update_item to set its state back to an open one (see work_list_states), and change its assignees too if someone else should redo it. Then say what is wrong in a comment with work_post_comment, mentioning the member.";
@@ -7196,7 +7204,8 @@ function leadBrief(goal, roster) {
     'Then use work_add_relation with type "blocked_by" to record dependencies: the dependent workItemId is blocked by the prerequisite relatedWorkItemId.',
     LEAD_OWN_ITEM_RULE,
     LEAD_SEND_BACK_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}`,
+    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>" }]. 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."
@@ -7209,6 +7218,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();
@@ -7324,7 +7334,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 });
@@ -8213,9 +8223,342 @@ async function deliverWake(ctx, input) {
   return true;
 }
 
+// src/runtime/wakeQueries.ts
+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/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",
@@ -8223,7 +8566,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),
@@ -8245,9 +8589,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: {
@@ -8279,8 +8620,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,
@@ -8337,7 +8680,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) {
@@ -8349,7 +8691,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;
@@ -8367,7 +8709,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]: {
@@ -8388,7 +8739,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;
@@ -8406,8 +8768,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 }
           }
         }
       };
@@ -8421,6 +8790,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: {
@@ -8428,8 +8813,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
           }
         }
       };
@@ -8449,16 +8837,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);
       }
@@ -8478,45 +8876,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 } : {}
-        });
+        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) {
@@ -8528,13 +8985,26 @@ 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
 var workLabel = (workItemId, sequenceId) => sequenceId === void 0 ? `the work item with workItemId ${workItemId}` : `work item W${sequenceId} (workItemId ${workItemId})`;
 var titled = (workItemId, sequenceId, title) => `${workLabel(workItemId, sequenceId)}${title ? `: ${title}` : ""}`;
-var itemText = (workItemId, sequenceId, title) => `You have ${titled(workItemId, sequenceId, title)}. 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. ${handbookMessage("memberBrief")} ${PERSON_MESSAGE_RULE}`;
+var ITEM_SUMMARY_MAX_CHARS = 300;
+var descriptionStart = (description) => {
+  const first = description?.trim().split(/\n\s*\n/u)[0]?.trim() ?? "";
+  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}`;
+};
+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) => `${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.`;
@@ -8549,13 +9019,14 @@ function startWakeRuntime(ctx, options = {}) {
   });
   const hash2 = options.hash ?? stableHash;
   let pending = Promise.resolve();
-  const readTitle = async (projectId, workItemId) => {
+  const readItem = async (projectId, workItemId) => {
     const result2 = await ctx.work.items.get({ projectId, workItemIds: [workItemId] });
-    return result2.items.find((item) => item.workItemId === workItemId)?.title;
+    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 delivered = await deliverWake(ctx, {
@@ -8563,11 +9034,19 @@ function startWakeRuntime(ctx, options = {}) {
           recipient: wake,
           requestId: `team-wake:${id}`,
           messageId: `team-wake-msg:${id}`,
-          text: async () => "principalId" in wake || wake.kind === "comment" ? commentText2(wake.workItemId, wake.sequenceId) : (wake.kind === "item" ? wake.lead === true ? leadItemText : itemText : wake.lead === true ? leadUnblockedText : unblockedText)(
-            wake.workItemId,
-            wake.sequenceId,
-            await readTitle(wake.projectId, wake.workItemId)
-          )
+          text: async () => {
+            if ("principalId" in wake || wake.kind === "comment")
+              return commentText2(wake.workItemId, wake.sequenceId);
+            const item = await readItem(wake.projectId, wake.workItemId);
+            const title = item?.title;
+            if (wake.kind === "item")
+              return wake.lead === true ? leadItemText(wake.workItemId, wake.sequenceId, title) : itemText(wake.workItemId, wake.sequenceId, item, wake.leadThreadId);
+            return (wake.lead === true ? leadUnblockedText : unblockedText)(
+              wake.workItemId,
+              wake.sequenceId,
+              title
+            );
+          }
         });
         if (!delivered) continue;
         const receipt = await ctx.events.append({
@@ -8581,7 +9060,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 });
       }
@@ -8595,10 +9074,212 @@ 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 };
+}
+
+// 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) {
+  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 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
+        });
+        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
@@ -9304,7 +9985,7 @@ function registerHandbookPanel(ctx, runtime) {
 // src/index.ts
 var index_default = definePlugin({
   id: "team",
-  apiVersion: 27,
+  apiVersion: 29,
   activate(ctx) {
     const rosters = createRosterService(ctx);
     registerRosterCommands(ctx, rosters);
@@ -9312,7 +9993,8 @@ var index_default = definePlugin({
     registerGoalCommands(ctx, goals);
     registerBoardCommands(ctx, goals, rosters);
     registerDetailCommands(ctx, goals);
-    startWakeRuntime(ctx);
+    const wakes = startWakeRuntime(ctx);
+    startRecoveryRuntime(ctx, goals, wakes.state);
     const handbook = startHandbookRuntime(ctx);
     registerHandbook(ctx, handbook);
     registerHandbookPanel(ctx, handbook);