@ycodium-ai/plugin-team 0.2.3116 → 0.2.3122

package/dist/index.js

@@ -3511,9 +3511,9 @@ var fromOptionExit = (option2) => option2._tag === "None" ? missingExit : succee
 // ../../node_modules/.pnpm/effect@4.0.0-beta.103_patch_hash=78523ded7c3dfc3efd3cec0247f4960d00eaa3d3c96a2077457694a4d8b453c6/node_modules/effect/dist/SchemaGetter.js
 var Getter = class _Getter extends Class {
   run;
-  constructor(run2) {
+  constructor(run3) {
     super();
-    this.run = run2;
+    this.run = run3;
   }
   map(f) {
     return new _Getter((oe, options) => this.run(oe, options).pipe(mapEager2(map(f))));
@@ -3670,18 +3670,18 @@ var Declaration = class _Declaration extends Base2 {
   typeParameters;
   run;
   encodingChecks;
-  constructor(typeParameters, run2, annotations, checks, encoding, context2, encodingChecks) {
+  constructor(typeParameters, run3, annotations, checks, encoding, context2, encodingChecks) {
     super(annotations, checks, encoding, context2);
     this.typeParameters = typeParameters;
-    this.run = run2;
+    this.run = run3;
     this.encodingChecks = encodingChecks;
   }
   /** @internal */
   getParser() {
-    let run2;
+    let run3;
     return (input, options) => {
       if (input === missing) return missingExit;
-      return (run2 ??= this.run(this.typeParameters))(input, this, options);
+      return (run3 ??= this.run(this.typeParameters))(input, this, options);
     };
   }
   _rebuild(recur, checks, encodingChecks) {
@@ -4635,9 +4635,9 @@ var Filter2 = class _Filter extends Class {
    * Whether the parsing process should be aborted after this check has failed.
    */
   aborted;
-  constructor(run2, annotations = void 0, aborted = false) {
+  constructor(run3, annotations = void 0, aborted = false) {
     super();
-    this.run = run2;
+    this.run = run3;
     this.annotations = annotations;
     this.aborted = aborted;
   }
@@ -6199,8 +6199,8 @@ function fromASTs(asts) {
 
 // ../../node_modules/.pnpm/effect@4.0.0-beta.103_patch_hash=78523ded7c3dfc3efd3cec0247f4960d00eaa3d3c96a2077457694a4d8b453c6/node_modules/effect/dist/Schema.js
 function declareConstructor() {
-  return (typeParameters, run2, annotations) => {
-    return make8(new Declaration(typeParameters.map(getAST), (typeParameters2) => run2(typeParameters2.map((ast) => make8(ast))), annotations));
+  return (typeParameters, run3, annotations) => {
+    return make8(new Declaration(typeParameters.map(getAST), (typeParameters2) => run3(typeParameters2.map((ast) => make8(ast))), annotations));
   };
 }
 function declare(is2, annotations) {
@@ -6379,6 +6379,7 @@ function isBase64(annotations) {
     ...annotations
   });
 }
+var Finite = /* @__PURE__ */ make8(finite);
 function makeIsGreaterThanOrEqualTo(options) {
   const gte = isGreaterThanOrEqualTo(options.order);
   const formatter = options.formatter ?? format;
@@ -6861,8 +6862,216 @@ function readFact(state, key) {
 var nowIso = map5(now2, formatIso2);
 var factTime = () => runPromise2(nowIso);
 
+// src/domain/execution.ts
+function goalExecution(goal) {
+  return {
+    leadMemberId: goal?.leadMemberId ?? null,
+    members: goal === null ? [] : [...goal.threads, ...goal.remoteMembers ?? []]
+  };
+}
+
+// locales/en.json
+var en_default = {
+  handbook: {
+    requestConflict: "This requestId was already used for a different handbook request. Use a new requestId.",
+    requestVoided: "This requestId was abandoned before the handbook received it. Use a new requestId.",
+    ackTool: "Acknowledge the currently required handbook release for your member seat in the current goal. Reading alone does not acknowledge it. Without a goal there are no team members, acknowledgement gates or reminders.",
+    publishTool: "Publish handbook pages as the local team lead. Reuse requestId only for the same request. Rules changes require acknowledgement; for decisions changes choose requireAck (default false).",
+    revertTool: "Restore a handbook release as the local team lead. Reuse requestId only for the same request. Rules changes require acknowledgement; for decisions changes choose requireAck (default false).",
+    unknownMember: "Your verified caller identity is not mapped to a member of this project's current goal.",
+    leadOnly: "Only the local team lead member of the current goal can publish or revert the handbook.",
+    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).",
+    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."
+  },
+  tab: { title: "Teams" },
+  board: {
+    title: "Project board",
+    newItem: "New work item",
+    itemTitle: "Title",
+    description: "Description (optional)",
+    assignee: "Assign to (optional)",
+    create: "Create work item",
+    retryCreate: "Retry creation",
+    saving: "Saving\u2026",
+    moveTo: "Move to\u2026",
+    moveItem: "Move work item #{{number}}",
+    moveItemTo: "Move work item #{{number}} to {{state}}",
+    assignTo: "Assign to\u2026",
+    assignItem: "Assign work item #{{number}}",
+    assignItemTo: "Assign work item #{{number}} to {{name}}",
+    unassign: "Unassign",
+    unassignItem: "Unassign work item #{{number}}",
+    dragItem: "Drag work item #{{number}} to another state",
+    untitled: "(Untitled)",
+    other: "Other",
+    unassigned: "Unassigned",
+    blockedBy: "Blocked by {{count}} work items",
+    goalRequired: "Start a goal above before assigning work to members.",
+    loading: "Loading board\u2026",
+    loadFailed: "The board could not be loaded. Try reloading it.",
+    watchFailed: "Live board updates are unavailable. Reload to reconnect.",
+    createFailed: "The work item could not be created. Retry with the same request.",
+    updateFailed: "The work item could not be changed. Reloading the board.",
+    staleVersion: "The work item was changed elsewhere. Your change was rolled back and the board is being reloaded.",
+    notAMember: "This thread is not a member of the current goal. Choose a current member.",
+    invalidTitle: "Enter a title for the work item.",
+    reload: "Reload board",
+    truncated: "Showing the first 500 work items in this project."
+  },
+  detail: {
+    title: "Work item details",
+    open: "Details",
+    openItem: "Open details for work item #{{number}}",
+    close: "Close",
+    via: "via {{source}}",
+    description: "Description",
+    noDescription: "(No description)",
+    blockedBy: "Blocked by these work items",
+    blocking: "Blocking these work items",
+    dependency: "#{{number}} {{title}} \xB7 {{state}}",
+    comments: "Comments",
+    noComments: "No comments yet.",
+    deletedComment: "(This comment has been deleted)",
+    commentsTruncated: "Showing the latest 200 comments, including replies.",
+    reply: "Reply",
+    replyTo: "Reply to comment {{number}}",
+    newComment: "Post a comment",
+    send: "Send",
+    sendComment: "Send comment",
+    sendReply: "Send reply to comment {{number}}",
+    sending: "Sending\u2026",
+    retry: "Retry",
+    retryComment: "Retry comment",
+    retryReply: "Retry reply to comment {{number}}",
+    invalidBody: "The comment must be 1\u20138000 characters after trimming spaces.",
+    commentFailed: "The comment couldn't be posted. Try again.",
+    loading: "Loading work item details\u2026",
+    loadFailed: "The work item details could not be loaded. Try reloading them.",
+    reload: "Reload details",
+    notFound: "This work item was not found in this project.",
+    actor: {
+      you: "You",
+      human: "A person",
+      otherAgent: "Other agent",
+      team: "Teams plugin",
+      plugin: "Plugin {{pluginId}}",
+      localCli: "Local command line",
+      system: "System",
+      remoteAgentFallback: "Remote agent"
+    },
+    history: {
+      title: "Activity history",
+      empty: "No activity yet.",
+      truncated: "Showing the latest 200 activities.",
+      deletedState: "(Deleted state)",
+      created: "{{author}} created this work item",
+      createdAssigned: "{{author}} created this work item and assigned it to {{names}}",
+      stateChanged: "{{author}} changed the state from {{old}} to {{new}}",
+      assigned: "{{author}} assigned this work item to {{names}}",
+      unassigned: "{{author}} removed the assignment",
+      titleChanged: "{{author}} changed the title",
+      descriptionChanged: "{{author}} changed the description",
+      claimed: "{{author}} claimed this work item",
+      commented: "{{author}} posted a comment",
+      relationAdded: "{{author}} added a dependency",
+      relationRemoved: "{{author}} removed a dependency"
+    }
+  },
+  goal: {
+    current: "Current goal: {{goal}}",
+    lead: "Lead: {{name}}",
+    unknownLead: "Member no longer in the roster",
+    openLead: "Open lead thread",
+    label: "Goal for the lead",
+    rosterRequired: "Save the roster and choose a lead first.",
+    start: "Start",
+    startNew: "Start a new goal",
+    starting: "Starting\u2026",
+    retry: "Retry",
+    reload: "Reload goal",
+    loading: "Loading goal\u2026",
+    confirmTitle: "Start a new goal?",
+    confirmDescription: "Threads for the previous goal will keep running and remain in the thread list.",
+    confirmStart: "Start new goal",
+    cancel: "Cancel",
+    noRoster: "No saved roster was found. Save the roster and choose a lead first.",
+    invalidPayload: "Check the goal fields and try again.",
+    invalidGoal: "The goal must be 1\u20134000 characters after trimming spaces.",
+    invalidRequestId: "The request ID must be 1\u201364 letters, numbers, underscores, or hyphens.",
+    loadFailed: "The current goal could not be loaded. Try reloading it.",
+    startFailed: "The goal could not be fully started. Retry to finish creating the threads and sending the lead's brief.",
+    remoteMembers: "Remote members:"
+  },
+  roster: {
+    title: "Roster",
+    members: "Members",
+    memberName: "Member {{number}} name",
+    lead: "Lead",
+    leadFor: "Make member {{number}} the lead",
+    remove: "Remove member {{number}}",
+    add: "Add member",
+    addRemoteAgent: "Add remote agent",
+    noRemoteAgents: "There are no available remote agents on this machine yet.",
+    remote: "Remote",
+    save: "Save",
+    saving: "Saving\u2026",
+    saved: "Roster saved",
+    loading: "Loading roster\u2026",
+    retry: "Reload roster",
+    emptyTitle: "No team roster yet",
+    emptyDescription: "Add members and choose a lead for this project.",
+    toolsHint: "Keep the board and project memory on for this project so members can pick up work and record what they learn.",
+    toolkitsOff: "The lead needs the board and project memory. Turn on both switches above.",
+    toolkitsOn: "The board and project memory are on for this project.",
+    staleRevision: "The roster was changed elsewhere and has been reloaded.",
+    loadFailed: "The roster could not be loaded. Try reloading it.",
+    saveFailed: "The roster could not be saved. Try again.",
+    invalidPayload: "Check the roster fields and try again.",
+    memberCount: "A team needs between 1 and 8 members.",
+    invalidMemberId: "Member IDs must be 1\u201364 letters, numbers, underscores, or hyphens.",
+    invalidName: "Member names must be 1\u201340 characters after trimming spaces.",
+    duplicateMemberId: "Each member needs a different ID.",
+    duplicateName: "Member names must be different, ignoring capitalization and surrounding spaces.",
+    leadNotMember: "Choose a lead from the members.",
+    leadRemote: "The lead must be a local member.",
+    duplicatePrincipal: "Each remote agent can appear only once in the roster.",
+    invalidPrincipal: "A remote agent must have a non-empty principal ID.",
+    allRemoteAgentsAdded: "All available remote agents are already on the roster.",
+    remoteAgentsUnavailable: "Could not read the remote agents on this machine. Try again later.",
+    remoteSource: "Remote agent: {{label}}"
+  },
+  remoteStatus: {
+    title: "Remote members",
+    none: "No remote members on the roster. Add one with \u201CAdd remote agent\u201D in the roster.",
+    lastSeen: "Last seen {{time}}",
+    neverSeen: "Not seen yet",
+    workUnavailable: "Could not read this member's work. Try again later.",
+    noWork: "No work assigned.",
+    item: "#{{number}} {{title}}",
+    disabled: "Disabled",
+    revoked: "No active credentials",
+    lastSeenUnavailable: "Could not read when it was last seen",
+    blocked: "Blocked",
+    more: "{{count}} more not listed here"
+  }
+};
+
+// src/handbook/messages.ts
+function handbookMessage(key, release) {
+  return en_default.handbook[key].replace(/{{release}}/g, String(release ?? ""));
+}
+
 // src/domain/leadBrief.ts
 var PERSON_MESSAGE_RULE = "Send a message to the person only when you need their answer; put progress and updates in work item comments with work_post_comment instead.";
+var LEAD_SPLIT_RULE = "Use work_create_item to split the goal into a few work items: one item per task, with a clear action in the title. Members do not see this conversation or your goal, so put everything a member needs into the description: the deliverable, the constraints, and how to hand the work in. Create them without assignees.";
+var LEAD_OWN_ITEM_RULE = "If a work item for this goal is assigned to you, also record it as blocked by every item you create. When they are all done you will be told; then check the results and mark that item done with work_update_item.";
+var LEAD_SEND_BACK_RULE = "If a finished item is not acceptable, send it back: use work_update_item to set its state back to an open one (see work_list_states), and change its assignees too if someone else should redo it. Then say what is wrong in a comment with work_post_comment, mentioning the member.";
+var LEAD_NO_MEMBER_TASKS = "Do not do members' tasks yourself.";
 var tableCell = (value) => value.replace(/\|/g, "\\|").replace(/[\r\n]/g, " ");
 function leadBrief(goal, roster) {
   const localMembers = goal.threads.filter((thread) => thread.memberId !== goal.leadMemberId).map((thread) => {
@@ -6876,6 +7085,7 @@ function leadBrief(goal, roster) {
   return [
     "You are the lead of this project's team. Your goal is:",
     goal.goal,
+    handbookMessage("leadBrief"),
     "Team members and their assignment identities (your own conversation is omitted):",
     [
       "| Member | threadId / remote principalId |",
@@ -6883,11 +7093,11 @@ function leadBrief(goal, roster) {
       ...localMembers,
       ...remoteMembers
     ].join("\n"),
-    "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.",
+    LEAD_SPLIT_RULE,
     'Then use work_add_relation with type "blocked_by" to record dependencies: the dependent workItemId is blocked by the prerequisite relatedWorkItemId.',
-    "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.",
-    "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.",
-    `Only after all dependencies are recorded, assign each item to exactly one member with work_update_item. For local members use assignees: [{ "kind": "agent", "threadId": "<threadId from the table>" }]. A local member is told about an item as soon as it is assigned, so assigning before the dependencies exist starts blocked work early. Do not do members' tasks yourself.`,
+    LEAD_OWN_ITEM_RULE,
+    LEAD_SEND_BACK_RULE,
+    `Only after all dependencies are recorded, assign each item to exactly one member with work_update_item. For local members use assignees: [{ "kind": "agent", "threadId": "<threadId from the table>" }]. A local member is told about an item as soon as it is assigned, so assigning before the dependencies exist starts blocked work early. ${LEAD_NO_MEMBER_TASKS}`,
     ...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."
@@ -6991,9 +7201,10 @@ function createGoalService(ctx, rosterService, options = {}) {
     const goal = readFact(await goals.get(), projectId);
     if (goal === null) return null;
     const roster = await rosterService.read(projectId);
+    const execution = goalExecution(goal);
     return {
       ...goal,
-      members: [...goal.threads, ...goal.remoteMembers ?? []].map((member) => ({
+      members: execution.members.map((member) => ({
         ...member,
         name: roster?.members.find((row) => row.memberId === member.memberId)?.name ?? null
       }))
@@ -7312,7 +7523,9 @@ function registerBoardCommands(ctx, goals, rosters, options = {}) {
     const timer = NodeTimers.setTimeout(notify, delay2);
     return () => NodeTimers.clearTimeout(timer);
   });
-  const isMember2 = async (projectId, threadId) => (await goals.read(projectId))?.members.some((member) => member.threadId === threadId) === true;
+  const isMember2 = async (projectId, threadId) => goalExecution(await goals.read(projectId)).members.some(
+    (member) => "threadId" in member && member.threadId === threadId
+  );
   ctx.command({
     name: "board",
     scope: "read",
@@ -7767,12 +7980,42 @@ function createRosterService(ctx, options = {}) {
   };
 }
 
-// src/runtime/wake.ts
+// src/runtime/deliver.ts
 import * as NodeCrypto from "node:crypto";
+var stableHash = (key) => NodeCrypto.createHash("sha256").update(key).digest("hex").slice(0, 32);
+async function deliverWake(ctx, input) {
+  const { recipient } = input;
+  if ("principalId" in recipient) {
+    await ctx.communication.records.send({
+      projectId: input.projectId,
+      requestId: input.requestId,
+      to: { principalId: recipient.principalId },
+      text: typeof input.text === "string" ? input.text : await input.text(),
+      delivery: "wake"
+    });
+  } 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,
+      message: {
+        messageId: input.messageId,
+        role: "user",
+        text: typeof input.text === "string" ? input.text : await input.text(),
+        attachments: []
+      },
+      modelSelection: execution.modelSelection,
+      runtimeMode: execution.runtimeMode,
+      interactionMode: execution.interactionMode
+    });
+  }
+  return true;
+}
 
 // src/runtime/wakeState.ts
 var WAKE_STATE_KEY = "wakes";
-var WAKE_STATE_VERSION = 4;
+var WAKE_STATE_VERSION = 5;
 var WAKE_EVENTS = [
   "work.item-created",
   "work.item-updated",
@@ -7791,6 +8034,7 @@ var MemberWokenFact = Struct({
 });
 var emptyProject = () => ({
   threads: [],
+  leadThreads: [],
   remoteMembers: [],
   items: {},
   blockers: {},
@@ -7913,11 +8157,17 @@ function foldWakes(state, event) {
     if (fact.name === "team/goal-started") {
       const { goal } = fact.data;
       const project3 = readFact(state, goal.projectId) ?? emptyProject();
-      const threads = [...new Set(goal.threads.map((thread) => thread.threadId))];
+      const { members } = goalExecution(goal);
+      const threads = [
+        ...new Set(members.flatMap((member) => "threadId" in member ? [member.threadId] : []))
+      ];
       const remoteMembers = [
-        ...new Set((goal.remoteMembers ?? []).map((member) => member.principalId))
+        ...new Set(
+          members.flatMap((member) => "principalId" in member ? [member.principalId] : [])
+        )
       ];
-      const next2 = { ...project3, threads, remoteMembers };
+      const leadThreads = goal.threads.filter((thread) => thread.memberId === goal.leadMemberId).map((thread) => thread.threadId);
+      const next2 = { ...project3, threads, leadThreads, remoteMembers };
       return {
         ...state,
         [goal.projectId]: {
@@ -8041,6 +8291,7 @@ function dueWakes(state) {
   for (const [projectId, project] of Object.entries(state)) {
     const woken = new Set(project.woken);
     const threads = new Set(project.threads);
+    const leads = new Set(project.leadThreads ?? []);
     for (const [workItemId, item] of Object.entries(project.items)) {
       if (item.closed || hasOpenBlocker(project, workItemId)) continue;
       const unblocked = readFact(project.blockedAfterClaim, workItemId) ?? 0;
@@ -8063,7 +8314,8 @@ function dueWakes(state) {
           threadId,
           kind: finishing ? "unblocked" : "item",
           workItemId,
-          sequenceId: item.sequenceId
+          sequenceId: item.sequenceId,
+          ...leads.has(threadId) ? { lead: true } : {}
         });
       }
     }
@@ -8082,10 +8334,11 @@ function dueWakes(state) {
 // src/runtime/wake.ts
 var workLabel = (workItemId, sequenceId) => sequenceId === void 0 ? `the work item with workItemId ${workItemId}` : `work item W${sequenceId} (workItemId ${workItemId})`;
 var titled = (workItemId, sequenceId, title) => `${workLabel(workItemId, sequenceId)}${title ? `: ${title}` : ""}`;
-var itemText = (workItemId, sequenceId, title) => `You have ${titled(workItemId, sequenceId, title)}. Read it with work_read_items, passing workItemIds: ["${workItemId}"]. If it is blocked by items that are not done yet, do not start it; you will be told again when they are done. Otherwise claim it with work_claim_item. Before you change anything, search this repository's rules and checks with memory_search and follow what applies. Then work on it. ${PERSON_MESSAGE_RULE}`;
+var itemText = (workItemId, sequenceId, title) => `You have ${titled(workItemId, sequenceId, title)}. Read it with work_read_items, passing workItemIds: ["${workItemId}"]. If it is blocked by items that are not done yet, do not start it; you will be told again when they are done. Otherwise claim it with work_claim_item. Before you change anything, search this repository's rules and checks with memory_search and follow what applies. Then work on it. ${handbookMessage("memberBrief")} ${PERSON_MESSAGE_RULE}`;
+var leadItemText = (workItemId, sequenceId, title) => `You have ${titled(workItemId, sequenceId, title)}. You lead this team, so this item is the goal itself: do not claim it or do its work yourself. Read it with work_read_items, passing workItemIds: ["${workItemId}"]. If it has no work items yet, split it as your team brief says. ${LEAD_SPLIT_RULE} ${LEAD_OWN_ITEM_RULE} Record dependencies and assign each item to one member as the brief describes. ${LEAD_NO_MEMBER_TASKS} ${PERSON_MESSAGE_RULE}`;
+var leadUnblockedText = (workItemId, sequenceId, title) => `Everything blocking ${titled(workItemId, sequenceId, title)} is done now. Read those items with work_read_items and check the results. ${LEAD_SEND_BACK_RULE} When all of them are acceptable, mark this item done with work_update_item. ${LEAD_NO_MEMBER_TASKS}`;
 var unblockedText = (workItemId, sequenceId, title) => `Everything blocking ${titled(workItemId, sequenceId, title)} is done now. Read those items with work_read_items, finish this one, and mark it done with work_update_item.`;
 var commentText2 = (workItemId, sequenceId) => `There is a new comment for you on ${workLabel(workItemId, sequenceId)}. Read it with work_list_comments, passing workItemId: "${workItemId}", and reply there if needed.`;
-var stableHash = (key) => NodeCrypto.createHash("sha256").update(key).digest("hex").slice(0, 32);
 function startWakeRuntime(ctx, options = {}) {
   const wakes = ctx.derivedState({
     key: WAKE_STATE_KEY,
@@ -8105,35 +8358,18 @@ function startWakeRuntime(ctx, options = {}) {
     for (const wake of dueWakes(state)) {
       try {
         const id = hash2(wake.key);
-        if ("principalId" in wake) {
-          await ctx.communication.records.send({
-            projectId: wake.projectId,
-            requestId: `team-wake:${id}`,
-            to: { principalId: wake.principalId },
-            text: commentText2(wake.workItemId, wake.sequenceId),
-            delivery: "wake"
-          });
-        } else {
-          const execution = await ctx.projections.getThreadExecution(wake.threadId);
-          if (execution === null || execution.archivedAt !== null) continue;
-          await ctx.threads.turns.start({
-            requestId: `team-wake:${id}`,
-            threadId: wake.threadId,
-            message: {
-              messageId: `team-wake-msg:${id}`,
-              role: "user",
-              text: wake.kind === "comment" ? commentText2(wake.workItemId, wake.sequenceId) : (wake.kind === "item" ? itemText : unblockedText)(
-                wake.workItemId,
-                wake.sequenceId,
-                await readTitle(wake.projectId, wake.workItemId)
-              ),
-              attachments: []
-            },
-            modelSelection: execution.modelSelection,
-            runtimeMode: execution.runtimeMode,
-            interactionMode: execution.interactionMode
-          });
-        }
+        const delivered = await deliverWake(ctx, {
+          projectId: wake.projectId,
+          recipient: wake,
+          requestId: `team-wake:${id}`,
+          messageId: `team-wake-msg:${id}`,
+          text: async () => "principalId" in wake || wake.kind === "comment" ? commentText2(wake.workItemId, wake.sequenceId) : (wake.kind === "item" ? wake.lead === true ? leadItemText : itemText : wake.lead === true ? leadUnblockedText : unblockedText)(
+            wake.workItemId,
+            wake.sequenceId,
+            await readTitle(wake.projectId, wake.workItemId)
+          )
+        });
+        if (!delivered) continue;
         const receipt = await ctx.events.append({
           commandId: `team-woken:${id}`,
           name: "member-woken",
@@ -8165,10 +8401,562 @@ function startWakeRuntime(ctx, options = {}) {
   return { flush, ready };
 }
 
+// src/handbook/content.ts
+async function releaseRefs(memory, projectId, release) {
+  return release === 0 ? [] : (await memory.handbook.releases.get({ projectId, release })).pages;
+}
+async function readBody(memory, projectId, ref) {
+  let offset = 0;
+  let body = "";
+  while (true) {
+    const page = await memory.pageRevisions.get({
+      projectId,
+      pageId: ref.pageId,
+      revision: ref.revision,
+      textOffset: offset
+    });
+    if (page.bodyState !== "present" || page.body === null)
+      throw new Error("handbook-content-unavailable");
+    body += page.body;
+    const next = page.bodyWindow?.nextOffset;
+    if (next === void 0 || next === null) break;
+    offset = next;
+  }
+  return body;
+}
+async function publicationRequiresAck(memory, projectId, input) {
+  const kinds = input.requireAck ? ["handbook_rules", "handbook_decisions"] : ["handbook_rules"];
+  if (input.operation === "publish" && !input.pages.some((page) => kinds.includes(page.kind)))
+    return false;
+  const current = await releaseRefs(memory, projectId, input.expectedRelease);
+  const target = input.operation === "revert" ? await releaseRefs(memory, projectId, input.toRelease) : [];
+  for (const kind of kinds) {
+    const previous = current.find((page) => page.kind === kind);
+    if (input.operation === "publish") {
+      const page = input.pages.find((row) => row.kind === kind);
+      if (page === void 0) continue;
+      if (previous === void 0) return true;
+      if (await readBody(memory, projectId, previous) !== page.body) return true;
+    } else {
+      const next = target.find((page) => page.kind === kind);
+      if (previous === void 0 || next === void 0) {
+        if (previous !== next) return true;
+        continue;
+      }
+      if (previous.pageId === next.pageId && previous.revision === next.revision) continue;
+      if (await readBody(memory, projectId, previous) !== await readBody(memory, projectId, next))
+        return true;
+    }
+  }
+  return false;
+}
+
+// src/handbook/contracts.ts
+var Release = Int.check(isGreaterThanOrEqualTo3(1));
+var Page = Struct({
+  kind: Literals(["handbook_decisions", "handbook_rules", "handbook_progress"]),
+  baseRevision: NullOr(Finite),
+  title: optionalKey2(String4),
+  body: String4,
+  changeSummary: optionalKey2(String4)
+});
+var WriteFields = {
+  requestId: String4,
+  expectedRelease: Finite,
+  requireAck: optionalKey2(Boolean2)
+};
+var PublishInput = Struct({
+  ...WriteFields,
+  pages: ArraySchema(Page),
+  sourceExperience: optionalKey2(
+    Struct({ experienceId: String4, revision: Finite })
+  )
+});
+var RevertInput = Struct({ ...WriteFields, toRelease: Finite });
+var AcknowledgeInput = Struct({ release: Release });
+var ReadHandbookInput = Struct({ projectId: String4 });
+var PublicationIntent = Struct({
+  version: Literal2(1),
+  projectId: String4,
+  memberId: String4,
+  requestId: String4,
+  op: Literals(["publish", "revert"]),
+  requireAckChoice: optionalKey2(Boolean2),
+  requiresAck: optionalKey2(Boolean2)
+});
+var PublicationCompleted = Struct({
+  version: Literal2(1),
+  projectId: String4,
+  requestId: String4,
+  outcome: Union2([
+    Struct({ status: Literal2("succeeded"), release: Release }),
+    Struct({ status: Literal2("rejected") }),
+    Struct({ status: Literal2("voided") })
+  ])
+});
+var Acknowledged = Struct({
+  version: Literal2(1),
+  projectId: String4,
+  release: Release,
+  memberId: String4
+});
+var ReminderSent = Struct({
+  ...Acknowledged.fields
+});
+
+// src/handbook/state.ts
+var HANDBOOK_EVENTS = ["plugin.event-appended", "wiki.handbook-released"];
+var emptyHandbookState = () => ({
+  projects: {},
+  intents: {},
+  completed: {},
+  pendingPublications: {},
+  pendingAcknowledgements: {},
+  pendingReminders: {}
+});
+var emptyHandbookProject = () => ({
+  goal: null,
+  currentRelease: null,
+  requiredRelease: null,
+  acknowledgements: {},
+  reminded: {}
+});
+var envelope = (name, data) => Struct({ pluginId: Literal2("team"), name: Literal2(`team/${name}`), data });
+var decodeFact3 = decodeUnknownOption2(
+  Union2([
+    envelope("goal-started", GoalStartedFact),
+    envelope("handbook-publication-intended", PublicationIntent),
+    envelope("handbook-publication-completed", PublicationCompleted),
+    envelope("handbook-acknowledged", Acknowledged),
+    envelope("handbook-reminder-sent", ReminderSent)
+  ])
+);
+var decodeRelease = decodeUnknownSync(
+  Struct({
+    projectId: String4,
+    release: Number5,
+    requiresAck: Boolean2
+  })
+);
+function callerMember(project, caller) {
+  if (caller === void 0) return void 0;
+  return goalExecution(project.goal).members.find(
+    (member) => caller.kind === "thread" ? "threadId" in member && member.threadId === caller.threadId : "principalId" in member && member.principalId === caller.principalId
+  );
+}
+var hasAcknowledged = (project, memberId, release) => readFact(readFact(project.acknowledgements, memberId)?.releases ?? {}, String(release)) === true;
+var reminderKey = (projectId, release, memberId) => JSON.stringify([projectId, release, memberId]);
+var without = (rows, key) => {
+  if (!Object.hasOwn(rows, key)) return rows;
+  const next = { ...rows };
+  delete next[key];
+  return next;
+};
+function foldHandbook(state, event) {
+  if (event.type === "wiki.handbook-released") {
+    const fact2 = decodeRelease(event.payload);
+    const project2 = readFact(state.projects, fact2.projectId) ?? emptyHandbookProject();
+    const pendingReminders = { ...state.pendingReminders };
+    if (fact2.requiresAck)
+      for (const { memberId, ...recipient } of goalExecution(project2.goal).members) {
+        const key = reminderKey(fact2.projectId, fact2.release, memberId);
+        if (readFact(project2.reminded, key) === null)
+          pendingReminders[key] = {
+            projectId: fact2.projectId,
+            release: fact2.release,
+            member: { memberId, recipient }
+          };
+      }
+    return {
+      ...state,
+      pendingReminders,
+      projects: {
+        ...state.projects,
+        [fact2.projectId]: {
+          ...project2,
+          currentRelease: fact2.release,
+          requiredRelease: fact2.requiresAck ? fact2.release : project2.requiredRelease
+        }
+      }
+    };
+  }
+  if (event.type !== "plugin.event-appended") return state;
+  const decoded = decodeFact3(event.payload);
+  if (isNone2(decoded)) return state;
+  const fact = decoded.value;
+  const projectId = fact.name === "team/goal-started" ? fact.data.goal.projectId : fact.data.projectId;
+  const project = readFact(state.projects, projectId) ?? emptyHandbookProject();
+  let next = project;
+  switch (fact.name) {
+    case "team/goal-started":
+      next = { ...project, goal: fact.data.goal };
+      break;
+    case "team/handbook-publication-intended": {
+      const intent = fact.data;
+      if (readFact(state.intents, intent.requestId) !== null) return state;
+      return {
+        ...state,
+        intents: { ...state.intents, [intent.requestId]: intent },
+        pendingPublications: { ...state.pendingPublications, [intent.requestId]: intent }
+      };
+    }
+    case "team/handbook-publication-completed": {
+      const completed = fact.data;
+      if (readFact(state.completed, completed.requestId) !== null) return state;
+      const intent = readFact(state.pendingPublications, completed.requestId);
+      let pendingAcknowledgements = state.pendingAcknowledgements;
+      let pendingReminders = state.pendingReminders;
+      if (intent !== null && intent.requiresAck && completed.outcome.status === "succeeded") {
+        const { release } = completed.outcome;
+        const key = reminderKey(projectId, release, intent.memberId);
+        pendingReminders = without(pendingReminders, key);
+        if (!hasAcknowledged(project, intent.memberId, release))
+          pendingAcknowledgements = {
+            ...pendingAcknowledgements,
+            [key]: { version: 1, projectId, release, memberId: intent.memberId }
+          };
+      }
+      return {
+        ...state,
+        completed: { ...state.completed, [completed.requestId]: completed },
+        pendingPublications: without(state.pendingPublications, completed.requestId),
+        pendingAcknowledgements,
+        pendingReminders
+      };
+    }
+    case "team/handbook-acknowledged": {
+      const { memberId, release } = fact.data;
+      if (hasAcknowledged(project, memberId, release)) return state;
+      const previous = readFact(project.acknowledgements, memberId);
+      next = {
+        ...project,
+        acknowledgements: {
+          ...project.acknowledgements,
+          [memberId]: {
+            releases: { ...previous?.releases, [release]: true },
+            latestRelease: Math.max(previous?.latestRelease ?? 0, release)
+          }
+        }
+      };
+      return {
+        ...state,
+        pendingAcknowledgements: without(
+          state.pendingAcknowledgements,
+          reminderKey(projectId, release, memberId)
+        ),
+        projects: { ...state.projects, [projectId]: next }
+      };
+    }
+    case "team/handbook-reminder-sent": {
+      const key = reminderKey(projectId, fact.data.release, fact.data.memberId);
+      if (readFact(project.reminded, key) !== null) return state;
+      next = { ...project, reminded: { ...project.reminded, [key]: true } };
+      return {
+        ...state,
+        pendingReminders: without(state.pendingReminders, key),
+        projects: { ...state.projects, [projectId]: next }
+      };
+    }
+  }
+  return { ...state, projects: { ...state.projects, [projectId]: next } };
+}
+
+// src/handbook/runtime.ts
+var terminalFailure = (error) => {
+  if (typeof error !== "object" || error === null || !("_tag" in error)) return null;
+  const reason = "reason" in error ? error.reason : void 0;
+  const rejected = error._tag === "DataCommandError" && ["rejected", "request-conflict", "command-id-conflict", "not-qualified"].includes(
+    String(reason)
+  );
+  const invalid2 = error._tag === "PluginCapabilityError" && reason === void 0 && "capability" in error && ["memory.handbook.publish", "memory.handbook.revert"].includes(String(error.capability));
+  if (!rejected && !invalid2) return null;
+  return error instanceof Error ? error.message : "detail" in error ? String(error.detail) : String(reason);
+};
+function startHandbookRuntime(ctx) {
+  const state = ctx.derivedState({
+    key: "handbook",
+    version: 4,
+    events: HANDBOOK_EVENTS,
+    init: emptyHandbookState,
+    apply: foldHandbook
+  });
+  let pending = Promise.resolve();
+  let disposed = false;
+  const serial = (execute2) => {
+    const result2 = pending.then(() => {
+      if (disposed) throw new Error("team-handbook-disposed");
+      return execute2();
+    });
+    pending = result2.then(
+      () => void 0,
+      () => void 0
+    );
+    return result2;
+  };
+  const append2 = async (projectId, name, key, data) => {
+    const receipt = await ctx.events.append({
+      commandId: `handbook:${name}:${stableHash(key)}`,
+      name,
+      aggregate: { kind: "project", id: projectId },
+      data
+    });
+    return state.get({ throughSequence: receipt.sequence });
+  };
+  const acknowledge = async (projectId, release, memberId) => {
+    const project = readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
+    if (hasAcknowledged(project, memberId, release)) return;
+    await append2(
+      projectId,
+      "handbook-acknowledged",
+      JSON.stringify([projectId, release, memberId]),
+      {
+        version: 1,
+        projectId,
+        release,
+        memberId
+      }
+    );
+  };
+  const complete = async (intent, outcome) => {
+    await append2(intent.projectId, "handbook-publication-completed", intent.requestId, {
+      version: 1,
+      requestId: intent.requestId,
+      projectId: intent.projectId,
+      outcome
+    });
+    if (outcome.status === "succeeded" && intent.requiresAck) {
+      await acknowledge(intent.projectId, outcome.release, intent.memberId);
+    }
+    return outcome;
+  };
+  const reconcile = async (intent) => {
+    const completed = readFact((await state.get()).completed, intent.requestId);
+    if (completed !== null) return completed.outcome;
+    const receipt = await ctx.commands.getReceipt({
+      commandId: intent.requestId,
+      commandType: `wiki.handbook.${intent.op}`
+    });
+    if (receipt.status === "absent") return complete(intent, { status: "voided" });
+    if (receipt.status === "rejected") return complete(intent, { status: "rejected" });
+    const result2 = receipt.result;
+    if (typeof result2 !== "object" || result2 === null || !("release" in result2) || typeof result2.release !== "number" || !Number.isSafeInteger(result2.release) || result2.release < 1)
+      throw new Error("handbook-receipt-result-unavailable");
+    await state.get({ throughSequence: receipt.sequence });
+    return complete(intent, { status: "succeeded", release: result2.release });
+  };
+  const remind = async () => {
+    const snapshot = await state.get();
+    for (const [key, reminder] of Object.entries(snapshot.pendingReminders)) {
+      const { projectId, release, member } = reminder;
+      try {
+        const id = stableHash(key);
+        const delivered = await deliverWake(ctx, {
+          projectId,
+          recipient: member.recipient,
+          requestId: `team-handbook:${id}`,
+          messageId: `team-handbook-msg:${id}`,
+          text: handbookMessage("reminder", release)
+        });
+        if (!delivered) continue;
+        const previousKey = JSON.stringify([release, member.memberId]);
+        await append2(
+          projectId,
+          "handbook-reminder-sent",
+          JSON.stringify([projectId, previousKey]),
+          {
+            version: 1,
+            projectId,
+            release,
+            memberId: member.memberId
+          }
+        );
+      } catch (error) {
+        ctx.log.warn("team handbook reminder failed", { projectId, key, error });
+      }
+    }
+  };
+  const execute = async () => {
+    for (const intent of Object.values((await state.get()).pendingPublications)) {
+      try {
+        await reconcile(intent);
+      } catch (error) {
+        ctx.log.warn("team handbook publication catch-up failed", {
+          requestId: intent.requestId,
+          error
+        });
+      }
+    }
+    for (const ack of Object.values((await state.get()).pendingAcknowledgements)) {
+      try {
+        await acknowledge(ack.projectId, ack.release, ack.memberId);
+      } catch (error) {
+        ctx.log.warn("team handbook publisher acknowledgement failed", { ...ack, error });
+      }
+    }
+    await remind();
+  };
+  const flush = () => serial(execute);
+  ctx.reactor({ name: "team-handbook", events: HANDBOOK_EVENTS, handle: () => flush() });
+  ctx.onDispose(async () => {
+    disposed = true;
+    await pending;
+  });
+  const ready = flush();
+  void ready.catch((error) => ctx.log.warn("team handbook catch-up failed", { error }));
+  return {
+    ready,
+    flush,
+    async read(projectId) {
+      const project = readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
+      return {
+        currentRelease: project.currentRelease,
+        requiredRelease: project.requiredRelease,
+        members: goalExecution(project.goal).members.map(({ memberId }) => ({
+          memberId,
+          acknowledgedRelease: readFact(project.acknowledgements, memberId)?.latestRelease ?? null,
+          acknowledgedRequiredRelease: project.requiredRelease === null || hasAcknowledged(project, memberId, project.requiredRelease)
+        }))
+      };
+    },
+    ack(release, invocation) {
+      return serial(async () => {
+        const projectId = invocation.projectId;
+        const project = projectId === null ? emptyHandbookProject() : readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
+        const member = callerMember(project, invocation.caller);
+        if (member === void 0 || projectId === null)
+          throw new Error(handbookMessage("unknownMember"));
+        if (project.requiredRelease === null) throw new Error(handbookMessage("noRequirement"));
+        if (release !== project.requiredRelease)
+          throw new Error(handbookMessage("wrongRelease", project.requiredRelease));
+        await acknowledge(projectId, release, member.memberId);
+        return { release, memberId: member.memberId };
+      });
+    },
+    publish(input, invocation) {
+      return serial(async () => {
+        const projectId = invocation.projectId;
+        const project = projectId === null ? emptyHandbookProject() : readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
+        const member = callerMember(project, invocation.caller);
+        const execution = goalExecution(project.goal);
+        if (execution.leadMemberId === null) throw new Error(handbookMessage("noGoal"));
+        if (projectId === null || invocation.caller?.kind !== "thread" || member === void 0 || member.memberId !== execution.leadMemberId)
+          throw new Error(handbookMessage("leadOnly"));
+        const requestId = `team-handbook:${stableHash(JSON.stringify([projectId, input.requestId]))}`;
+        const current = await state.get();
+        const existing = readFact(current.intents, requestId);
+        const done2 = readFact(current.completed, requestId);
+        if (existing !== null) {
+          if (existing.op !== input.operation || existing.memberId !== member.memberId || (existing.requireAckChoice ?? false) !== (input.requireAck ?? false))
+            throw new Error(handbookMessage("requestConflict"));
+          if (done2?.outcome.status === "voided") throw new Error(handbookMessage("requestVoided"));
+        }
+        const requireAck = existing?.requiresAck ?? await publicationRequiresAck(ctx.memory, projectId, input);
+        const intent = existing ?? {
+          version: 1,
+          projectId,
+          memberId: member.memberId,
+          requestId,
+          op: input.operation,
+          requireAckChoice: input.requireAck ?? false,
+          requiresAck: requireAck
+        };
+        if (existing === null)
+          await append2(projectId, "handbook-publication-intended", requestId, intent);
+        let outcome;
+        let detail = null;
+        try {
+          const command = { ...input, projectId, requestId, requireAck };
+          const result2 = command.operation === "publish" ? await ctx.memory.handbook.publish(command) : await ctx.memory.handbook.revert(command);
+          await state.get({ throughSequence: result2.sequence });
+          outcome = { status: "succeeded", release: result2.result.release };
+        } catch (error) {
+          detail = terminalFailure(error);
+          if (detail === null) throw error;
+          outcome = { status: "rejected" };
+        }
+        if (done2 === null) await complete(intent, outcome);
+        await remind();
+        return detail === null ? outcome : { ...outcome, detail };
+      });
+    },
+    async check(input) {
+      const project = readFact(
+        (await state.get({ throughSequence: input.throughSequence })).projects,
+        input.projectId
+      );
+      if (project === null || project.requiredRelease === null) return { allowed: true };
+      for (const actor of input.added) {
+        const caller = actor.kind === "human" ? void 0 : actor.kind === "agent" ? { kind: "thread", threadId: actor.threadId } : actor;
+        const member = callerMember(project, caller);
+        if (member !== void 0 && !hasAcknowledged(project, member.memberId, project.requiredRelease)) {
+          return {
+            allowed: false,
+            detail: handbookMessage("guard", project.requiredRelease)
+          };
+        }
+      }
+      return { allowed: true };
+    }
+  };
+}
+
+// src/handbook/entry.ts
+var decodeAcknowledgement = decodeUnknownSync(AcknowledgeInput);
+var decodePublish = decodeUnknownSync(PublishInput);
+var decodeRevert = decodeUnknownSync(RevertInput);
+var decodeRead3 = decodeUnknownSync(ReadHandbookInput);
+var toolSchema = (schema) => ({
+  ...payloadSchemaOf(schema),
+  type: "object",
+  additionalProperties: false
+});
+var run2 = async (operation) => {
+  try {
+    const result2 = await operation();
+    const rejected = typeof result2 === "object" && result2 !== null && "status" in result2 && (result2.status === "rejected" || result2.status === "voided");
+    return { text: JSON.stringify(result2), ...rejected ? { isError: true } : {} };
+  } catch (error) {
+    return { text: error instanceof Error ? error.message : String(error), isError: true };
+  }
+};
+function registerHandbook(ctx, runtime) {
+  ctx.toolkit({
+    name: "handbook",
+    tools: [
+      {
+        name: "acknowledge_handbook",
+        remoteAvailable: true,
+        description: handbookMessage("ackTool"),
+        inputSchema: toolSchema(AcknowledgeInput),
+        handle: (input, invocation) => run2(() => runtime.ack(decodeAcknowledgement(input).release, invocation))
+      },
+      {
+        name: "publish_handbook",
+        description: handbookMessage("publishTool"),
+        inputSchema: toolSchema(PublishInput),
+        handle: (input, invocation) => run2(() => runtime.publish({ operation: "publish", ...decodePublish(input) }, invocation))
+      },
+      {
+        name: "revert_handbook",
+        description: handbookMessage("revertTool"),
+        inputSchema: toolSchema(RevertInput),
+        handle: (input, invocation) => run2(() => runtime.publish({ operation: "revert", ...decodeRevert(input) }, invocation))
+      }
+    ]
+  });
+  ctx.command({
+    name: "handbook",
+    scope: "read",
+    payloadSchema: payloadSchemaOf(ReadHandbookInput),
+    handle: (input) => runtime.read(decodeRead3(input).projectId)
+  });
+  ctx.operations.guard({ operations: ["work.assign"], check: runtime.check });
+}
+
 // src/index.ts
 var index_default = definePlugin({
   id: "team",
-  apiVersion: 12,
+  apiVersion: 13,
   activate(ctx) {
     const rosters = createRosterService(ctx);
     registerRosterCommands(ctx, rosters);
@@ -8177,6 +8965,7 @@ var index_default = definePlugin({
     registerBoardCommands(ctx, goals, rosters);
     registerDetailCommands(ctx);
     startWakeRuntime(ctx);
+    registerHandbook(ctx, startHandbookRuntime(ctx));
   }
 });
 export {