@ycodium-ai/plugin-team 0.2.3272 → 0.2.3306

package/dist/index.js

@@ -6894,7 +6894,8 @@ var en_default = {
     noGoal: "Start a goal before publishing or reverting the handbook. Without a goal there are no team members, acknowledgement gates or reminders.",
     noRequirement: "No handbook release requires acknowledgement yet.",
     wrongRelease: "Acknowledge handbook release {{release}}, the currently required version.",
-    guard: "First acknowledge handbook release {{release}} (team_acknowledge_handbook).",
+    guard: "{{member}} has not acknowledged handbook release {{release}} yet. The team plugin has asked them to; when they do, you are woken if items still wait to be assigned. Assign then; do not retry on a timer.",
+    leadAcknowledged: "{{member}} acknowledged handbook release {{release}}. Assignments to them are no longer refused: assign the items still waiting.",
     reminder: "Handbook release {{release}} requires acknowledgement. Read wiki_read_handbook, then call team_acknowledge_handbook with this release number.",
     leadBrief: "Read the handbook with wiki_read_handbook and explicitly acknowledge its currently required release with team_acknowledge_handbook before taking new work. Publish or revert it through team_publish_handbook or team_revert_handbook; publishing a release that requires acknowledgement also acknowledges it for you.",
     memberBrief: "Read the handbook with wiki_read_handbook and call team_acknowledge_handbook for its currently required release before taking new work; reading alone does not acknowledge it."
@@ -6930,6 +6931,15 @@ var en_default = {
     untitled: "(Untitled)",
     other: "Other",
     unassigned: "Unassigned",
+    sessionRunning: "Session running",
+    sessionFailed: "Failed",
+    sessionWaiting: "Needs input",
+    sessionStopped: "Stopped",
+    sessionStoppedAt: "Stopped at {{time}}",
+    sessionStatusTitle: "Status of the assigned member's session",
+    queued: "Queued",
+    dateLocale: "en",
+    queuedTitle: "Assigned but not woken yet: waits until their current item is done",
     blockedBy: "Blocked by {{count}} work items",
     goalRequired: "Start a goal above before assigning work to members.",
     loading: "Loading board\u2026",
@@ -7161,25 +7171,29 @@ var en_default = {
 };
 
 // src/handbook/messages.ts
-function handbookMessage(key, release) {
-  return en_default.handbook[key].replace(/{{release}}/g, String(release ?? ""));
+function handbookMessage(key, release, member) {
+  return en_default.handbook[key].replace(/{{release}}/g, String(release ?? "")).replace(/{{member}}/g, member ?? "");
 }
 
 // src/domain/leadBrief.ts
 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 MEMBER_NO_STASH_RULE = "Do not use git stash: all worktrees of this repository share one stash stack. To try something you can undo, commit to a temporary branch or copy files into an ignored folder inside your own worktree, and delete it before you mark the item done.";
+var NO_STASH = "Do not use git stash: all worktrees of this repository share one stash stack.";
+var MEMBER_NO_STASH_RULE = `${NO_STASH} To try something you can undo, commit to a temporary branch or copy files into an ignored folder inside your own worktree, and delete it before you mark the item done.`;
 var MEMBER_ASK_BEFORE_OUTSIDE_RULE = "Before you change dependencies or patches, write outside the project root, or fetch code from the network (git clone, downloads), mention your lead in a work item comment and wait for an answer.";
 var MEMBER_READ_RANGES_RULE = "Read files in ranges: find the place with Grep first, then read only the lines you need; read only the relevant section of a skill file.";
-var LEAD_ACCEPT_RULE = "When you check a finished item, run the checks that this project's rules name yourself. Send the item back if its changes touch patches/ or a lockfile, unless the item has a comment from you approving that change.";
+var LEAD_ACCEPT_RULE = `When you check a finished item, run the checks that this project's rules name yourself. Send the item back if its changes touch patches/ or a lockfile, unless the item has a comment from you approving that change. ${NO_STASH} To compare against the base, run the same check in your own working directory on the base branch and compare the error counts; do not stash in the member's worktree.`;
 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_STUCK_RULE = "When a member is stuck, answer in that item's comments before you next look in on members: give a concrete direction, split the item, or reassign it. A member is stuck when they mention you because they are stuck, and also when a comment of theirs reports a blocker, such as a test or error they cannot get past, even if it does not mention you. Do not just note it.";
+var LEAD_REPEATED_BLOCKER_RULE = "If, when you look in, a blocker a member reported is still there and their branch has no new commit since your last look-in, do not just ask for a work-in-progress commit: ask what they have tried and which exact line fails, then give a direction, or split or reassign the item.";
 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_OWN_ITEM_RULE = "If a work item for this goal is assigned to you, also record it as blocked by every item you create. Each time a member marks an item done you will be told, so check it then; when they are all done, mark that item done with work_update_item.";
+var LEAD_REBALANCE_RULE = "When a member has nothing in progress while another member has an item waiting in line that is not blocked, move one waiting item to the idle member with work_update_item.";
+var LEAD_CHECKPOINT_RULE = "Each time you look in on members, check each item in progress: if it entered In Progress more than 30 minutes ago and has had no new commit on the member's branch and no comment since, post a comment with work_post_comment that mentions the member and asks them to run the tests and typecheck for what they have changed so far, commit the work in progress to their branch, and post a one-line progress and blocker comment on the item. Take the times from work_history and, when you can read the member's worktree on this machine, from git log -1 --format=%cI there, and compare them with the current time; do not estimate. When you cannot read their worktree, as with a remote member, judge by work_history and comments alone; not being able to see commits does not mean there are none.";
 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.";
 var LEAD_NO_MEMBER_TASKS = "Do not do members' tasks yourself, and never assign an item you create to yourself: merging, pushing and integrating the work are member tasks too.";
 var tableCell = (value) => value.replace(/\|/g, "\\|").replace(/[\r\n]/g, " ");
@@ -7210,7 +7224,10 @@ function leadBrief(goal, roster) {
     LEAD_SEND_BACK_RULE,
     LEAD_ACCEPT_RULE,
     LEAD_STUCK_RULE,
+    LEAD_CHECKPOINT_RULE,
+    LEAD_REPEATED_BLOCKER_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}`,
+    LEAD_REBALANCE_RULE,
     ...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."
@@ -7548,7 +7565,15 @@ var BoardItem = Struct({
   state: Struct({ stateId: String4, name: String4 }),
   assignees: ArraySchema(WorkIdentity),
   blockedByTotal: Number5,
-  version: Number5
+  version: Number5,
+  assigneeSession: optionalKey2(
+    Struct({
+      threadId: String4,
+      status: Literals(["running", "failed", "waiting", "stopped"]),
+      stoppedAt: optionalKey2(String4)
+    })
+  ),
+  queued: optionalKey2(Boolean3)
 });
 var BoardGoalItem = Struct({
   workItemId: String4,
@@ -7610,6 +7635,10 @@ var decodeProject = decodeUnknownOption2(Struct({ projectId: String4 }));
 var decodeFact = decodeUnknownOption2(
   Struct({ pluginId: Literal2("team"), name: String4 })
 );
+var eventProject = (event) => {
+  const payload = decodeProject(event.payload);
+  return isSome2(payload) ? payload.value.projectId : event.aggregateKind === "project" ? event.aggregateId : null;
+};
 var WORK_EVENTS = /* @__PURE__ */ new Set([
   "work.item-created",
   "work.item-updated",
@@ -7626,7 +7655,7 @@ var HANDBOOK_EVENTS = /* @__PURE__ */ new Set([
   "wiki.page-erased",
   "memory.toolkit-set"
 ]);
-function registerTeamWatch(ctx, options) {
+function registerTeamWatch(ctx, hasMember, options) {
   const after = options.after ?? ((delay2, notify) => {
     const timer = NodeTimers.setTimeout(notify, delay2);
     return () => NodeTimers.clearTimeout(timer);
@@ -7634,38 +7663,95 @@ function registerTeamWatch(ctx, options) {
   const listeners = /* @__PURE__ */ new Map();
   const cursors = /* @__PURE__ */ new Map();
   const timers = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const subscriptions = /* @__PURE__ */ new Map();
   let disposed = false;
-  const changed = (event, board, handbook) => {
-    const payload = decodeProject(event.payload);
-    const projectId = isSome2(payload) ? payload.value.projectId : event.aggregateKind === "project" ? event.aggregateId : null;
+  const invalidate = (projectId, board, handbook, sequence = 0) => {
     if (projectId === null || disposed || !listeners.has(projectId)) return;
-    const previous = cursors.get(projectId) ?? emptyChanges();
-    cursors.set(projectId, {
-      cursor: board ? Math.max(previous.cursor, event.sequence) : previous.cursor,
-      handbookCursor: handbook ? Math.max(previous.handbookCursor, event.sequence) : previous.handbookCursor
+    const batch = pending.get(projectId);
+    pending.set(projectId, {
+      board: board || batch?.board === true,
+      handbook: handbook || batch?.handbook === true,
+      boardSequence: Math.max(board ? sequence : 0, batch?.boardSequence ?? 0),
+      handbookSequence: Math.max(handbook ? sequence : 0, batch?.handbookSequence ?? 0)
     });
     if (timers.has(projectId)) return;
     timers.set(
       projectId,
       after(50, () => {
         timers.delete(projectId);
-        for (const emit of [...listeners.get(projectId) ?? []])
+        const batch2 = pending.get(projectId);
+        pending.delete(projectId);
+        if (batch2 === void 0) return;
+        const previous = cursors.get(projectId) ?? emptyChanges();
+        cursors.set(projectId, {
+          cursor: batch2.board ? Math.max(previous.cursor + 1, batch2.boardSequence) : previous.cursor,
+          handbookCursor: batch2.handbook ? Math.max(previous.handbookCursor + 1, batch2.handbookSequence) : previous.handbookCursor
+        });
+        for (const emit of listeners.get(projectId) ?? [])
           emit(cursors.get(projectId) ?? emptyChanges());
       })
     );
   };
+  const changed = (event, board, handbook) => invalidate(eventProject(event), board, handbook, event.sequence);
   const stops = [.../* @__PURE__ */ new Set([...WORK_EVENTS, ...HANDBOOK_EVENTS])].map(
     (type) => ctx.events.onRaw(
       type,
       (event) => changed(event, WORK_EVENTS.has(type), HANDBOOK_EVENTS.has(type))
     )
   );
+  const subscribe = (projectId) => {
+    if (subscriptions.has(projectId)) return;
+    const controller = new AbortController();
+    const { signal } = controller;
+    const known = /* @__PURE__ */ new Set();
+    const active = () => !disposed && !signal.aborted && listeners.has(projectId);
+    const done2 = (async () => {
+      while (active()) {
+        try {
+          await ctx.threads.subscribeList(
+            { projectId },
+            async (frame) => {
+              if (!active() || frame._tag === "synchronized") return;
+              const ids = frame._tag === "snapshot" ? [.../* @__PURE__ */ new Set([...known, ...frame.value.items.map((row) => row.threadId)])] : frame._tag === "refresh" ? frame.threads.map((row) => row.threadId) : [
+                frame.change._tag === "removed" ? frame.change.threadId : frame.change.thread.threadId
+              ];
+              if (frame._tag === "snapshot") {
+                known.clear();
+                for (const row of frame.value.items) known.add(row.threadId);
+              } else if (frame._tag === "delta") {
+                if (frame.change._tag === "removed") known.delete(frame.change.threadId);
+                else known.add(frame.change.thread.threadId);
+              }
+              if (ids.length === 0) return;
+              const matches = await hasMember(projectId, ids).catch(() => false);
+              if (matches && active()) invalidate(projectId, true, false);
+            },
+            signal
+          );
+        } catch {
+        }
+        if (!active()) return;
+        await new Promise((resolve2) => {
+          const finish = () => {
+            cancel();
+            signal.removeEventListener("abort", finish);
+            resolve2();
+          };
+          const cancel = after(1e3, finish);
+          signal.addEventListener("abort", finish, { once: true });
+          if (signal.aborted) finish();
+        });
+      }
+    })();
+    subscriptions.set(projectId, { controller, done: done2 });
+  };
   stops.push(
     ctx.events.onRaw("plugin.event-appended", (event) => {
       const fact = decodeFact(event.payload);
       if (isNone2(fact)) return;
       const name = fact.value.name;
-      const board = name === "team/goal-started" || name === "team/roster-set";
+      const board = name === "team/goal-started" || name === "team/roster-set" || name === "team/member-woken";
       const handbook = name === "team/goal-started" || name === "team/handbook-acknowledged" || name === "team/handbook-publication-completed";
       if (board || handbook) changed(event, board, handbook);
     })
@@ -7684,6 +7770,7 @@ function registerTeamWatch(ctx, options) {
       };
       listeners.set(projectId, subscribers);
       subscribers.add(ring);
+      subscribe(projectId);
       try {
         ring(cursors.get(projectId) ?? emptyChanges());
         await new Promise((resolve2) => {
@@ -7694,20 +7781,30 @@ function registerTeamWatch(ctx, options) {
         subscribers.delete(ring);
         if (subscribers.size === 0) {
           listeners.delete(projectId);
+          const subscription = subscriptions.get(projectId);
+          subscriptions.delete(projectId);
+          subscription?.controller.abort();
           timers.get(projectId)?.();
           timers.delete(projectId);
+          pending.delete(projectId);
           cursors.delete(projectId);
+          await subscription?.done;
         }
       }
     }
   });
-  ctx.onDispose(() => {
+  ctx.onDispose(async () => {
     disposed = true;
+    const owned = [...subscriptions.values()];
+    for (const subscription of owned) subscription.controller.abort();
     for (const stop of stops) stop();
     for (const cancel of timers.values()) cancel();
     timers.clear();
     listeners.clear();
     cursors.clear();
+    pending.clear();
+    subscriptions.clear();
+    await Promise.all(owned.map((subscription) => subscription.done));
   });
 }
 
@@ -7735,6 +7832,121 @@ async function readPages(maximum, read, keep = "oldest") {
   return { items, truncated };
 }
 
+// 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;
+}
+function deferredWakes(project2, threadId) {
+  return Object.entries(project2.items).filter(([, item]) => isDeferredWake(project2, item, threadId)).map(([workItemId, item]) => ({ workItemId, sequenceId: item.sequenceId })).sort(
+    (a, b) => Number(hasOpenBlocker(project2, a.workItemId)) - Number(hasOpenBlocker(project2, b.workItemId)) || compareWakeItems(a, b)
+  );
+}
+
+// src/boardProgress.ts
+var sessionStatus = (thread) => {
+  const { status, threadId } = thread;
+  switch (status) {
+    case "running":
+    case "failed":
+      return { threadId, status };
+    case "needs-input":
+    case "needs-approval":
+      return { threadId, status: "waiting" };
+    case "idle":
+    case "stopped": {
+      const stoppedAt = thread.summary?.latestTurn?.completedAt;
+      return { threadId, status: "stopped", ...stoppedAt == null ? {} : { stoppedAt } };
+    }
+    default:
+      return void 0;
+  }
+};
+function boardProgress(rows, goal, threads, wakes) {
+  const members = goalExecution(goal).members;
+  const isMember2 = (threadId) => findGoalMember(members, { threadId }) !== void 0;
+  const sessions = new Map(
+    threads.filter((thread) => isMember2(thread.threadId)).map((thread) => [thread.threadId, thread])
+  );
+  const started = /* @__PURE__ */ new Map();
+  const countStarted = (threadId, workItemId) => {
+    const items = started.get(threadId) ?? /* @__PURE__ */ new Set();
+    items.add(workItemId);
+    started.set(threadId, items);
+  };
+  for (const item of rows) {
+    if (item.state.group !== "started") continue;
+    for (const assignee of item.assignees) {
+      if (assignee.kind === "agent") countStarted(assignee.threadId, item.workItemId);
+    }
+  }
+  for (const [workItemId, item] of Object.entries(wakes?.items ?? {})) {
+    if (item.stateGroup === "started") {
+      for (const threadId of item.assigneeThreads) countStarted(threadId, workItemId);
+    }
+  }
+  const queuedByMember = /* @__PURE__ */ new Map();
+  const queuedFor = (threadId) => {
+    let items = queuedByMember.get(threadId);
+    if (items === void 0) {
+      items = new Set(
+        wakes === void 0 ? [] : deferredWakes(wakes, threadId).map((item) => item.workItemId)
+      );
+      queuedByMember.set(threadId, items);
+    }
+    return items;
+  };
+  return (item) => {
+    const assignees = item.assignees.filter(
+      (assignee2) => assignee2.kind === "agent" && isMember2(assignee2.threadId)
+    );
+    const queued = assignees.some(
+      (assignee2) => assignee2.kind === "agent" && queuedFor(assignee2.threadId).has(item.workItemId)
+    );
+    const assignee = item.state.group === "started" ? assignees.find(
+      (assignee2) => assignee2.kind === "agent" && ((started.get(assignee2.threadId)?.size ?? 0) <= 1 || wakes?.items[item.workItemId]?.wakeStatus?.[assignee2.threadId] === "active")
+    ) : void 0;
+    const thread = assignee?.kind === "agent" ? sessions.get(assignee.threadId) : void 0;
+    const session = thread === void 0 ? void 0 : sessionStatus(thread);
+    return {
+      ...session === void 0 ? {} : { assigneeSession: session },
+      ...queued ? { queued: true } : {}
+    };
+  };
+}
+
 // src/workWrites.ts
 var decodeHostRefusal = decodeUnknownOption2(
   Struct({
@@ -7766,12 +7978,17 @@ async function writeWork(invocation, commandType, write) {
 // src/board.ts
 var ITEM_LIMIT = 500;
 var PEOPLE_LIMIT = 200;
+var MEMBER_THREAD_LIMIT = 50;
 var REMOTE_AGENT_LIMIT = 1e3;
 var decodeRead2 = decodeUnknownSync(ReadBoardInput);
 var decodeCreate = decodeUnknownOption2(CreateItemInput);
 var decodeUpdate = decodeUnknownOption2(UpdateItemInput);
-function registerBoardCommands(ctx, goals, rosters, options = {}) {
-  const isMember2 = async (projectId, threadId) => findGoalMember(goalExecution(await goals.read(projectId)).members, { threadId }) !== void 0;
+function registerBoardCommands(ctx, goals, rosters, wakes, options = {}) {
+  const hasMember = async (projectId, threadIds) => {
+    const members = goalExecution(await goals.read(projectId)).members;
+    return threadIds.some((threadId) => findGoalMember(members, { threadId }) !== void 0);
+  };
+  const isMember2 = (projectId, threadId) => hasMember(projectId, [threadId]);
   ctx.command({
     name: "board",
     scope: "read",
@@ -7795,7 +8012,17 @@ function registerBoardCommands(ctx, goals, rosters, options = {}) {
         invocation.viewer?.communication.people.current({}).catch(() => null)
       ]);
       const goalItemId = goal === null ? null : teamGoalItemId(projectId, goal.goalId);
-      const [remoteWork, { items: rows, truncated }, goalItem] = await Promise.all([
+      const leadThreadId = goal?.threads.find(
+        ({ memberId }) => memberId === goal.leadMemberId
+      )?.threadId;
+      const [
+        remoteWork,
+        { items: rows, truncated },
+        goalItem,
+        memberThreads,
+        leadThread2,
+        wakeState
+      ] = await Promise.all([
         Promise.all(
           (roster?.members ?? []).flatMap(
             (member) => member.principal === void 0 ? [] : [
@@ -7808,8 +8035,37 @@ function registerBoardCommands(ctx, goals, rosters, options = {}) {
         ),
         readPages(ITEM_LIMIT, (page) => ctx.work.items.list({ projectId, ...page })),
         // 目标那件按号单读：看板只列最新的 500 件，目标那件可能不在里面。
-        goalItemId === null ? void 0 : ctx.work.items.get({ projectId, workItemIds: [goalItemId] }).then(({ items: items2 }) => items2.find((item) => item.workItemId === goalItemId))
+        goalItemId === null ? void 0 : ctx.work.items.get({ projectId, workItemIds: [goalItemId] }).then(({ items: items2 }) => items2.find((item) => item.workItemId === goalItemId)),
+        // 成员都是负责人的子会话；人数很少，只读摘要，按小上限防游标出错。
+        leadThreadId === void 0 ? null : readPages(
+          MEMBER_THREAD_LIMIT,
+          (page) => ctx.threads.list({
+            ...page,
+            projectId,
+            parentThreadId: leadThreadId,
+            include: ["summary"],
+            limit: MEMBER_THREAD_LIMIT
+          })
+        ).catch(() => null),
+        // 负责人自己也可能领件；与成员分开读，一边失败不连累另一边。
+        leadThreadId === void 0 ? null : ctx.threads.get({ threadId: leadThreadId }).catch(() => null),
+        wakes.get().catch(() => null)
       ]);
+      const progress = boardProgress(
+        rows,
+        goal,
+        [
+          ...memberThreads?.items ?? [],
+          ...leadThread2 === null ? [] : [
+            {
+              threadId: leadThread2.id,
+              status: leadThread2.status,
+              summary: { latestTurn: leadThread2.latestTurn }
+            }
+          ]
+        ],
+        wakeState?.[projectId]
+      );
       const enabled = (toolkit) => toolkitStates.toolkits.some((row) => row.toolkit === toolkit && row.enabled);
       const items = rows.map((item) => ({
         workItemId: item.workItemId,
@@ -7818,7 +8074,8 @@ function registerBoardCommands(ctx, goals, rosters, options = {}) {
         state: { stateId: item.state.stateId, name: item.state.name },
         assignees: item.assignees.map(workIdentity),
         blockedByTotal: item.blockedByTotal,
-        version: item.version
+        version: item.version,
+        ...progress(item)
       }));
       return {
         states: stateList.states.map(({ stateId, name, sequence, defaultKey }) => ({
@@ -7916,7 +8173,7 @@ function registerBoardCommands(ctx, goals, rosters, options = {}) {
       return "code" in result2 ? result2 : { workItemId: result2.result.workItemId, version: result2.result.version };
     }
   });
-  registerTeamWatch(ctx, options);
+  registerTeamWatch(ctx, hasMember, options);
 }
 
 // src/detailContracts.ts
@@ -8196,46 +8453,16 @@ 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 worktreeSetupSentence = async (ctx, projectId, branch) => {
+  const intro = `You are in your own newly created worktree on branch ${branch}.`;
+  const project2 = await ctx.projects.get({ projectId }).catch(() => null);
+  const setup = project2?.scripts.find((script) => script.runOnWorktreeCreate);
+  if (project2 == null || setup === void 0)
+    return `${intro} Install dependencies according to the project's instructions before starting work.`;
+  return `${intro} If dependencies are missing, install them before starting work. This project defines a setup command for that: ${setup.command}; run it from the worktree root with the environment variables YCODIUM_PROJECT_ROOT set to "${project2.workspaceRoot}" and YCODIUM_WORKTREE_PATH set to this worktree's path. If it fails with "could not lock config file", wait a moment and run it again.`;
+};
 var stableHash = (key) => NodeCrypto.createHash("sha256").update(key).digest("hex").slice(0, 32);
 var memberWorktreeBranch = (name, threadId) => {
   const slug = Array.from(
@@ -8272,7 +8499,7 @@ async function deliverWake(ctx, input) {
       requestId: input.requestId,
       to: { principalId: recipient.principalId },
       text: typeof input.text === "string" ? input.text : await input.text(),
-      delivery: "wake"
+      delivery: input.steer ? "steer" : "wake"
     });
   } else {
     const execution = await ctx.projections.getThreadExecution(recipient.threadId);
@@ -8292,14 +8519,23 @@ async function deliverWake(ctx, input) {
       runtimeMode: execution.runtimeMode,
       interactionMode: execution.interactionMode
     };
+    const runningTurnId = input.steer && execution.session?.status === "running" ? execution.session.activeTurnId : null;
     const startTurn = (suffix) => ctx.threads.turns.start({
       ...turn,
       requestId: `${input.requestId}${suffix}`,
-      message: { ...turn.message, messageId: `${input.messageId}${suffix}` }
+      message: { ...turn.message, messageId: `${input.messageId}${suffix}` },
+      ...runningTurnId == null ? {} : {
+        intentAction: {
+          kind: "steer",
+          source: "automatic",
+          turnId: runningTurnId,
+          commandId: `${input.requestId}${suffix}:steer`
+        }
+      }
     });
     let failure = worktree?.failure;
     let delivered = false;
-    if (worktree !== void 0 && failure === void 0 && !execution.worktreePath) {
+    if (runningTurnId == null && 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);
@@ -8315,7 +8551,7 @@ async function deliverWake(ctx, input) {
               ...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.`
+${await worktreeSetupSentence(ctx, input.projectId, branch)}`
             },
             bootstrap: {
               prepareWorktree: {
@@ -8374,6 +8610,7 @@ var RecoveryPlan = Struct({
   workItemIds: ArraySchema(String4),
   resumeQueue: optionalKey2(Literal2(true))
 });
+var withoutStartFailure = ({ startFailureTurnId: _done, ...member }) => member;
 var REQUESTED = "team/member-recovery-requested";
 var DELIVERED = "team/member-recovery-delivered";
 var decodeRecoveryFact = decodeUnknownOption2(
@@ -8535,7 +8772,9 @@ function foldRecovery(state, event, previous) {
     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;
+      const startFailed = session.status === "error" && session.activeTurnId === null && member.status !== "running" && member.status !== "error" && member.turnId !== null;
+      const startFailureTurnId = startFailed ? `${member.turnId}#start-${event.sequence}` : session.status === "error" && session.activeTurnId === null ? member.startFailureTurnId : void 0;
+      const turnId = startFailureTurnId ?? 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";
@@ -8548,7 +8787,12 @@ function foldRecovery(state, event, previous) {
         (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 ? {
+      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,
+        ...startFailed && member.turnId !== null ? { afterTurnId: member.turnId } : {}
+      } : succeeded && turnId !== null && hasStarted ? {
         turnId,
         category: "normal-end",
         kind: "stall",
@@ -8562,8 +8806,9 @@ function foldRecovery(state, event, previous) {
           recovery: {
             ...project2.recovery,
             [threadId]: {
-              ...member,
-              turnId,
+              ...withoutStartFailure(member),
+              ...startFailureTurnId === void 0 ? {} : { startFailureTurnId },
+              turnId: startFailureTurnId === void 0 ? turnId : member.turnId,
               status: session.status,
               retriedItemIds: succeeded ? [] : member.retriedItemIds,
               ...succeeded ? { unprogressedRetryItemIds: [] } : {},
@@ -8674,6 +8919,81 @@ function dueRecoveries(state, changedThreadId) {
   );
 }
 
+// src/runtime/reviewWakes.ts
+var decodeCompletion = decodeUnknownOption2(
+  Struct({
+    projectId: String4,
+    workItemId: String4,
+    state: Struct({ group: String4 }),
+    actor: Union2([
+      Struct({ kind: Literal2("agent"), threadId: String4 }),
+      Struct({ kind: Literal2("remote-agent"), principalId: String4 })
+    ])
+  })
+);
+var openLeadItemsBlockedBy = (project2, workItemId) => {
+  const lead = project2.leadThreads?.[0];
+  return lead === void 0 ? [] : Object.entries(project2.items).filter(
+    ([id]) => isAssignedOpen(project2, id, lead) && readFact(project2.blockers, id)?.includes(workItemId) === true
+  );
+};
+function reviewOnUpdate(previous, next, event) {
+  const decoded = decodeCompletion(event.payload);
+  if (isNone2(decoded) || decoded.value.state.group !== "completed") return null;
+  const { projectId, workItemId, actor } = decoded.value;
+  if (readFact(previous.items, workItemId)?.stateGroup === "completed") return null;
+  const lead = next.leadThreads?.[0];
+  if (lead === void 0) return null;
+  const by = actor.kind === "agent" ? { threadId: actor.threadId } : { principalId: actor.principalId };
+  if (!isMember(next, by) || "threadId" in by && next.leadThreads?.includes(by.threadId))
+    return null;
+  const goals = openLeadItemsBlockedBy(next, workItemId);
+  if (goals.length === 0 || goals.some(([id]) => isWorkable(next, id))) return null;
+  return {
+    key: `review:${workItemId}:${lead}#${event.sequence}`,
+    projectId,
+    workItemId,
+    threadId: lead,
+    by
+  };
+}
+var isLiveReview = (project2, review) => review.threadId === project2.leadThreads?.[0] && readFact(project2.items, review.workItemId)?.stateGroup === "completed" && openLeadItemsBlockedBy(project2, review.workItemId).length > 0;
+var isReviewDue = (project2, key) => project2.pendingReviews?.some((review) => review.key === key && isLiveReview(project2, review)) === true;
+var dueReviews = (project2) => (project2.pendingReviews ?? []).filter((review) => isLiveReview(project2, review)).map((review) => {
+  const item = readFact(project2.items, review.workItemId);
+  return {
+    ...review,
+    kind: "review",
+    lead: true,
+    ...item === null ? {} : { sequenceId: item.sequenceId }
+  };
+});
+function pruneReviews(previous, state) {
+  let next = state;
+  for (const [projectId, project2] of Object.entries(state)) {
+    const pending = project2.pendingReviews;
+    if (pending === void 0 || pending.length === 0) continue;
+    const before = previous[projectId];
+    if (before !== void 0 && before.leadThreads === project2.leadThreads && before.items === project2.items && before.blockers === project2.blockers)
+      continue;
+    const live = pending.filter((review) => isLiveReview(project2, review));
+    if (live.length !== pending.length)
+      next = { ...next, [projectId]: { ...project2, pendingReviews: live } };
+  }
+  return next;
+}
+function reviewFacts(project2, queues) {
+  const { busy, waiting } = queues;
+  return {
+    idle: project2.threads.filter(
+      (threadId) => !project2.leadThreads?.includes(threadId) && !busy.has(threadId) && (waiting.get(threadId) ?? []).length === 0
+    ),
+    queued: [...busy].flatMap(
+      (threadId) => [...waiting.get(threadId) ?? []].sort(compareWakeItems).map(({ workItemId, sequenceId }) => ({ workItemId, sequenceId, threadId }))
+    )
+  };
+}
+
 // src/runtime/wakeState.ts
 var WAKE_STATE_KEY = "wakes";
 var WAKE_STATE_VERSION = 7;
@@ -8890,6 +9210,15 @@ function foldWorkWakes(state, event) {
         }
       };
     }
+    if (project3.pendingReviews?.some((review) => review.key === key)) {
+      return {
+        ...state,
+        [projectId2]: {
+          ...project3,
+          pendingReviews: project3.pendingReviews.filter((review) => review.key !== key)
+        }
+      };
+    }
     if (project3.woken.includes(key)) return state;
     const items = { ...project3.items };
     for (const [workItemId2, item] of Object.entries(items)) {
@@ -8975,6 +9304,9 @@ function foldWorkWakes(state, event) {
       };
       if (work.type === "work.item-claimed" && currentItem.claimedBy.length === 0 && hasOpenBlocker(next, workItemId))
         next = markBlockedAfterClaim(next, workItemId);
+      const review = work.type === "work.item-updated" ? reviewOnUpdate(project2, next, event) : null;
+      if (review !== null)
+        next = { ...next, pendingReviews: [...next.pendingReviews ?? [], review] };
       break;
     }
     case "work.relation-added":
@@ -9046,7 +9378,7 @@ function foldWorkWakes(state, event) {
   return { ...state, [projectId]: next };
 }
 function foldWakes(state, event) {
-  return foldRecovery(foldWorkWakes(state, event), event, state);
+  return foldRecovery(pruneReviews(state, foldWorkWakes(state, event)), event, state);
 }
 var compare2 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 var itemWakeCandidate = (projectId, project2, workItemId, item, threadId, woken) => {
@@ -9070,9 +9402,9 @@ var itemWakeCandidate = (projectId, project2, workItemId, item, threadId, woken)
   };
 };
 var needsMemberSlot = (wake) => wake.kind === "item" && wake.lead !== true;
-function memberItemSlots(projectId, project2, woken, onlyThreadId) {
+function memberQueues(projectId, project2, woken = new Set(project2.woken), onlyThreadId) {
   const busy = /* @__PURE__ */ new Set();
-  const slots = /* @__PURE__ */ new Map();
+  const waiting = /* @__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;
@@ -9082,12 +9414,24 @@ function memberItemSlots(projectId, project2, woken, onlyThreadId) {
       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);
+      const queue = waiting.get(threadId);
+      if (queue === void 0) waiting.set(threadId, [candidate]);
+      else queue.push(candidate);
     }
   }
-  for (const threadId of busy) slots.delete(threadId);
+  return { busy, waiting };
+}
+function memberItemSlots(projectId, project2, woken, onlyThreadId) {
+  const { busy, waiting } = memberQueues(projectId, project2, woken, onlyThreadId);
+  const slots = /* @__PURE__ */ new Map();
+  for (const [threadId, candidates] of waiting)
+    if (!busy.has(threadId))
+      slots.set(
+        threadId,
+        candidates.reduce(
+          (first, candidate) => compareWakeItems(candidate, first) < 0 ? candidate : first
+        )
+      );
   return slots;
 }
 function isWakeDue(state, wake) {
@@ -9095,6 +9439,7 @@ function isWakeDue(state, wake) {
   if (project2 === null) return false;
   if (wake.kind === "comment")
     return project2.pendingComments.some((comment) => comment.key === wake.key);
+  if (wake.kind === "review") return isReviewDue(project2, wake.key);
   if (!("threadId" in wake)) return false;
   const item = readFact(project2.items, wake.workItemId);
   if (item === null) return false;
@@ -9128,6 +9473,7 @@ function dueWakes(state) {
         due.push(candidate);
       }
     }
+    due.push(...dueReviews(project2));
     for (const comment of project2.pendingComments) {
       const item = readFact(project2.items, comment.workItemId);
       due.push({
@@ -9160,6 +9506,15 @@ var itemText = (workItemId, sequenceId, item, leadThreadId) => `${itemHeadline(s
 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_ACCEPT_RULE} ${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 leadReviewText = (workItemId, sequenceId, title, by, facts) => [
+  `${by} marked ${titled(workItemId, sequenceId, title)} done. Read it with work_read_items, passing workItemIds: ["${workItemId}"], and check it now.`,
+  LEAD_ACCEPT_RULE,
+  LEAD_SEND_BACK_RULE,
+  ...facts.idle.length === 0 ? [] : [`Nothing in progress now: ${facts.idle.join("; ")}.`],
+  ...facts.queued.length === 0 ? [] : [`Waiting in line, not blocked: ${facts.queued.join("; ")}.`],
+  ...facts.idle.length > 0 && facts.queued.length > 0 ? [LEAD_REBALANCE_RULE] : [],
+  LEAD_NO_MEMBER_TASKS
+].join(" ");
 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, goals, options = {}) {
   const wakes = ctx.derivedState({
@@ -9189,11 +9544,35 @@ function startWakeRuntime(ctx, goals, options = {}) {
           requestId: `team-wake:${id}`,
           messageId: `team-wake-msg:${id}`,
           memberWorktree: worktree === void 0 ? void 0 : { ...worktree, lane: worktrees },
+          // 评论在收件人正在跑时插进当前这一轮，不排到这一轮结束（试跑 3：一轮 97 分钟，检查点落空）。
+          ...wake.kind === "comment" ? { steer: true } : {},
           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 === "review") {
+              const project2 = state[wake.projectId];
+              const members = (await goals.read(wake.projectId))?.members ?? [];
+              const name = (id2) => {
+                const member = findGoalMember(members, id2);
+                const key = "threadId" in id2 ? id2.threadId : id2.principalId;
+                return `${member?.name ?? key} (${"threadId" in id2 ? "threadId" : "principalId"} ${key})`;
+              };
+              const facts = project2 === void 0 ? { idle: [], queued: [] } : reviewFacts(project2, memberQueues(wake.projectId, project2));
+              return leadReviewText(
+                wake.workItemId,
+                wake.sequenceId,
+                title,
+                wake.by === void 0 ? "A member" : name(wake.by),
+                {
+                  idle: facts.idle.map((threadId) => name({ threadId })),
+                  queued: facts.queued.map(
+                    (queued) => `${workLabel(queued.workItemId, queued.sequenceId)}, assigned to ${name({ threadId: queued.threadId })}`
+                  )
+                }
+              );
+            }
             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)(
@@ -9247,7 +9626,7 @@ var readStallExecution = async (ctx, threadId) => {
 };
 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 leadText = (recovery, name, paused) => `Member ${name} (threadId ${recovery.threadId}) ${recovery.afterTurnId === void 0 ? "stopped because of an upstream error" : "could not start a session"} (${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");
@@ -9261,6 +9640,7 @@ var stallLeadText = (recovery, name) => `Member ${name} (threadId ${recovery.thr
 ).join("")}${leadInstructions()}`;
 function startRecoveryRuntime(ctx, goals, state, worktrees) {
   let pending = Promise.resolve();
+  const skipped = /* @__PURE__ */ new Map();
   let disposed = false;
   const execute = async (scope2) => {
     if (disposed) return;
@@ -9278,6 +9658,9 @@ function startRecoveryRuntime(ctx, goals, state, worktrees) {
         )
       );
     }
+    for (const [key, entry] of skipped)
+      if (readFact(current, entry.projectId)?.recovery?.[entry.threadId]?.pending?.turnId !== entry.turnId)
+        skipped.delete(key);
     const recoveries = dueRecoveries(
       projects,
       scope2?.kind === "thread" ? scope2.threadId : void 0
@@ -9290,8 +9673,22 @@ function startRecoveryRuntime(ctx, goals, state, worktrees) {
         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")))
+        if (execution === null || execution.archivedAt !== null || execution.session == null || !queuedContinuation && (execution.session.activeTurnId !== null || execution.latestTurn?.turnId !== (recovery.afterTurnId ?? 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 === "running"))) {
+          if (!skipped.has(recovery.key)) {
+            skipped.set(recovery.key, {
+              projectId: recovery.projectId,
+              threadId: recovery.threadId,
+              turnId: recovery.turnId
+            });
+            ctx.log.warn("team member recovery skipped", {
+              threadId: recovery.threadId,
+              turnId: recovery.turnId,
+              sessionStatus: execution?.session?.status ?? null,
+              latestTurnState: execution?.latestTurn?.state ?? null
+            });
+          }
           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)
@@ -9491,6 +9888,28 @@ async function publicationRequiresAck(memory, projectId, input) {
   return false;
 }
 
+// src/handbook/waitingWork.ts
+async function hasUnassignedWork(items, projectId, goal) {
+  const goalItemId = teamGoalItemId(projectId, goal.goalId);
+  const members = goalExecution(goal).members.filter(
+    (member) => member.memberId !== goal.leadMemberId
+  );
+  const waiting = (item) => item.workItemId !== goalItemId && !isClosed({ stateGroup: item.state.group }) && !item.assignees.some(
+    (assignee) => assignee.kind === "agent" ? findGoalMember(members, { threadId: assignee.threadId }) !== void 0 : assignee.kind === "remote-agent" ? findGoalMember(members, { principalId: assignee.principalId }) !== void 0 : false
+  );
+  let cursor = null;
+  do {
+    const page = await items.list({
+      projectId,
+      limit: PAGE_SIZE,
+      ...cursor === null ? {} : { cursor }
+    });
+    if (page.items.some(waiting)) return true;
+    cursor = page.nextCursor;
+  } while (cursor !== null);
+  return false;
+}
+
 // src/handbook/contracts.ts
 var Release = Int.check(isGreaterThanOrEqualTo3(1));
 var HandbookPageKind = Literals([
@@ -9549,6 +9968,10 @@ var Acknowledged = Struct({
 var ReminderSent = Struct({
   ...Acknowledged.fields
 });
+var LeadNotified = Struct({
+  ...Acknowledged.fields,
+  woke: Boolean3
+});
 
 // src/handbook/state.ts
 var HANDBOOK_EVENTS2 = ["plugin.event-appended", "wiki.handbook-released"];
@@ -9575,7 +9998,8 @@ var decodeFact3 = decodeUnknownOption2(
     envelope("handbook-publication-intended", PublicationIntent),
     envelope("handbook-publication-completed", PublicationCompleted),
     envelope("handbook-acknowledged", Acknowledged),
-    envelope("handbook-reminder-sent", ReminderSent)
+    envelope("handbook-reminder-sent", ReminderSent),
+    envelope("handbook-lead-notified", LeadNotified)
   ])
 );
 var decodeRelease = decodeUnknownSync(
@@ -9600,24 +10024,28 @@ var without = (rows, key) => {
   delete next[key];
   return next;
 };
+var queueReminders = (pending, project2, projectId, release, members) => {
+  const next = { ...pending };
+  for (const { memberId } of members) {
+    const key = reminderKey(projectId, release, memberId);
+    if (readFact(project2.reminded, key) === null)
+      next[key] = { projectId, release, member: { memberId } };
+  }
+  return next;
+};
 function foldHandbook(state, event) {
   if (event.type === "wiki.handbook-released") {
     const fact2 = decodeRelease(event.payload);
     const project3 = readFact(state.projects, fact2.projectId) ?? emptyHandbookProject();
-    const pendingReminders = { ...state.pendingReminders };
-    if (fact2.requiresAck)
-      for (const { memberId, ...recipient } of goalExecution(project3.goal).members) {
-        const key = reminderKey(fact2.projectId, fact2.release, memberId);
-        if (readFact(project3.reminded, key) === null)
-          pendingReminders[key] = {
-            projectId: fact2.projectId,
-            release: fact2.release,
-            member: { memberId, recipient }
-          };
-      }
     return {
       ...state,
-      pendingReminders,
+      pendingReminders: fact2.requiresAck ? queueReminders(
+        state.pendingReminders,
+        project3,
+        fact2.projectId,
+        fact2.release,
+        goalExecution(project3.goal).members
+      ) : state.pendingReminders,
       projects: {
         ...state.projects,
         [fact2.projectId]: {
@@ -9634,11 +10062,24 @@ function foldHandbook(state, event) {
   const fact = decoded.value;
   const projectId = fact.name === "team/goal-started" ? fact.data.goal.projectId : fact.data.projectId;
   const project2 = readFact(state.projects, projectId) ?? emptyHandbookProject();
-  let next = project2;
   switch (fact.name) {
-    case "team/goal-started":
-      next = { ...project2, goal: fact.data.goal };
-      break;
+    case "team/goal-started": {
+      const goal = fact.data.goal;
+      const required = project2.requiredRelease;
+      return {
+        ...state,
+        pendingReminders: required === null ? state.pendingReminders : queueReminders(
+          state.pendingReminders,
+          project2,
+          projectId,
+          required,
+          goalExecution(goal).members.filter(
+            ({ memberId }) => memberId !== goal.leadMemberId && !hasAcknowledged(project2, memberId, required)
+          )
+        ),
+        projects: { ...state.projects, [projectId]: { ...project2, goal } }
+      };
+    }
     case "team/handbook-publication-intended": {
       const intent = fact.data;
       if (readFact(state.intents, intent.requestId) !== null) return state;
@@ -9687,7 +10128,7 @@ function foldHandbook(state, event) {
       const { memberId, release } = fact.data;
       if (hasAcknowledged(project2, memberId, release)) return state;
       const previous = readFact(project2.acknowledgements, memberId);
-      next = {
+      const next = {
         ...project2,
         acknowledgements: {
           ...project2.acknowledgements,
@@ -9697,27 +10138,40 @@ function foldHandbook(state, event) {
           }
         }
       };
+      const key = reminderKey(projectId, release, memberId);
+      const notice = project2.goal !== null && memberId !== project2.goal.leadMemberId && release === project2.requiredRelease;
       return {
         ...state,
-        pendingAcknowledgements: without(
-          state.pendingAcknowledgements,
-          reminderKey(projectId, release, memberId)
-        ),
+        pendingAcknowledgements: without(state.pendingAcknowledgements, key),
+        ...notice ? {
+          pendingLeadNotices: {
+            ...state.pendingLeadNotices,
+            [key]: { version: 1, projectId, release, memberId }
+          }
+        } : {},
         projects: { ...state.projects, [projectId]: next }
       };
     }
+    case "team/handbook-lead-notified": {
+      const pendingLeadNotices = without(
+        state.pendingLeadNotices ?? {},
+        reminderKey(projectId, fact.data.release, fact.data.memberId)
+      );
+      return pendingLeadNotices === state.pendingLeadNotices ? state : { ...state, pendingLeadNotices };
+    }
     case "team/handbook-reminder-sent": {
       const key = reminderKey(projectId, fact.data.release, fact.data.memberId);
       if (readFact(project2.reminded, key) !== null) return state;
-      next = { ...project2, reminded: { ...project2.reminded, [key]: true } };
       return {
         ...state,
         pendingReminders: without(state.pendingReminders, key),
-        projects: { ...state.projects, [projectId]: next }
+        projects: {
+          ...state.projects,
+          [projectId]: { ...project2, reminded: { ...project2.reminded, [key]: true } }
+        }
       };
     }
   }
-  return { ...state, projects: { ...state.projects, [projectId]: next } };
 }
 
 // src/handbook/runtime.ts
@@ -9810,20 +10264,23 @@ function startHandbookRuntime(ctx, worktrees) {
   };
   const remind = async () => {
     const snapshot = await state.get();
-    const wakeState = Object.keys(snapshot.pendingReminders).length === 0 ? void 0 : await worktrees.lane.state.get();
+    const wakeState = Object.keys(snapshot.pendingReminders).length === 0 && Object.keys(snapshot.pendingLeadNotices ?? {}).length === 0 ? void 0 : await worktrees.lane.state.get();
     for (const [key, reminder] of Object.entries(snapshot.pendingReminders)) {
       const { projectId, release, member } = reminder;
+      const project2 = readFact(snapshot.projects, projectId) ?? emptyHandbookProject();
+      const recipient = currentRecipient(project2, member.memberId);
+      if (recipient === void 0 || goalClosed(project2, wakeState?.[projectId])) continue;
       try {
         const id = stableHash(key);
         const worktree = memberWorktreeFor(
           worktrees.goals,
           wakeState?.[projectId],
           projectId,
-          member.recipient
+          recipient
         );
-        const delivered = await deliverWake(ctx, {
+        const delivered = hasAcknowledged(project2, member.memberId, release) || await deliverWake(ctx, {
           projectId,
-          recipient: member.recipient,
+          recipient,
           requestId: `team-handbook:${id}`,
           messageId: `team-handbook-msg:${id}`,
           text: handbookMessage("reminder", release),
@@ -9846,6 +10303,39 @@ function startHandbookRuntime(ctx, worktrees) {
         ctx.log.warn("team handbook reminder failed", { projectId, key, error });
       }
     }
+    const unassigned = /* @__PURE__ */ new Map();
+    for (const [key, notice] of Object.entries(snapshot.pendingLeadNotices ?? {})) {
+      const { projectId, release, memberId } = notice;
+      const project2 = readFact(snapshot.projects, projectId) ?? emptyHandbookProject();
+      const lead = leadThread(project2);
+      try {
+        const { goal } = project2;
+        const waiting = lead !== void 0 && goal !== null && currentRecipient(project2, memberId) !== void 0 && !goalClosed(project2, wakeState?.[projectId]) && await (unassigned.get(projectId) ?? unassigned.set(projectId, hasUnassignedWork(ctx.work.items, projectId, goal)).get(projectId));
+        if (waiting) {
+          const name = (await worktrees.goals.read(projectId))?.members.find(
+            (member) => member.memberId === memberId
+          )?.name ?? memberId;
+          const id = stableHash(`lead:${key}`);
+          const delivered = await deliverWake(ctx, {
+            projectId,
+            recipient: { threadId: lead },
+            requestId: `team-handbook-lead:${id}`,
+            messageId: `team-handbook-lead-msg:${id}`,
+            text: handbookMessage("leadAcknowledged", release, name)
+          });
+          if (!delivered) continue;
+        }
+        await append2(projectId, "handbook-lead-notified", `lead:${key}`, {
+          version: 1,
+          projectId,
+          release,
+          memberId,
+          woke: waiting
+        });
+      } catch (error) {
+        ctx.log.warn("team handbook lead notice failed", { projectId, key, error });
+      }
+    }
   };
   const execute = async () => {
     for (const intent of Object.values((await state.get()).pendingPublications)) {
@@ -9868,7 +10358,11 @@ function startHandbookRuntime(ctx, worktrees) {
     await remind();
   };
   const flush = () => serial(execute);
-  ctx.reactor({ name: "team-handbook", events: HANDBOOK_EVENTS2, handle: () => flush() });
+  ctx.reactor({
+    name: "team-handbook",
+    events: [...HANDBOOK_EVENTS2, "work.item-updated"],
+    handle: () => flush()
+  });
   ctx.onDispose(async () => {
     disposed = true;
     await pending;
@@ -9973,9 +10467,12 @@ function startHandbookRuntime(ctx, worktrees) {
         const caller = actor.kind === "human" ? void 0 : actor.kind === "agent" ? { kind: "thread", threadId: actor.threadId } : actor;
         const member = callerMember(project2, caller);
         if (member !== void 0 && !hasAcknowledged(project2, member.memberId, project2.requiredRelease)) {
+          const name = (await worktrees.goals.read(input.projectId))?.members.find(
+            (row) => row.memberId === member.memberId
+          )?.name ?? member.memberId;
           return {
             allowed: false,
-            detail: handbookMessage("guard", project2.requiredRelease)
+            detail: handbookMessage("guard", project2.requiredRelease, name)
           };
         }
       }
@@ -9983,6 +10480,13 @@ function startHandbookRuntime(ctx, worktrees) {
     }
   };
 }
+var currentRecipient = (project2, memberId) => {
+  const member = goalExecution(project2.goal).members.find((row) => row.memberId === memberId);
+  if (member === void 0) return void 0;
+  return "threadId" in member ? { threadId: member.threadId } : { principalId: member.principalId };
+};
+var leadThread = (project2) => project2.goal?.threads.find((thread) => thread.memberId === project2.goal?.leadMemberId)?.threadId;
+var goalClosed = (project2, wake) => project2.goal !== null && wake !== void 0 && isClosed(readFact(wake.items, teamGoalItemId(project2.goal.projectId, project2.goal.goalId)));
 
 // src/handbook/entry.ts
 var decodeAcknowledgement = decodeUnknownSync(AcknowledgeInput);
@@ -10152,15 +10656,15 @@ function registerHandbookPanel(ctx, runtime) {
 // src/index.ts
 var index_default = definePlugin({
   id: "team",
-  apiVersion: 32,
+  apiVersion: 34,
   activate(ctx) {
     const rosters = createRosterService(ctx);
     registerRosterCommands(ctx, rosters);
     const goals = createGoalService(ctx, rosters);
     registerGoalCommands(ctx, goals);
-    registerBoardCommands(ctx, goals, rosters);
-    registerDetailCommands(ctx, goals);
     const wakes = startWakeRuntime(ctx, goals);
+    registerBoardCommands(ctx, goals, rosters, wakes.state);
+    registerDetailCommands(ctx, goals);
     startRecoveryRuntime(ctx, goals, wakes.state, wakes.worktrees);
     const handbook = startHandbookRuntime(ctx, { lane: wakes.worktrees, goals });
     registerHandbook(ctx, handbook);