@ycodium-ai/plugin-team 0.2.3120 → 0.2.3130

package/dist/index.js

@@ -1,9 +1,6 @@
 // src/index.ts
 import { definePlugin } from "@ycodium-ai/plugin-api";
 
-// src/board.ts
-import * as NodeTimers from "node:timers";
-
 // ../../node_modules/.pnpm/effect@4.0.0-beta.103_patch_hash=78523ded7c3dfc3efd3cec0247f4960d00eaa3d3c96a2077457694a4d8b453c6/node_modules/effect/dist/Pipeable.js
 var pipeArguments = (self, args2) => {
   switch (args2.length) {
@@ -3511,9 +3508,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 +3667,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) {
@@ -3843,7 +3840,7 @@ function numberToJson(checks) {
   return new Link(new Union([encodedFinite, nonFiniteLiterals], "anyOf"), new Transformation(Number3(), transform((n) => globalThis.Number.isFinite(n) ? n : globalThis.String(n))));
 }
 var number2 = /* @__PURE__ */ new Number4();
-var Boolean = class extends Base2 {
+var Boolean2 = class extends Base2 {
   _tag = "Boolean";
   /** @internal */
   getParser() {
@@ -3854,7 +3851,7 @@ var Boolean = class extends Base2 {
     return "boolean";
   }
 };
-var boolean = /* @__PURE__ */ new Boolean();
+var boolean = /* @__PURE__ */ new Boolean2();
 var Arrays = class _Arrays extends Base2 {
   _tag = "Arrays";
   isMutable;
@@ -4635,9 +4632,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 +6196,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) {
@@ -6265,7 +6262,7 @@ var Null2 = /* @__PURE__ */ make8(null_);
 var Undefined2 = /* @__PURE__ */ make8(undefined_2);
 var String4 = /* @__PURE__ */ make8(string2);
 var Number5 = /* @__PURE__ */ make8(number2);
-var Boolean2 = /* @__PURE__ */ make8(boolean);
+var Boolean3 = /* @__PURE__ */ make8(boolean);
 function makeStruct(ast, fields) {
   return make8(ast, {
     fields,
@@ -6379,6 +6376,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 +6859,272 @@ 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}}"
+  },
+  handbookPanel: {
+    title: "Handbook",
+    open: "View handbook",
+    close: "Close handbook",
+    current: "Current version {{version}}",
+    required: "Version {{version}} currently requires acknowledgement",
+    noCurrent: "No handbook has been published",
+    noRequired: "No version has required acknowledgement",
+    handbook_decisions: "Decisions",
+    handbook_rules: "Rules",
+    handbook_progress: "Progress",
+    missingPage: "This page is absent from the current version",
+    erased: "Erased",
+    unavailable: "Content is unavailable",
+    uneditable: "This page cannot be edited because its content is erased or unavailable",
+    loading: "Loading handbook\u2026",
+    loadFailed: "Could not read the handbook. Reload to try again.",
+    reload: "Reload handbook",
+    moreBody: "Read more",
+    moreBodyFailed: "Couldn't load the rest of this page. Click Read more to try again.",
+    releases: "Version history",
+    noReleases: "No versions yet",
+    version: "Version {{version}}",
+    publishedBy: "Published by {{author}}",
+    requiresAck: "Acknowledgement required",
+    noAck: "Acknowledgement not required",
+    restoredFrom: "Restored from version {{version}}",
+    moreReleases: "Load older versions",
+    members: "Member acknowledgements",
+    noMembers: "No executing members yet. Start a goal to assign team seats.",
+    member: "Member {{id}}",
+    neverAck: "Has not acknowledged a version",
+    acked: "Acknowledged version {{version}}",
+    pendingAck: "Needs to acknowledge version {{version}}",
+    edit: "Edit handbook",
+    pageTitle: "{{page}} \u2014 title (optional)",
+    pageBody: "{{page}} \u2014 body",
+    pageSummary: "{{page}} \u2014 change summary (optional)",
+    ackChoice: "Require acknowledgement for changes to Decisions",
+    ackPolicy: "Rules changes always require acknowledgement; Progress-only changes don't; Decisions changes follow this choice.",
+    cancel: "Cancel",
+    publish: "Save and publish",
+    saved: "Handbook published",
+    conflict: "Someone else changed the handbook. Your edits are kept. Review the latest version shown below before saving again.",
+    failed: "Publishing did not finish. Click Save and publish again; as long as you don't change the edits, it counts as the same publication and won't publish twice.",
+    revert: "Revert to this version",
+    revertVersion: "Revert to version {{version}}",
+    revertTitle: "Revert handbook to version {{version}}?",
+    revertDescription: "Publish the content of version {{version}} as a new version, under your name. The current version remains in history.",
+    confirmRevert: "Revert and publish",
+    historyFailed: "Couldn't load the version history. Try again.",
+    emptyPages: "Once the handbook is published, its three pages show here.",
+    fieldTitle: "Title (optional)",
+    fieldBody: "Body",
+    fieldSummary: "Change summary (optional)",
+    currentBadge: "Current",
+    currentReadOnly: "Current handbook (read-only)",
+    discardTitle: "Discard your unsaved edits?",
+    discardDescription: "Your edits to the handbook pages will be lost.",
+    keepEditing: "Keep editing",
+    discard: "Discard edits"
+  },
+  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 +7144,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 +7260,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
       }))
@@ -7038,8 +7304,8 @@ function createGoalService(ctx, rosterService, options = {}) {
     });
     await goals.get({ throughSequence: receipt.sequence });
     goal = readFact(await requests.get({ throughSequence: receipt.sequence }), key) ?? goal;
-    const project = await ctx.projects.get({ projectId: goal.projectId });
-    const selection = await ctx.providers.resolveSelection({ base: project.defaultModelSelection });
+    const project2 = await ctx.projects.get({ projectId: goal.projectId });
+    const selection = await ctx.providers.resolveSelection({ base: project2.defaultModelSelection });
     const orderedThreads = [
       ...goal.threads.filter((thread) => thread.memberId === goal.leadMemberId),
       ...goal.threads.filter((thread) => thread.memberId !== goal.leadMemberId)
@@ -7101,16 +7367,32 @@ function createGoalService(ctx, rosterService, options = {}) {
 // src/commands.ts
 var decodeReadRoster = decodeUnknownSync(ReadRosterInput);
 var decodeReadGoal = decodeUnknownSync(ReadGoalInput);
-var mergeAllOf = (node) => {
-  if (Array.isArray(node)) return node.map(mergeAllOf);
+var commandSchema = (node) => {
+  if (Array.isArray(node)) return node.map(commandSchema);
   if (typeof node !== "object" || node === null) return node;
   const { allOf, ...rest } = node;
   const merged = Object.fromEntries(
-    Object.entries(rest).map(([key, value]) => [key, mergeAllOf(value)])
+    Object.entries(rest).map(([key, value]) => [key, commandSchema(value)])
   );
-  return Array.isArray(allOf) ? Object.assign(merged, ...allOf.map(mergeAllOf)) : merged;
+  if (Array.isArray(allOf)) Object.assign(merged, ...allOf.map(commandSchema));
+  if (!Array.isArray(merged.anyOf) || merged.anyOf.length !== 2) return merged;
+  const branches = merged.anyOf.filter(
+    (branch) => typeof branch === "object" && branch !== null
+  );
+  if (branches.length !== 2) return merged;
+  const base = branches.find((branch) => branch.type !== "null");
+  if (!branches.some((branch) => branch.type === "null") || base === void 0 || typeof base.type !== "string" || !["string", "number", "integer", "boolean"].includes(base.type))
+    return merged;
+  const { anyOf: _, ...common } = merged;
+  const { const: literal, ...constraints } = base;
+  return {
+    ...common,
+    ...constraints,
+    type: [base.type, "null"],
+    ...Object.hasOwn(base, "const") ? { enum: [literal, null] } : Array.isArray(base.enum) ? { enum: [...base.enum, null] } : {}
+  };
 };
-var payloadSchemaOf = (schema) => mergeAllOf(toJsonSchemaDocument2(schema).schema);
+var payloadSchemaOf = (schema) => commandSchema(toJsonSchemaDocument2(schema).schema);
 function registerRosterCommands(ctx, service2) {
   ctx.command({
     name: "roster",
@@ -7140,57 +7422,8 @@ function registerGoalCommands(ctx, service2) {
   });
 }
 
-// src/workReads.ts
-var PAGE_SIZE = 200;
-async function readPages(maximum, read, keep = "oldest") {
-  let items = [];
-  let truncated = false;
-  let cursor = null;
-  do {
-    const page = await read({ limit: PAGE_SIZE, ...cursor === null ? {} : { cursor } });
-    items.push(...page.items);
-    cursor = page.nextCursor;
-    if (keep === "oldest" && items.length >= maximum) {
-      return {
-        items: items.slice(0, maximum),
-        truncated: items.length > maximum || cursor !== null
-      };
-    }
-    if (items.length > maximum) {
-      truncated = true;
-      items = items.slice(-maximum);
-    }
-  } while (cursor !== null);
-  return { items, truncated };
-}
-
-// src/workWrites.ts
-var decodeWorkRefusal = decodeUnknownOption2(
-  Struct({
-    rejection: Struct({
-      code: String4,
-      details: optionalKey2(Unknown2)
-    })
-  })
-);
-var rejectWork = (commandType, code) => ({ _tag: "TeamBoardRejection", commandType, code });
-async function writeWork(invocation, commandType, write) {
-  if (invocation.asPerson === void 0) return rejectWork(commandType, "needs-person");
-  try {
-    return await write(invocation.asPerson.work);
-  } catch (error) {
-    const refusal = decodeWorkRefusal(error);
-    if (isNone2(refusal)) throw error;
-    const { code, details } = refusal.value.rejection;
-    return {
-      ...rejectWork(
-        commandType,
-        commandType !== "postComment" && code === "version-conflict" ? "stale-version" : code
-      ),
-      ...details === void 0 ? {} : { details }
-    };
-  }
-}
+// src/watch.ts
+import * as NodeTimers from "node:timers";
 
 // src/boardContracts.ts
 var BoardState = Struct({
@@ -7228,7 +7461,7 @@ var BoardRemoteWork = Struct({
   pending: NullOr(
     Struct({
       count: Number5,
-      items: ArraySchema(Struct({ workItemId: String4, blocked: Boolean2 }))
+      items: ArraySchema(Struct({ workItemId: String4, blocked: Boolean3 }))
     })
   )
 });
@@ -7254,8 +7487,8 @@ var BoardSnapshot = Struct({
   remoteWork: ArraySchema(BoardRemoteWork),
   viewerKey: optionalKey2(String4),
   // 负责人要用看板与项目记忆两组工具；开关由宿主控件拨，这里只读来提示。
-  toolkits: Struct({ board: Boolean2, memory: Boolean2 }),
-  truncated: Boolean2
+  toolkits: Struct({ board: Boolean3, memory: Boolean3 }),
+  truncated: Boolean3
 });
 var ReadBoardInput = Struct({ projectId: String4 });
 var CreateItemInput = Struct({
@@ -7271,7 +7504,7 @@ var UpdateItemInput = Struct({
   expectedVersion: Int.check(isGreaterThanOrEqualTo3(1)),
   stateId: optionalKey2(String4),
   assigneeThreadId: optionalKey2(String4),
-  unassign: optionalKey2(Boolean2)
+  unassign: optionalKey2(Boolean3)
 });
 var BoardRejection = Struct({
   _tag: Literal2("TeamBoardRejection"),
@@ -7288,18 +7521,14 @@ var UpdateItemResult = Union2([
   BoardRejection
 ]);
 
-// src/board.ts
-var ITEM_LIMIT = 500;
-var PEOPLE_LIMIT = 200;
-var REMOTE_AGENT_LIMIT = 1e3;
+// src/watch.ts
+var emptyChanges = () => ({ cursor: 0, handbookCursor: 0 });
 var decodeRead = decodeUnknownSync(ReadBoardInput);
-var decodeCreate = decodeUnknownOption2(CreateItemInput);
-var decodeUpdate = decodeUnknownOption2(UpdateItemInput);
 var decodeProject = decodeUnknownOption2(Struct({ projectId: String4 }));
 var decodeFact = decodeUnknownOption2(
   Struct({ pluginId: Literal2("team"), name: String4 })
 );
-var WORK_EVENTS = [
+var WORK_EVENTS = /* @__PURE__ */ new Set([
   "work.item-created",
   "work.item-updated",
   "work.item-claimed",
@@ -7307,22 +7536,168 @@ var WORK_EVENTS = [
   "work.relation-removed",
   "work.comment-posted",
   "work.states-seeded",
-  // 快照带看板与记忆两只开关的状态，拨一下就敲门。
   "board.toolkit-set",
   "memory.toolkit-set"
-];
-function registerBoardCommands(ctx, goals, rosters, options = {}) {
+]);
+var HANDBOOK_EVENTS = /* @__PURE__ */ new Set([
+  "wiki.handbook-released",
+  "wiki.page-erased",
+  "memory.toolkit-set"
+]);
+function registerTeamWatch(ctx, options) {
   const after = options.after ?? ((delay2, notify) => {
     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 listeners = /* @__PURE__ */ new Map();
+  const cursors = /* @__PURE__ */ new Map();
+  const timers = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const changed = (event, board, handbook) => {
+    const payload = decodeProject(event.payload);
+    const projectId = isSome2(payload) ? payload.value.projectId : event.aggregateKind === "project" ? event.aggregateId : null;
+    if (projectId === null || disposed || !listeners.has(projectId)) return;
+    const previous = cursors.get(projectId) ?? emptyChanges();
+    cursors.set(projectId, {
+      cursor: board ? Math.max(previous.cursor, event.sequence) : previous.cursor,
+      handbookCursor: handbook ? Math.max(previous.handbookCursor, event.sequence) : previous.handbookCursor
+    });
+    if (timers.has(projectId)) return;
+    timers.set(
+      projectId,
+      after(50, () => {
+        timers.delete(projectId);
+        for (const emit of [...listeners.get(projectId) ?? []])
+          emit(cursors.get(projectId) ?? emptyChanges());
+      })
+    );
+  };
+  const stops = [.../* @__PURE__ */ new Set([...WORK_EVENTS, ...HANDBOOK_EVENTS])].map(
+    (type) => ctx.events.onRaw(
+      type,
+      (event) => changed(event, WORK_EVENTS.has(type), HANDBOOK_EVENTS.has(type))
+    )
+  );
+  stops.push(
+    ctx.events.onRaw("plugin.event-appended", (event) => {
+      const fact = decodeFact(event.payload);
+      if (isNone2(fact)) return;
+      const name = fact.value.name;
+      const board = name === "team/goal-started" || name === "team/roster-set";
+      const handbook = name === "team/goal-started" || name === "team/handbook-acknowledged" || name === "team/handbook-publication-completed";
+      if (board || handbook) changed(event, board, handbook);
+    })
+  );
+  ctx.stream({
+    name: "watch",
+    scope: "read",
+    payloadSchema: payloadSchemaOf(ReadBoardInput),
+    buffer: { latest: 1 },
+    handle: async (payload, emit, signal) => {
+      if (signal.aborted || disposed) return;
+      const { projectId } = decodeRead(payload);
+      const subscribers = listeners.get(projectId) ?? /* @__PURE__ */ new Set();
+      const ring = (value) => {
+        if (!signal.aborted && !disposed) emit(value);
+      };
+      listeners.set(projectId, subscribers);
+      subscribers.add(ring);
+      try {
+        ring(cursors.get(projectId) ?? emptyChanges());
+        await new Promise((resolve2) => {
+          if (signal.aborted) resolve2();
+          else signal.addEventListener("abort", () => resolve2(), { once: true });
+        });
+      } finally {
+        subscribers.delete(ring);
+        if (subscribers.size === 0) {
+          listeners.delete(projectId);
+          timers.get(projectId)?.();
+          timers.delete(projectId);
+          cursors.delete(projectId);
+        }
+      }
+    }
+  });
+  ctx.onDispose(() => {
+    disposed = true;
+    for (const stop of stops) stop();
+    for (const cancel of timers.values()) cancel();
+    timers.clear();
+    listeners.clear();
+    cursors.clear();
+  });
+}
+
+// src/workReads.ts
+var PAGE_SIZE = 200;
+async function readPages(maximum, read, keep = "oldest") {
+  let items = [];
+  let truncated = false;
+  let cursor = null;
+  do {
+    const page = await read({ limit: PAGE_SIZE, ...cursor === null ? {} : { cursor } });
+    items.push(...page.items);
+    cursor = page.nextCursor;
+    if (keep === "oldest" && items.length >= maximum) {
+      return {
+        items: items.slice(0, maximum),
+        truncated: items.length > maximum || cursor !== null
+      };
+    }
+    if (items.length > maximum) {
+      truncated = true;
+      items = items.slice(-maximum);
+    }
+  } while (cursor !== null);
+  return { items, truncated };
+}
+
+// src/workWrites.ts
+var decodeHostRefusal = decodeUnknownOption2(
+  Struct({
+    rejection: Struct({
+      code: String4,
+      details: optionalKey2(Unknown2)
+    })
+  })
+);
+var rejectWork = (commandType, code) => ({ _tag: "TeamBoardRejection", commandType, code });
+async function writeWork(invocation, commandType, write) {
+  if (invocation.asPerson === void 0) return rejectWork(commandType, "needs-person");
+  try {
+    return await write(invocation.asPerson.work);
+  } catch (error) {
+    const refusal = decodeHostRefusal(error);
+    if (isNone2(refusal)) throw error;
+    const { code, details } = refusal.value.rejection;
+    return {
+      ...rejectWork(
+        commandType,
+        commandType !== "postComment" && code === "version-conflict" ? "stale-version" : code
+      ),
+      ...details === void 0 ? {} : { details }
+    };
+  }
+}
+
+// src/board.ts
+var ITEM_LIMIT = 500;
+var PEOPLE_LIMIT = 200;
+var REMOTE_AGENT_LIMIT = 1e3;
+var decodeRead2 = decodeUnknownSync(ReadBoardInput);
+var decodeCreate = decodeUnknownOption2(CreateItemInput);
+var decodeUpdate = decodeUnknownOption2(UpdateItemInput);
+function registerBoardCommands(ctx, goals, rosters, options = {}) {
+  const isMember2 = async (projectId, threadId) => goalExecution(await goals.read(projectId)).members.some(
+    (member) => "threadId" in member && member.threadId === threadId
+  );
   ctx.command({
     name: "board",
     scope: "read",
     payloadSchema: payloadSchemaOf(ReadBoardInput),
     handle: async (payload, invocation) => {
-      const { projectId } = decodeRead(payload);
+      const { projectId } = decodeRead2(payload);
       const [stateList, goal, roster, toolkitStates, people, remoteAgents, viewer] = await Promise.all([
         ctx.work.states.list({ projectId }),
         goals.read(projectId),
@@ -7447,74 +7822,7 @@ function registerBoardCommands(ctx, goals, rosters, options = {}) {
       return "code" in result2 ? result2 : { workItemId: result2.result.workItemId, version: result2.result.version };
     }
   });
-  const listeners = /* @__PURE__ */ new Map();
-  const cursors = /* @__PURE__ */ new Map();
-  const timers = /* @__PURE__ */ new Map();
-  let disposed = false;
-  const changed = (event) => {
-    const payload = decodeProject(event.payload);
-    const projectId = isSome2(payload) ? payload.value.projectId : event.aggregateKind === "project" ? event.aggregateId : null;
-    if (projectId === null || disposed || !listeners.has(projectId)) return;
-    cursors.set(projectId, Math.max(cursors.get(projectId) ?? 0, event.sequence));
-    if (timers.has(projectId)) return;
-    timers.set(
-      projectId,
-      after(50, () => {
-        timers.delete(projectId);
-        for (const emit of [...listeners.get(projectId) ?? []]) {
-          emit({ cursor: cursors.get(projectId) ?? 0 });
-        }
-      })
-    );
-  };
-  const stops = WORK_EVENTS.map((type) => ctx.events.onRaw(type, changed));
-  stops.push(
-    ctx.events.onRaw("plugin.event-appended", (event) => {
-      const fact = decodeFact(event.payload);
-      if (isSome2(fact) && ["team/goal-started", "team/roster-set"].includes(fact.value.name)) {
-        changed(event);
-      }
-    })
-  );
-  ctx.stream({
-    name: "watch",
-    scope: "read",
-    payloadSchema: payloadSchemaOf(ReadBoardInput),
-    buffer: { latest: 1 },
-    handle: async (payload, emit, signal) => {
-      if (signal.aborted || disposed) return;
-      const { projectId } = decodeRead(payload);
-      const subscribers = listeners.get(projectId) ?? /* @__PURE__ */ new Set();
-      const ring = (value) => {
-        if (!signal.aborted && !disposed) emit(value);
-      };
-      listeners.set(projectId, subscribers);
-      subscribers.add(ring);
-      try {
-        ring({ cursor: cursors.get(projectId) ?? 0 });
-        await new Promise((resolve2) => {
-          if (signal.aborted) resolve2();
-          else signal.addEventListener("abort", () => resolve2(), { once: true });
-        });
-      } finally {
-        subscribers.delete(ring);
-        if (subscribers.size === 0) {
-          listeners.delete(projectId);
-          timers.get(projectId)?.();
-          timers.delete(projectId);
-          cursors.delete(projectId);
-        }
-      }
-    }
-  });
-  ctx.onDispose(() => {
-    disposed = true;
-    for (const stop of stops) stop();
-    for (const cancel of timers.values()) cancel();
-    timers.clear();
-    listeners.clear();
-    cursors.clear();
-  });
+  registerTeamWatch(ctx, options);
 }
 
 // src/detailContracts.ts
@@ -7576,9 +7884,9 @@ var ItemDetailSnapshot = Struct({
   blockedBy: ArraySchema(Dependency),
   blocking: ArraySchema(Dependency),
   comments: ArraySchema(DetailComment),
-  commentsTruncated: Boolean2,
+  commentsTruncated: Boolean3,
   history: ArraySchema(DetailActivity),
-  historyTruncated: Boolean2
+  historyTruncated: Boolean3
 });
 var ReadItemDetailResult = NullOr(ItemDetailSnapshot);
 
@@ -7587,7 +7895,7 @@ var RELATION_LIMIT = 100;
 var COMMENT_LIMIT = 200;
 var HISTORY_LIMIT = 200;
 var GET_BATCH_SIZE = 50;
-var decodeRead2 = decodeUnknownSync(ReadItemDetailInput);
+var decodeRead3 = decodeUnknownSync(ReadItemDetailInput);
 var decodePost = decodeUnknownOption2(PostCommentInput);
 function registerDetailCommands(ctx) {
   ctx.command({
@@ -7595,7 +7903,7 @@ function registerDetailCommands(ctx) {
     scope: "read",
     payloadSchema: payloadSchemaOf(ReadItemDetailInput),
     handle: async (payload) => {
-      const { projectId, workItemId } = decodeRead2(payload);
+      const { projectId, workItemId } = decodeRead3(payload);
       const result2 = await ctx.work.items.get({ projectId, workItemIds: [workItemId] });
       const item = result2.items.find((row) => row.workItemId === workItemId);
       if (item === void 0) return null;
@@ -7771,8 +8079,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";
@@ -7806,14 +8144,14 @@ var emptyProject = () => ({
 });
 var itemWakeKey = (workItemId, threadId, generation) => generation === 0 ? `item:${workItemId}:${threadId}` : `item:${workItemId}:${threadId}#${generation}`;
 var unblockedWakeKey = (workItemId, threadId, generation) => `unblocked:${workItemId}:${threadId}#${generation}`;
-var hasOpenBlocker = (project, workItemId) => (readFact(project.blockers, workItemId) ?? []).some(
-  (blocker) => readFact(project.items, blocker)?.closed !== true
+var hasOpenBlocker = (project2, workItemId) => (readFact(project2.blockers, workItemId) ?? []).some(
+  (blocker) => readFact(project2.items, blocker)?.closed !== true
 );
-var markBlockedAfterClaim = (project, workItemId) => ({
-  ...project,
+var markBlockedAfterClaim = (project2, workItemId) => ({
+  ...project2,
   blockedAfterClaim: {
-    ...project.blockedAfterClaim,
-    [workItemId]: (readFact(project.blockedAfterClaim, workItemId) ?? 0) + 1
+    ...project2.blockedAfterClaim,
+    [workItemId]: (readFact(project2.blockedAfterClaim, workItemId) ?? 0) + 1
   }
 });
 var decodeEnvelope2 = decodeUnknownOption2(
@@ -7898,8 +8236,8 @@ var decodeWorkEvent = decodeUnknownOption2(
 var agentThreads = (principals) => [
   ...new Set(principals.flatMap((p) => p.kind === "agent" ? [p.threadId] : []))
 ];
-var isMember = (project, recipient) => "threadId" in recipient ? project.threads.includes(recipient.threadId) : project.remoteMembers.includes(recipient.principalId);
-var commentRecipients = (project, actor, people) => {
+var isMember = (project2, recipient) => "threadId" in recipient ? project2.threads.includes(recipient.threadId) : project2.remoteMembers.includes(recipient.principalId);
+var commentRecipients = (project2, actor, people) => {
   const recipients = /* @__PURE__ */ new Map();
   for (const person of people) {
     if (person.kind === "agent" && !(actor.kind === "agent" && actor.threadId === person.threadId))
@@ -7907,7 +8245,7 @@ var commentRecipients = (project, actor, people) => {
     if (person.kind === "remote-agent" && !(actor.kind === "remote-agent" && actor.principalId === person.principalId))
       recipients.set(`principal:${person.principalId}`, { principalId: person.principalId });
   }
-  return [...recipients.values()].filter((recipient) => isMember(project, recipient));
+  return [...recipients.values()].filter((recipient) => isMember(project2, recipient));
 };
 var commentWakeKey = (commentId, recipient) => "threadId" in recipient ? `comment:${commentId}:${recipient.threadId}` : `comment:${commentId}:principal:${recipient.principalId}`;
 function foldWakes(state, event) {
@@ -7917,48 +8255,53 @@ function foldWakes(state, event) {
     const fact = decoded2.value;
     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 project4 = readFact(state, goal.projectId) ?? emptyProject();
+      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 };
+      const next2 = { ...project4, threads, leadThreads, remoteMembers };
       return {
         ...state,
         [goal.projectId]: {
           ...next2,
-          pendingComments: project3.pendingComments.filter((comment) => isMember(next2, comment))
+          pendingComments: project4.pendingComments.filter((comment) => isMember(next2, comment))
         }
       };
     }
     const { projectId: projectId2, key } = fact.data;
-    const project2 = readFact(state, projectId2) ?? emptyProject();
-    if (project2.pendingComments.some((comment) => comment.key === key)) {
+    const project3 = readFact(state, projectId2) ?? emptyProject();
+    if (project3.pendingComments.some((comment) => comment.key === key)) {
       return {
         ...state,
         [projectId2]: {
-          ...project2,
-          pendingComments: project2.pendingComments.filter((comment) => comment.key !== key)
+          ...project3,
+          pendingComments: project3.pendingComments.filter((comment) => comment.key !== key)
         }
       };
     }
-    if (project2.woken.includes(key)) return state;
-    return { ...state, [projectId2]: { ...project2, woken: [...project2.woken, key] } };
+    if (project3.woken.includes(key)) return state;
+    return { ...state, [projectId2]: { ...project3, woken: [...project3.woken, key] } };
   }
   const decoded = decodeWorkEvent(event);
   if (isNone2(decoded)) return state;
   const work = decoded.value;
   const { projectId, workItemId } = work.payload;
-  const project = readFact(state, projectId) ?? emptyProject();
-  const currentItem = readFact(project.items, workItemId);
-  let next = project;
+  const project2 = readFact(state, projectId) ?? emptyProject();
+  const currentItem = readFact(project2.items, workItemId);
+  let next = project2;
   switch (work.type) {
     case "work.item-created":
       next = {
-        ...project,
+        ...project2,
         items: {
-          ...project.items,
+          ...project2.items,
           [workItemId]: {
             sequenceId: work.payload.sequenceId,
             assigneeThreads: agentThreads(work.payload.assignees),
@@ -7978,9 +8321,9 @@ function foldWakes(state, event) {
         ])
       ];
       next = {
-        ...project,
+        ...project2,
         items: {
-          ...project.items,
+          ...project2.items,
           [workItemId]: {
             ...currentItem,
             assigneeThreads,
@@ -7996,18 +8339,18 @@ function foldWakes(state, event) {
     case "work.relation-added":
     case "work.relation-removed": {
       if (work.payload.relationKind !== "blocked_by") return state;
-      const blockers = readFact(project.blockers, workItemId) ?? [];
+      const blockers = readFact(project2.blockers, workItemId) ?? [];
       const related = work.payload.relatedWorkItemId;
       next = {
-        ...project,
+        ...project2,
         blockers: {
-          ...project.blockers,
+          ...project2.blockers,
           [workItemId]: work.type === "work.relation-added" ? [.../* @__PURE__ */ new Set([...blockers, related])] : blockers.filter((blocker) => blocker !== related)
         }
       };
-      if (work.type === "work.relation-added" && currentItem !== null && readFact(project.items, related)?.closed !== true) {
-        const woken = new Set(project.woken);
-        const rearms = { ...project.rearms };
+      if (work.type === "work.relation-added" && currentItem !== null && readFact(project2.items, related)?.closed !== true) {
+        const woken = new Set(project2.woken);
+        const rearms = { ...project2.rearms };
         for (const threadId of currentItem.assigneeThreads) {
           if (currentItem.claimedBy.includes(threadId)) continue;
           const generation = rearms[`${workItemId}:${threadId}`] ?? 0;
@@ -8015,14 +8358,14 @@ function foldWakes(state, event) {
             rearms[`${workItemId}:${threadId}`] = generation + 1;
         }
         next = { ...next, rearms };
-        if (currentItem.claimedBy.length > 0 && !hasOpenBlocker(project, workItemId))
+        if (currentItem.claimedBy.length > 0 && !hasOpenBlocker(project2, workItemId))
           next = markBlockedAfterClaim(next, workItemId);
       }
       break;
     }
     case "work.comment-posted": {
       const { actor, parentAuthor, mentions, commentId } = work.payload;
-      const comments = commentRecipients(project, actor, [
+      const comments = commentRecipients(project2, actor, [
         ...parentAuthor === void 0 ? [] : [parentAuthor],
         ...mentions
       ]).map((recipient) => ({
@@ -8032,10 +8375,10 @@ function foldWakes(state, event) {
         workItemId,
         commentId
       })).filter(
-        (comment) => !project.pendingComments.some((pending) => pending.key === comment.key)
+        (comment) => !project2.pendingComments.some((pending) => pending.key === comment.key)
       );
       if (comments.length === 0) return state;
-      next = { ...project, pendingComments: [...project.pendingComments, ...comments] };
+      next = { ...project2, pendingComments: [...project2.pendingComments, ...comments] };
       break;
     }
   }
@@ -8044,13 +8387,13 @@ function foldWakes(state, event) {
 var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 function dueWakes(state) {
   const due = [];
-  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;
+  for (const [projectId, project2] of Object.entries(state)) {
+    const woken = new Set(project2.woken);
+    const threads = new Set(project2.threads);
+    const leads = new Set(project2.leadThreads ?? []);
+    for (const [workItemId, item] of Object.entries(project2.items)) {
+      if (item.closed || hasOpenBlocker(project2, workItemId)) continue;
+      const unblocked = readFact(project2.blockedAfterClaim, workItemId) ?? 0;
       const recipients = /* @__PURE__ */ new Set([
         ...item.assigneeThreads,
         ...unblocked > 0 ? item.claimedBy : []
@@ -8061,7 +8404,7 @@ function dueWakes(state) {
         const key = finishing ? unblockedWakeKey(workItemId, threadId, unblocked) : itemWakeKey(
           workItemId,
           threadId,
-          readFact(project.rearms, `${workItemId}:${threadId}`) ?? 0
+          readFact(project2.rearms, `${workItemId}:${threadId}`) ?? 0
         );
         if (woken.has(key)) continue;
         due.push({
@@ -8075,8 +8418,8 @@ function dueWakes(state) {
         });
       }
     }
-    for (const comment of project.pendingComments) {
-      const item = readFact(project.items, comment.workItemId);
+    for (const comment of project2.pendingComments) {
+      const item = readFact(project2.items, comment.workItemId);
       due.push({
         ...comment,
         kind: "comment",
@@ -8090,12 +8433,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 +8457,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 +8500,707 @@ 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 HandbookPageKind = Literals([
+  "handbook_decisions",
+  "handbook_rules",
+  "handbook_progress"
+]);
+var Page = Struct({
+  kind: HandbookPageKind,
+  baseRevision: NullOr(Finite),
+  title: optionalKey2(String4),
+  body: String4,
+  changeSummary: optionalKey2(String4)
+});
+var WriteFields = {
+  requestId: String4,
+  expectedRelease: Finite,
+  requireAck: optionalKey2(Boolean3)
+};
+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(Boolean3),
+  requiresAck: optionalKey2(Boolean3)
+});
+var PublicationCompleted = Struct({
+  version: Literal2(1),
+  projectId: String4,
+  requestId: String4,
+  producedRelease: optionalKey2(Boolean3),
+  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_EVENTS2 = ["plugin.event-appended", "wiki.handbook-released"];
+var emptyHandbookState = () => ({
+  projects: {},
+  intents: {},
+  completed: {},
+  publishers: {},
+  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: Boolean3
+  })
+);
+function callerMember(project2, caller) {
+  if (caller === void 0) return void 0;
+  return goalExecution(project2.goal).members.find(
+    (member) => caller.kind === "thread" ? "threadId" in member && member.threadId === caller.threadId : "principalId" in member && member.principalId === caller.principalId
+  );
+}
+var hasAcknowledged = (project2, memberId, release) => readFact(readFact(project2.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 project3 = readFact(state.projects, fact2.projectId) ?? emptyHandbookProject();
+    const pendingReminders = { ...state.pendingReminders };
+    if (fact2.requiresAck)
+      for (const { memberId, ...recipient } of goalExecution(project3.goal).members) {
+        const key = reminderKey(fact2.projectId, fact2.release, memberId);
+        if (readFact(project3.reminded, key) === null)
+          pendingReminders[key] = {
+            projectId: fact2.projectId,
+            release: fact2.release,
+            member: { memberId, recipient }
+          };
+      }
+    return {
+      ...state,
+      pendingReminders,
+      projects: {
+        ...state.projects,
+        [fact2.projectId]: {
+          ...project3,
+          currentRelease: fact2.release,
+          requiredRelease: fact2.requiresAck ? fact2.release : project3.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 project2 = readFact(state.projects, projectId) ?? emptyHandbookProject();
+  let next = project2;
+  switch (fact.name) {
+    case "team/goal-started":
+      next = { ...project2, goal: fact.data.goal };
+      break;
+    case "team/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 publishers = state.publishers;
+      if (intent !== null && completed.producedRelease === true && completed.outcome.status === "succeeded") {
+        const releases = readFact(publishers ?? {}, projectId) ?? {};
+        const release = String(completed.outcome.release);
+        if (readFact(releases, release) === null)
+          publishers = {
+            ...publishers,
+            [projectId]: { ...releases, [release]: intent.memberId }
+          };
+      }
+      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(project2, intent.memberId, release))
+          pendingAcknowledgements = {
+            ...pendingAcknowledgements,
+            [key]: { version: 1, projectId, release, memberId: intent.memberId }
+          };
+      }
+      return {
+        ...state,
+        completed: { ...state.completed, [completed.requestId]: completed },
+        ...publishers === void 0 ? {} : { publishers },
+        pendingPublications: without(state.pendingPublications, completed.requestId),
+        pendingAcknowledgements,
+        pendingReminders
+      };
+    }
+    case "team/handbook-acknowledged": {
+      const { memberId, release } = fact.data;
+      if (hasAcknowledged(project2, memberId, release)) return state;
+      const previous = readFact(project2.acknowledgements, memberId);
+      next = {
+        ...project2,
+        acknowledgements: {
+          ...project2.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(project2.reminded, key) !== null) return state;
+      next = { ...project2, reminded: { ...project2.reminded, [key]: true } };
+      return {
+        ...state,
+        pendingReminders: without(state.pendingReminders, key),
+        projects: { ...state.projects, [projectId]: next }
+      };
+    }
+  }
+  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: 5,
+    events: HANDBOOK_EVENTS2,
+    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 project2 = readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
+    if (hasAcknowledged(project2, memberId, release)) return;
+    await append2(
+      projectId,
+      "handbook-acknowledged",
+      JSON.stringify([projectId, release, memberId]),
+      {
+        version: 1,
+        projectId,
+        release,
+        memberId
+      }
+    );
+  };
+  const complete = async (intent, outcome, producedRelease) => {
+    await append2(intent.projectId, "handbook-publication-completed", intent.requestId, {
+      version: 1,
+      requestId: intent.requestId,
+      projectId: intent.projectId,
+      outcome,
+      ...producedRelease === void 0 ? {} : { producedRelease }
+    });
+    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 },
+      "changed" in result2 && result2.changed === true
+    );
+  };
+  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_EVENTS2, 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 publisherMembers(projectId, releases) {
+      const snapshot = await state.get();
+      const publishers = readFact(snapshot.publishers ?? {}, projectId) ?? {};
+      return releases.flatMap((release) => {
+        const memberId = readFact(publishers, String(release));
+        return memberId === null ? [] : [{ release, memberId }];
+      });
+    },
+    async read(projectId) {
+      const project2 = readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
+      return {
+        currentRelease: project2.currentRelease,
+        requiredRelease: project2.requiredRelease,
+        members: goalExecution(project2.goal).members.map(({ memberId }) => ({
+          memberId,
+          acknowledgedRelease: readFact(project2.acknowledgements, memberId)?.latestRelease ?? null,
+          acknowledgedRequiredRelease: project2.requiredRelease === null || hasAcknowledged(project2, memberId, project2.requiredRelease)
+        }))
+      };
+    },
+    ack(release, invocation) {
+      return serial(async () => {
+        const projectId = invocation.projectId;
+        const project2 = projectId === null ? emptyHandbookProject() : readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
+        const member = callerMember(project2, invocation.caller);
+        if (member === void 0 || projectId === null)
+          throw new Error(handbookMessage("unknownMember"));
+        if (project2.requiredRelease === null) throw new Error(handbookMessage("noRequirement"));
+        if (release !== project2.requiredRelease)
+          throw new Error(handbookMessage("wrongRelease", project2.requiredRelease));
+        await acknowledge(projectId, release, member.memberId);
+        return { release, memberId: member.memberId };
+      });
+    },
+    publish(input, invocation) {
+      return serial(async () => {
+        const projectId = invocation.projectId;
+        const project2 = projectId === null ? emptyHandbookProject() : readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
+        const member = callerMember(project2, invocation.caller);
+        const execution = goalExecution(project2.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 producedRelease;
+        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 };
+          producedRelease = result2.result.changed;
+        } catch (error) {
+          detail = terminalFailure(error);
+          if (detail === null) throw error;
+          outcome = { status: "rejected" };
+        }
+        if (done2 === null) await complete(intent, outcome, producedRelease);
+        await remind();
+        return detail === null ? outcome : { ...outcome, detail };
+      });
+    },
+    async check(input) {
+      const project2 = readFact(
+        (await state.get({ throughSequence: input.throughSequence })).projects,
+        input.projectId
+      );
+      if (project2 === null || project2.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(project2, caller);
+        if (member !== void 0 && !hasAcknowledged(project2, member.memberId, project2.requiredRelease)) {
+          return {
+            allowed: false,
+            detail: handbookMessage("guard", project2.requiredRelease)
+          };
+        }
+      }
+      return { allowed: true };
+    }
+  };
+}
+
+// src/handbook/entry.ts
+var decodeAcknowledgement = decodeUnknownSync(AcknowledgeInput);
+var decodePublish = decodeUnknownSync(PublishInput);
+var decodeRevert = decodeUnknownSync(RevertInput);
+var decodeRead4 = 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(decodeRead4(input).projectId)
+  });
+  ctx.operations.guard({ operations: ["work.assign"], check: runtime.check });
+}
+
+// src/handbook/panelContracts.ts
+var project = { projectId: String4 };
+var ReadPanelInput = Struct(project);
+var ReadReleasesInput = Struct({
+  ...project,
+  cursor: optionalKey2(String4)
+});
+var ReadPageInput = Struct({
+  ...project,
+  pageId: String4,
+  revision: Int,
+  textOffset: optionalKey2(Int)
+});
+var PublishPanelInput = Struct({ ...project, ...PublishInput.fields });
+var RevertPanelInput = Struct({ ...project, ...RevertInput.fields });
+var HandbookWriteResult = Union2([
+  Struct({ status: Literal2("succeeded"), release: Int }),
+  Struct({ status: Literal2("rejected"), code: String4, detail: String4 })
+]);
+
+// src/handbook/panel.ts
+var decodePanel = decodeUnknownSync(ReadPanelInput);
+var decodeList = decodeUnknownSync(ReadReleasesInput);
+var decodePage = decodeUnknownSync(ReadPageInput);
+var decodePublish2 = decodeUnknownSync(PublishPanelInput);
+var decodeRevert2 = decodeUnknownSync(RevertPanelInput);
+function registerHandbookPanel(ctx, runtime) {
+  ctx.command({
+    name: "handbookPanel",
+    scope: "read",
+    payloadSchema: payloadSchemaOf(ReadPanelInput),
+    handle: async (payload, invocation) => {
+      const input = decodePanel(payload);
+      const [result2, status] = await Promise.all([
+        ctx.memory.handbook.get(input),
+        runtime.read(input.projectId)
+      ]);
+      return { head: result2.head, status, canOperate: invocation.scope === "operate" };
+    }
+  });
+  ctx.command({
+    name: "handbookReleases",
+    scope: "read",
+    payloadSchema: payloadSchemaOf(ReadReleasesInput),
+    handle: async (payload) => {
+      const input = decodeList(payload);
+      const result2 = await ctx.memory.handbook.releases.list({ ...input, limit: 20 });
+      const publishers = await runtime.publisherMembers(
+        input.projectId,
+        result2.items.map((row) => row.release)
+      );
+      return {
+        ...result2,
+        items: result2.items.map((row) => ({
+          ...row,
+          publisherMemberId: row.publishedBy.kind === "plugin" && row.publishedBy.pluginId === "team" ? publishers.find((publisher) => publisher.release === row.release)?.memberId ?? null : null
+        }))
+      };
+    }
+  });
+  ctx.command({
+    name: "handbookPage",
+    scope: "read",
+    payloadSchema: payloadSchemaOf(ReadPageInput),
+    handle: (payload) => ctx.memory.pageRevisions.get(decodePage(payload))
+  });
+  const write = async (input, invocation) => {
+    if (invocation.scope !== "operate" || invocation.asPerson === void 0)
+      return { status: "rejected", code: "needs-person", detail: "needs-person" };
+    try {
+      const requireAck = await publicationRequiresAck(ctx.memory, input.projectId, input);
+      const handbook = invocation.asPerson.memory.handbook;
+      const command = {
+        projectId: input.projectId,
+        requestId: input.requestId,
+        expectedRelease: input.expectedRelease,
+        requireAck
+      };
+      const result2 = input.operation === "publish" ? await handbook.publish({
+        ...command,
+        pages: input.pages,
+        ...input.sourceExperience === void 0 ? {} : { sourceExperience: input.sourceExperience }
+      }) : await handbook.revert({ ...command, toRelease: input.toRelease });
+      return { status: "succeeded", release: result2.result.release };
+    } catch (error) {
+      const refusal = decodeHostRefusal(error);
+      if (isNone2(refusal)) throw error;
+      const { code, details } = refusal.value.rejection;
+      return {
+        status: "rejected",
+        code,
+        detail: [
+          error instanceof Error ? error.message : code,
+          details === void 0 ? null : JSON.stringify(details)
+        ].filter(Boolean).join("\n")
+      };
+    }
+  };
+  ctx.command({
+    name: "publishHandbook",
+    scope: "operate",
+    payloadSchema: payloadSchemaOf(PublishPanelInput),
+    handle: (payload, invocation) => write({ ...decodePublish2(payload), operation: "publish" }, invocation)
+  });
+  ctx.command({
+    name: "revertHandbook",
+    scope: "operate",
+    payloadSchema: payloadSchemaOf(RevertPanelInput),
+    handle: (payload, invocation) => write({ ...decodeRevert2(payload), operation: "revert" }, invocation)
+  });
+}
+
 // src/index.ts
 var index_default = definePlugin({
   id: "team",
-  apiVersion: 12,
+  apiVersion: 14,
   activate(ctx) {
     const rosters = createRosterService(ctx);
     registerRosterCommands(ctx, rosters);
@@ -8187,6 +9209,9 @@ var index_default = definePlugin({
     registerBoardCommands(ctx, goals, rosters);
     registerDetailCommands(ctx);
     startWakeRuntime(ctx);
+    const handbook = startHandbookRuntime(ctx);
+    registerHandbook(ctx, handbook);
+    registerHandbookPanel(ctx, handbook);
   }
 });
 export {