@ycodium-ai/plugin-team 0.2.3252 → 0.2.3254

package/dist/index.js

@@ -7211,6 +7211,7 @@ function leadBrief(goal, roster) {
       "A comment that mentions a remote member, or replies to one of their comments, wakes them on their machine, so you can ask or answer them in work item comments. Once they mark an item done they stop working on it, so to send work back to a remote member you still reopen the item as described above."
     ],
     "Use work_list_items to check progress. When all work is complete, summarize the results here in one or two sentences.",
+    "Members' worktrees and branches remain after the goal ends. After their work is merged into the main line, they can be deleted from the source control panel.",
     PERSON_MESSAGE_RULE,
     "If the work item tools are unavailable, tell the user directly that this project needs the board and project memory switches turned on first."
   ].join("\n\n");
@@ -8190,9 +8191,74 @@ function createRosterService(ctx, options = {}) {
   };
 }
 
+// src/runtime/wakeQueries.ts
+function memberWorktreeFor(goals, project2, projectId, recipient) {
+  if (!("threadId" in recipient) || project2 === void 0 || !project2.threads.includes(recipient.threadId) || project2.leadThreads?.includes(recipient.threadId))
+    return;
+  const { threadId } = recipient;
+  const leadThreadId = project2.leadThreads?.[0];
+  if (leadThreadId === void 0) return;
+  return {
+    leadThreadId,
+    failure: project2.worktreeFailures?.[threadId],
+    // 只在要建树或报失败时读目标取名字，叫醒的热路径不多读。
+    name: async () => (await goals.read(projectId))?.members.find((member) => member.threadId === threadId)?.name ?? project2.memberIds?.[threadId] ?? threadId
+  };
+}
+var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var compareWakeItems = (a, b) => a.sequenceId - b.sequenceId || compare(a.workItemId, b.workItemId);
+var isClosed = (item) => item?.stateGroup === "completed" || item?.stateGroup === "cancelled";
+var hasOpenBlocker = (project2, workItemId) => (readFact(project2.blockers, workItemId) ?? []).some(
+  (blocker) => !isClosed(readFact(project2.items, blocker))
+);
+var isAssignedOpen = (project2, workItemId, threadId) => {
+  const item = readFact(project2.items, workItemId);
+  return item !== null && item !== void 0 && !isClosed(item) && item.assigneeThreads.includes(threadId);
+};
+var isWorkable = (project2, workItemId) => !isClosed(readFact(project2.items, workItemId)) && !hasOpenBlocker(project2, workItemId);
+var isOpenWorkFor = (project2, workItemId, threadId) => isAssignedOpen(project2, workItemId, threadId) && !hasOpenBlocker(project2, workItemId);
+var isMember = (project2, recipient) => "threadId" in recipient ? project2.threads.includes(recipient.threadId) : project2.remoteMembers.includes(recipient.principalId);
+var isQueuedUnclaimed = (item, threadId) => item.wakeStatus?.[threadId] === "pending" && !item.claimedBy.includes(threadId);
+var isDeferredWake = (project2, item, threadId) => project2.threads.includes(threadId) && !project2.leadThreads?.includes(threadId) && item.assigneeThreads.includes(threadId) && isQueuedUnclaimed(item, threadId) && !isClosed(item);
+function countDeferredWakes(project2, threadId) {
+  let count = 0;
+  for (const workItemId in project2.items) {
+    const item = readFact(project2.items, workItemId);
+    if (item !== null && isDeferredWake(project2, item, threadId)) count++;
+  }
+  return count;
+}
+
 // src/runtime/deliver.ts
 import * as NodeCrypto from "node:crypto";
 var stableHash = (key) => NodeCrypto.createHash("sha256").update(key).digest("hex").slice(0, 32);
+var memberWorktreeBranch = (name, threadId) => {
+  const slug = Array.from(
+    name.normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "-")
+  ).slice(0, 32).join("").replace(/^-+|-+$/g, "") || "member";
+  return `team/${slug}-${stableHash(threadId).slice(0, 16)}`;
+};
+var createMemberWorktreeLane = (state, events) => {
+  const tails = /* @__PURE__ */ new Map();
+  return {
+    state,
+    events,
+    serialize: (threadId, run3) => {
+      const next = (tails.get(threadId) ?? Promise.resolve()).then(run3);
+      const tail = next.then(
+        () => void 0,
+        () => void 0
+      );
+      tails.set(threadId, tail);
+      void tail.then(() => {
+        if (tails.get(threadId) === tail) tails.delete(threadId);
+      });
+      return next;
+    }
+  };
+};
+var shortReason = (error) => (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim().slice(0, 240) || "Worktree preparation failed";
+var FALLBACK_SUFFIX = ":worktree-fallback";
 async function deliverWake(ctx, input) {
   const { recipient } = input;
   if ("principalId" in recipient) {
@@ -8206,46 +8272,93 @@ async function deliverWake(ctx, input) {
   } else {
     const execution = await ctx.projections.getThreadExecution(recipient.threadId);
     if (execution === null || execution.archivedAt !== null) return false;
-    await ctx.threads.turns.start({
-      requestId: input.requestId,
-      threadId: recipient.threadId,
+    const { threadId } = recipient;
+    const text = typeof input.text === "string" ? input.text : await input.text();
+    const worktree = input.memberWorktree;
+    const turn = {
+      threadId,
       message: {
         messageId: input.messageId,
         role: "user",
-        text: typeof input.text === "string" ? input.text : await input.text(),
+        text,
         attachments: []
       },
       modelSelection: execution.modelSelection,
       runtimeMode: execution.runtimeMode,
       interactionMode: execution.interactionMode
+    };
+    const startTurn = (suffix) => ctx.threads.turns.start({
+      ...turn,
+      requestId: `${input.requestId}${suffix}`,
+      message: { ...turn.message, messageId: `${input.messageId}${suffix}` }
     });
-  }
-  return true;
-}
+    let failure = worktree?.failure;
+    let delivered = false;
+    if (worktree !== void 0 && failure === void 0 && !execution.worktreePath) {
+      const { lane } = worktree;
+      const first = await lane.serialize(threadId, async () => {
+        const current = await ctx.projections.getThreadExecution(threadId);
+        if (current?.worktreePath) return { kind: "registered" };
+        const recorded = (await lane.state.get())[input.projectId]?.worktreeFailures?.[threadId];
+        if (recorded !== void 0) return { kind: "failed", failure: recorded };
+        const branch = memberWorktreeBranch(await worktree.name(), threadId);
+        try {
+          await ctx.threads.turns.start({
+            ...turn,
+            requestId: input.requestId,
+            message: {
+              ...turn.message,
+              text: `${text}
 
-// 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++;
+You are in your own newly created worktree on branch ${branch}. Install dependencies according to the project's instructions before starting work.`
+            },
+            bootstrap: {
+              prepareWorktree: {
+                // bootstrapTurnStart 将它传作 refName；gitDriver/worktrees 用 cwd 下的 HEAD 执行 git worktree add -b。
+                baseBranch: "HEAD",
+                branch,
+                startFromOrigin: false
+              }
+            }
+          });
+        } catch (error) {
+          await startTurn(FALLBACK_SUFFIX);
+          const reason = shortReason(error);
+          const receipt = await lane.events.append({
+            commandId: `team-worktree-failed:${threadId}`,
+            name: "member-worktree-failed",
+            aggregate: { kind: "project", id: input.projectId },
+            data: { version: 1, projectId: input.projectId, threadId, reason }
+          });
+          const persisted = (await lane.state.get({ throughSequence: receipt.sequence }))[input.projectId]?.worktreeFailures?.[threadId];
+          return { kind: "fallback", failure: persisted ?? { reason } };
+        }
+        return { kind: "worktree" };
+      });
+      if (first.kind === "worktree") return true;
+      if (first.kind !== "registered") failure = first.failure;
+      delivered = first.kind === "fallback";
+    }
+    if (!delivered) await startTurn(failure === void 0 ? "" : FALLBACK_SUFFIX);
+    if (worktree !== void 0 && failure !== void 0 && failure.reported !== true) {
+      const reported = await deliverWake(ctx, {
+        projectId: input.projectId,
+        recipient: { threadId: worktree.leadThreadId },
+        requestId: `team-worktree-report:${threadId}`,
+        messageId: `team-worktree-report-msg:${threadId}`,
+        text: `Could not create a worktree for member ${await worktree.name()} (threadId ${threadId}): ${failure.reason}. They will work in the project folder for now.`
+      });
+      if (!reported) throw new Error("Member worktree failure could not be reported to the lead");
+      const receipt = await worktree.lane.events.append({
+        commandId: `team-worktree-reported:${threadId}`,
+        name: "member-worktree-reported",
+        aggregate: { kind: "project", id: input.projectId },
+        data: { version: 1, projectId: input.projectId, threadId }
+      });
+      await worktree.lane.state.get({ throughSequence: receipt.sequence });
+    }
   }
-  return count;
+  return true;
 }
 
 // src/runtime/recoveryState.ts
@@ -8576,6 +8689,12 @@ var MemberWokenFact = Struct({
   threadId: optionalKey2(String4),
   principalId: optionalKey2(String4)
 });
+var MemberWorktreeFailedFact = Struct({
+  version: Literal2(1),
+  projectId: String4,
+  threadId: String4,
+  reason: String4
+});
 var emptyProject = () => ({
   threads: [],
   leadThreads: [],
@@ -8607,6 +8726,20 @@ var decodeEnvelope2 = decodeUnknownOption2(
       pluginId: Literal2("team"),
       name: Literal2("team/member-woken"),
       data: MemberWokenFact
+    }),
+    Struct({
+      pluginId: Literal2("team"),
+      name: Literal2("team/member-worktree-failed"),
+      data: MemberWorktreeFailedFact
+    }),
+    Struct({
+      pluginId: Literal2("team"),
+      name: Literal2("team/member-worktree-reported"),
+      data: Struct({
+        version: Literal2(1),
+        projectId: String4,
+        threadId: String4
+      })
     })
   ])
 );
@@ -8727,6 +8860,20 @@ function foldWorkWakes(state, event) {
         }
       };
     }
+    if (fact.name === "team/member-worktree-failed" || fact.name === "team/member-worktree-reported") {
+      const { projectId: projectId3, threadId } = fact.data;
+      const project4 = readFact(state, projectId3) ?? emptyProject();
+      const previous = project4.worktreeFailures?.[threadId];
+      const failure = fact.name === "team/member-worktree-failed" ? previous ?? { reason: fact.data.reason } : previous === void 0 ? void 0 : { ...previous, reported: true };
+      if (failure === void 0 || failure === previous) return state;
+      return {
+        ...state,
+        [projectId3]: {
+          ...project4,
+          worktreeFailures: { ...project4.worktreeFailures, [threadId]: failure }
+        }
+      };
+    }
     const { projectId: projectId2, key } = fact.data;
     const project3 = readFact(state, projectId2) ?? emptyProject();
     if (project3.pendingComments.some((comment) => comment.key === key)) {
@@ -9009,7 +9156,7 @@ var leadItemText = (workItemId, sequenceId, title) => `You have ${titled(workIte
 var leadUnblockedText = (workItemId, sequenceId, title) => `Everything blocking ${titled(workItemId, sequenceId, title)} is done now. Read those items with work_read_items and check the results. ${LEAD_SEND_BACK_RULE} When all of them are acceptable, mark this item done with work_update_item. ${LEAD_NO_MEMBER_TASKS}`;
 var unblockedText = (workItemId, sequenceId, title) => `Everything blocking ${titled(workItemId, sequenceId, title)} is done now. Read those items with work_read_items, finish this one, and mark it done with work_update_item.`;
 var commentText2 = (workItemId, sequenceId) => `There is a new comment for you on ${workLabel(workItemId, sequenceId)}. Read it with work_list_comments, passing workItemId: "${workItemId}", and reply there if needed.`;
-function startWakeRuntime(ctx, options = {}) {
+function startWakeRuntime(ctx, goals, options = {}) {
   const wakes = ctx.derivedState({
     key: WAKE_STATE_KEY,
     version: WAKE_STATE_VERSION,
@@ -9017,6 +9164,7 @@ function startWakeRuntime(ctx, options = {}) {
     init: () => ({}),
     apply: foldWakes
   });
+  const worktrees = createMemberWorktreeLane(wakes, ctx.events);
   const hash2 = options.hash ?? stableHash;
   let pending = Promise.resolve();
   const readItem = async (projectId, workItemId) => {
@@ -9029,11 +9177,13 @@ function startWakeRuntime(ctx, options = {}) {
       if (!isWakeDue(state, wake)) continue;
       try {
         const id = hash2(wake.key);
+        const worktree = memberWorktreeFor(goals, state[wake.projectId], wake.projectId, wake);
         const delivered = await deliverWake(ctx, {
           projectId: wake.projectId,
           recipient: wake,
           requestId: `team-wake:${id}`,
           messageId: `team-wake-msg:${id}`,
+          memberWorktree: worktree === void 0 ? void 0 : { ...worktree, lane: worktrees },
           text: async () => {
             if ("principalId" in wake || wake.kind === "comment")
               return commentText2(wake.workItemId, wake.sequenceId);
@@ -9081,7 +9231,7 @@ function startWakeRuntime(ctx, options = {}) {
   });
   const ready = flush();
   void ready.catch((error) => ctx.log?.warn("team wake catch-up failed", { error }));
-  return { flush, ready, state: wakes };
+  return { flush, ready, state: wakes, worktrees };
 }
 
 // src/runtime/recovery.ts
@@ -9104,7 +9254,7 @@ ${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) {
+function startRecoveryRuntime(ctx, goals, state, worktrees) {
   let pending = Promise.resolve();
   let disposed = false;
   const execute = async (scope2) => {
@@ -9222,12 +9372,16 @@ function startRecoveryRuntime(ctx, goals, state) {
             await requestPlan(plan);
           }
         }
+        const worktree = memberWorktreeFor(goals, current[recovery.projectId], recovery.projectId, {
+          threadId: plan.recipientThreadId
+        });
         const delivered = await deliverWake(ctx, {
           projectId: recovery.projectId,
           recipient: { threadId: plan.recipientThreadId },
           requestId: `team-recovery:${id}:${plan.action}`,
           messageId: `team-recovery-msg:${id}:${plan.action}`,
-          text: plan.text
+          text: plan.text,
+          memberWorktree: worktree === void 0 ? void 0 : { ...worktree, lane: worktrees }
         });
         if (!delivered) continue;
         const receipt = await ctx.events.append({
@@ -9572,7 +9726,7 @@ var terminalFailure = (error) => {
   if (!rejected && !invalid2) return null;
   return error instanceof Error ? error.message : "detail" in error ? String(error.detail) : String(reason);
 };
-function startHandbookRuntime(ctx) {
+function startHandbookRuntime(ctx, worktrees) {
   const state = ctx.derivedState({
     key: "handbook",
     version: 5,
@@ -9651,16 +9805,24 @@ function startHandbookRuntime(ctx) {
   };
   const remind = async () => {
     const snapshot = await state.get();
+    const wakeState = Object.keys(snapshot.pendingReminders).length === 0 ? void 0 : await worktrees.lane.state.get();
     for (const [key, reminder] of Object.entries(snapshot.pendingReminders)) {
       const { projectId, release, member } = reminder;
       try {
         const id = stableHash(key);
+        const worktree = memberWorktreeFor(
+          worktrees.goals,
+          wakeState?.[projectId],
+          projectId,
+          member.recipient
+        );
         const delivered = await deliverWake(ctx, {
           projectId,
           recipient: member.recipient,
           requestId: `team-handbook:${id}`,
           messageId: `team-handbook-msg:${id}`,
-          text: handbookMessage("reminder", release)
+          text: handbookMessage("reminder", release),
+          memberWorktree: worktree === void 0 ? void 0 : { ...worktree, lane: worktrees.lane }
         });
         if (!delivered) continue;
         const previousKey = JSON.stringify([release, member.memberId]);
@@ -9985,7 +10147,7 @@ function registerHandbookPanel(ctx, runtime) {
 // src/index.ts
 var index_default = definePlugin({
   id: "team",
-  apiVersion: 29,
+  apiVersion: 30,
   activate(ctx) {
     const rosters = createRosterService(ctx);
     registerRosterCommands(ctx, rosters);
@@ -9993,9 +10155,9 @@ var index_default = definePlugin({
     registerGoalCommands(ctx, goals);
     registerBoardCommands(ctx, goals, rosters);
     registerDetailCommands(ctx, goals);
-    const wakes = startWakeRuntime(ctx);
-    startRecoveryRuntime(ctx, goals, wakes.state);
-    const handbook = startHandbookRuntime(ctx);
+    const wakes = startWakeRuntime(ctx, goals);
+    startRecoveryRuntime(ctx, goals, wakes.state, wakes.worktrees);
+    const handbook = startHandbookRuntime(ctx, { lane: wakes.worktrees, goals });
     registerHandbook(ctx, handbook);
     registerHandbookPanel(ctx, handbook);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/plugin-team",
-  "version": "0.2.3252",
+  "version": "0.2.3254",
   "description": "A project team roster with members, a lead, and goals.",
   "keywords": [
     "teams",
@@ -34,7 +34,7 @@
     "tailwindcss": "^4.0.0",
     "typescript": "~6.0.3",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.3252"
+    "@ycodium-ai/plugin-api": "0.2.3254"
   },
   "ycodium": {
     "plugin": "./dist/index.js",
@@ -46,6 +46,7 @@
         "commands": [
           "thread.create",
           "thread.turn.start",
+          "thread.worktree.prepare",
           "thread.turn-queue.resume",
           "work.item.create",
           "work.item.update",