@ycodium-ai/plugin-team 0.2.3120 → 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,6 +6862,210 @@ 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.";
@@ -6880,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 |",
@@ -6995,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
       }))
@@ -7316,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",
@@ -7771,8 +7980,38 @@ 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";
@@ -7918,9 +8157,14 @@ 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 leadThreads = goal.threads.filter((thread) => thread.memberId === goal.leadMemberId).map((thread) => thread.threadId);
       const next2 = { ...project3, threads, leadThreads, remoteMembers };
@@ -8090,12 +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,
@@ -8115,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" ? wake.lead === true ? leadItemText : itemText : wake.lead === true ? leadUnblockedText : 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",
@@ -8175,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);
@@ -8187,6 +8965,7 @@ var index_default = definePlugin({
     registerBoardCommands(ctx, goals, rosters);
     registerDetailCommands(ctx);
     startWakeRuntime(ctx);
+    registerHandbook(ctx, startHandbookRuntime(ctx));
   }
 });
 export {