@ycodium-ai/plugin-team 0.2.3122 → 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) {
@@ -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;
@@ -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,
@@ -7045,6 +7042,68 @@ var en_default = {
     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.",
@@ -7245,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)
@@ -7308,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",
@@ -7347,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({
@@ -7435,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 }))
     })
   )
 });
@@ -7461,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({
@@ -7478,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"),
@@ -7495,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",
@@ -7514,15 +7536,159 @@ 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 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
   );
@@ -7531,7 +7697,7 @@ function registerBoardCommands(ctx, goals, rosters, options = {}) {
     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),
@@ -7656,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
@@ -7785,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);
 
@@ -7796,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({
@@ -7804,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;
@@ -8045,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(
@@ -8137,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))
@@ -8146,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) {
@@ -8156,7 +8255,7 @@ 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 project4 = readFact(state, goal.projectId) ?? emptyProject();
       const { members } = goalExecution(goal);
       const threads = [
         ...new Set(members.flatMap((member) => "threadId" in member ? [member.threadId] : []))
@@ -8167,42 +8266,42 @@ function foldWakes(state, event) {
         )
       ];
       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),
@@ -8222,9 +8321,9 @@ function foldWakes(state, event) {
         ])
       ];
       next = {
-        ...project,
+        ...project2,
         items: {
-          ...project.items,
+          ...project2.items,
           [workItemId]: {
             ...currentItem,
             assigneeThreads,
@@ -8240,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;
@@ -8259,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) => ({
@@ -8276,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;
     }
   }
@@ -8288,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 : []
@@ -8305,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({
@@ -8319,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",
@@ -8453,8 +8552,13 @@ async function publicationRequiresAck(memory, projectId, input) {
 
 // src/handbook/contracts.ts
 var Release = Int.check(isGreaterThanOrEqualTo3(1));
+var HandbookPageKind = Literals([
+  "handbook_decisions",
+  "handbook_rules",
+  "handbook_progress"
+]);
 var Page = Struct({
-  kind: Literals(["handbook_decisions", "handbook_rules", "handbook_progress"]),
+  kind: HandbookPageKind,
   baseRevision: NullOr(Finite),
   title: optionalKey2(String4),
   body: String4,
@@ -8463,7 +8567,7 @@ var Page = Struct({
 var WriteFields = {
   requestId: String4,
   expectedRelease: Finite,
-  requireAck: optionalKey2(Boolean2)
+  requireAck: optionalKey2(Boolean3)
 };
 var PublishInput = Struct({
   ...WriteFields,
@@ -8481,13 +8585,14 @@ var PublicationIntent = Struct({
   memberId: String4,
   requestId: String4,
   op: Literals(["publish", "revert"]),
-  requireAckChoice: optionalKey2(Boolean2),
-  requiresAck: optionalKey2(Boolean2)
+  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") }),
@@ -8505,11 +8610,12 @@ var ReminderSent = Struct({
 });
 
 // src/handbook/state.ts
-var HANDBOOK_EVENTS = ["plugin.event-appended", "wiki.handbook-released"];
+var HANDBOOK_EVENTS2 = ["plugin.event-appended", "wiki.handbook-released"];
 var emptyHandbookState = () => ({
   projects: {},
   intents: {},
   completed: {},
+  publishers: {},
   pendingPublications: {},
   pendingAcknowledgements: {},
   pendingReminders: {}
@@ -8535,16 +8641,16 @@ var decodeRelease = decodeUnknownSync(
   Struct({
     projectId: String4,
     release: Number5,
-    requiresAck: Boolean2
+    requiresAck: Boolean3
   })
 );
-function callerMember(project, caller) {
+function callerMember(project2, caller) {
   if (caller === void 0) return void 0;
-  return goalExecution(project.goal).members.find(
+  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 = (project, memberId, release) => readFact(readFact(project.acknowledgements, memberId)?.releases ?? {}, String(release)) === true;
+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;
@@ -8555,12 +8661,12 @@ var without = (rows, key) => {
 function foldHandbook(state, event) {
   if (event.type === "wiki.handbook-released") {
     const fact2 = decodeRelease(event.payload);
-    const project2 = readFact(state.projects, fact2.projectId) ?? emptyHandbookProject();
+    const project3 = readFact(state.projects, fact2.projectId) ?? emptyHandbookProject();
     const pendingReminders = { ...state.pendingReminders };
     if (fact2.requiresAck)
-      for (const { memberId, ...recipient } of goalExecution(project2.goal).members) {
+      for (const { memberId, ...recipient } of goalExecution(project3.goal).members) {
         const key = reminderKey(fact2.projectId, fact2.release, memberId);
-        if (readFact(project2.reminded, key) === null)
+        if (readFact(project3.reminded, key) === null)
           pendingReminders[key] = {
             projectId: fact2.projectId,
             release: fact2.release,
@@ -8573,9 +8679,9 @@ function foldHandbook(state, event) {
       projects: {
         ...state.projects,
         [fact2.projectId]: {
-          ...project2,
+          ...project3,
           currentRelease: fact2.release,
-          requiredRelease: fact2.requiresAck ? fact2.release : project2.requiredRelease
+          requiredRelease: fact2.requiresAck ? fact2.release : project3.requiredRelease
         }
       }
     };
@@ -8585,11 +8691,11 @@ function foldHandbook(state, event) {
   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;
+  const project2 = readFact(state.projects, projectId) ?? emptyHandbookProject();
+  let next = project2;
   switch (fact.name) {
     case "team/goal-started":
-      next = { ...project, goal: fact.data.goal };
+      next = { ...project2, goal: fact.data.goal };
       break;
     case "team/handbook-publication-intended": {
       const intent = fact.data;
@@ -8604,13 +8710,23 @@ function foldHandbook(state, event) {
       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(project, intent.memberId, release))
+        if (!hasAcknowledged(project2, intent.memberId, release))
           pendingAcknowledgements = {
             ...pendingAcknowledgements,
             [key]: { version: 1, projectId, release, memberId: intent.memberId }
@@ -8619,6 +8735,7 @@ function foldHandbook(state, event) {
       return {
         ...state,
         completed: { ...state.completed, [completed.requestId]: completed },
+        ...publishers === void 0 ? {} : { publishers },
         pendingPublications: without(state.pendingPublications, completed.requestId),
         pendingAcknowledgements,
         pendingReminders
@@ -8626,12 +8743,12 @@ function foldHandbook(state, event) {
     }
     case "team/handbook-acknowledged": {
       const { memberId, release } = fact.data;
-      if (hasAcknowledged(project, memberId, release)) return state;
-      const previous = readFact(project.acknowledgements, memberId);
+      if (hasAcknowledged(project2, memberId, release)) return state;
+      const previous = readFact(project2.acknowledgements, memberId);
       next = {
-        ...project,
+        ...project2,
         acknowledgements: {
-          ...project.acknowledgements,
+          ...project2.acknowledgements,
           [memberId]: {
             releases: { ...previous?.releases, [release]: true },
             latestRelease: Math.max(previous?.latestRelease ?? 0, release)
@@ -8649,8 +8766,8 @@ function foldHandbook(state, event) {
     }
     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 } };
+      if (readFact(project2.reminded, key) !== null) return state;
+      next = { ...project2, reminded: { ...project2.reminded, [key]: true } };
       return {
         ...state,
         pendingReminders: without(state.pendingReminders, key),
@@ -8675,8 +8792,8 @@ var terminalFailure = (error) => {
 function startHandbookRuntime(ctx) {
   const state = ctx.derivedState({
     key: "handbook",
-    version: 4,
-    events: HANDBOOK_EVENTS,
+    version: 5,
+    events: HANDBOOK_EVENTS2,
     init: emptyHandbookState,
     apply: foldHandbook
   });
@@ -8703,8 +8820,8 @@ function startHandbookRuntime(ctx) {
     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;
+    const project2 = readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
+    if (hasAcknowledged(project2, memberId, release)) return;
     await append2(
       projectId,
       "handbook-acknowledged",
@@ -8717,12 +8834,13 @@ function startHandbookRuntime(ctx) {
       }
     );
   };
-  const complete = async (intent, outcome) => {
+  const complete = async (intent, outcome, producedRelease) => {
     await append2(intent.projectId, "handbook-publication-completed", intent.requestId, {
       version: 1,
       requestId: intent.requestId,
       projectId: intent.projectId,
-      outcome
+      outcome,
+      ...producedRelease === void 0 ? {} : { producedRelease }
     });
     if (outcome.status === "succeeded" && intent.requiresAck) {
       await acknowledge(intent.projectId, outcome.release, intent.memberId);
@@ -8742,7 +8860,11 @@ function startHandbookRuntime(ctx) {
     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 });
+    return complete(
+      intent,
+      { status: "succeeded", release: result2.release },
+      "changed" in result2 && result2.changed === true
+    );
   };
   const remind = async () => {
     const snapshot = await state.get();
@@ -8796,7 +8918,7 @@ function startHandbookRuntime(ctx) {
     await remind();
   };
   const flush = () => serial(execute);
-  ctx.reactor({ name: "team-handbook", events: HANDBOOK_EVENTS, handle: () => flush() });
+  ctx.reactor({ name: "team-handbook", events: HANDBOOK_EVENTS2, handle: () => flush() });
   ctx.onDispose(async () => {
     disposed = true;
     await pending;
@@ -8806,28 +8928,36 @@ function startHandbookRuntime(ctx) {
   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 project = readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
+      const project2 = readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
       return {
-        currentRelease: project.currentRelease,
-        requiredRelease: project.requiredRelease,
-        members: goalExecution(project.goal).members.map(({ memberId }) => ({
+        currentRelease: project2.currentRelease,
+        requiredRelease: project2.requiredRelease,
+        members: goalExecution(project2.goal).members.map(({ memberId }) => ({
           memberId,
-          acknowledgedRelease: readFact(project.acknowledgements, memberId)?.latestRelease ?? null,
-          acknowledgedRequiredRelease: project.requiredRelease === null || hasAcknowledged(project, memberId, project.requiredRelease)
+          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 project = projectId === null ? emptyHandbookProject() : readFact((await state.get()).projects, projectId) ?? emptyHandbookProject();
-        const member = callerMember(project, invocation.caller);
+        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 (project.requiredRelease === null) throw new Error(handbookMessage("noRequirement"));
-        if (release !== project.requiredRelease)
-          throw new Error(handbookMessage("wrongRelease", project.requiredRelease));
+        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 };
       });
@@ -8835,9 +8965,9 @@ function startHandbookRuntime(ctx) {
     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);
+        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"));
@@ -8863,35 +8993,37 @@ function startHandbookRuntime(ctx) {
         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);
+        if (done2 === null) await complete(intent, outcome, producedRelease);
         await remind();
         return detail === null ? outcome : { ...outcome, detail };
       });
     },
     async check(input) {
-      const project = readFact(
+      const project2 = readFact(
         (await state.get({ throughSequence: input.throughSequence })).projects,
         input.projectId
       );
-      if (project === null || project.requiredRelease === null) return { allowed: true };
+      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(project, caller);
-        if (member !== void 0 && !hasAcknowledged(project, member.memberId, project.requiredRelease)) {
+        const member = callerMember(project2, caller);
+        if (member !== void 0 && !hasAcknowledged(project2, member.memberId, project2.requiredRelease)) {
           return {
             allowed: false,
-            detail: handbookMessage("guard", project.requiredRelease)
+            detail: handbookMessage("guard", project2.requiredRelease)
           };
         }
       }
@@ -8904,7 +9036,7 @@ function startHandbookRuntime(ctx) {
 var decodeAcknowledgement = decodeUnknownSync(AcknowledgeInput);
 var decodePublish = decodeUnknownSync(PublishInput);
 var decodeRevert = decodeUnknownSync(RevertInput);
-var decodeRead3 = decodeUnknownSync(ReadHandbookInput);
+var decodeRead4 = decodeUnknownSync(ReadHandbookInput);
 var toolSchema = (schema) => ({
   ...payloadSchemaOf(schema),
   type: "object",
@@ -8948,15 +9080,127 @@ function registerHandbook(ctx, runtime) {
     name: "handbook",
     scope: "read",
     payloadSchema: payloadSchemaOf(ReadHandbookInput),
-    handle: (input) => runtime.read(decodeRead3(input).projectId)
+    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: 13,
+  apiVersion: 14,
   activate(ctx) {
     const rosters = createRosterService(ctx);
     registerRosterCommands(ctx, rosters);
@@ -8965,7 +9209,9 @@ var index_default = definePlugin({
     registerBoardCommands(ctx, goals, rosters);
     registerDetailCommands(ctx);
     startWakeRuntime(ctx);
-    registerHandbook(ctx, startHandbookRuntime(ctx));
+    const handbook = startHandbookRuntime(ctx);
+    registerHandbook(ctx, handbook);
+    registerHandbookPanel(ctx, handbook);
   }
 });
 export {