@ycodium-ai/plugin-team 0.2.3252 → 0.2.3265

package/dist/index.js

@@ -7168,6 +7168,10 @@ function handbookMessage(key, release) {
 // 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 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 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.";
@@ -7204,6 +7208,7 @@ 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,
+    LEAD_ACCEPT_RULE,
     LEAD_STUCK_RULE,
     `Only after all dependencies are recorded, assign each item to exactly one member with work_update_item. For local members use assignees: [{ "kind": "agent", "threadId": "<threadId from the table>" }]. 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 ? [] : [
@@ -7211,6 +7216,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 +8196,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 +8277,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 +8694,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 +8731,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 +8865,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)) {
@@ -9004,12 +9156,12 @@ var itemHeadline = (sequenceId, item) => {
   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 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_READ_RANGES_RULE} ${MEMBER_NO_STASH_RULE} ${MEMBER_ASK_BEFORE_OUTSIDE_RULE} ${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 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 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 +9169,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 +9182,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 +9236,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 +9259,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 +9377,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 +9731,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 +9810,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 +10152,7 @@ function registerHandbookPanel(ctx, runtime) {
 // src/index.ts
 var index_default = definePlugin({
   id: "team",
-  apiVersion: 29,
+  apiVersion: 31,
   activate(ctx) {
     const rosters = createRosterService(ctx);
     registerRosterCommands(ctx, rosters);
@@ -9993,9 +10160,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.3265",
   "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.3265"
   },
   "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",