@productbrain/mcp 0.0.1-beta.9616 → 0.0.1-beta.9621

package/dist/{chunk-UPTW4MKK.js → chunk-U6BVSTXX.js}

@@ -47,7 +47,7 @@ import {
 
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z35 } from "zod/v3";
+import { z as z36 } from "zod/v3";
 
 // src/lib/mcpGatewayClientMessages.ts
 function agentSessionNotActiveMessage(status2) {
@@ -12245,22 +12245,21 @@ function formatInviteSentence(reply, clean) {
 }
 
 // src/tools/role.ts
-var ROLE_ACTIONS = ["accountable", "seat", "unseat", "invite"];
+var ROLE_ACTIONS = ["accountable", "seat", "unseat"];
 var roleSchema = z32.object({
   action: z32.enum(ROLE_ACTIONS).describe(
-    "'accountable': what this role owns (explicit), reports on (reporting), and \u2014 not yet computed \u2014 inherits via Team-Lead vacancy coverage. 'seat': put a person in this role. 'unseat': take this role from a person. 'invite': send a login link by email; a placeholder person (seated by name) is invited in place and keeps every role it holds."
+    "'accountable': what this role owns (explicit), reports on (reporting), and \u2014 not yet computed \u2014 inherits via Team-Lead vacancy coverage. 'seat': put a person in this role. 'unseat': take this role from a person."
   ),
-  roleId: z32.string().max(200).optional().describe("The role, by the human chain id `chain.getEntry` or `pb get` would print for it, or a raw entry id. Required for every action except 'invite'."),
+  roleId: z32.string().max(200).optional().describe("The role, by the human chain id `chain.getEntry` or `pb get` would print for it, or a raw entry id."),
   canonicalKey: z32.string().max(200).optional().describe("'accountable': narrow to one kind (e.g. objective, key_result, tension)."),
   limit: z32.number().int().positive().max(200).optional().describe("'accountable': max explicit-list rows per page (default and maximum 200)."),
   cursor: z32.number().optional().describe("'accountable': continue the explicit list from an earlier truncated page's nextCursor."),
   person: z32.string().max(200).optional().describe(
-    "'seat' / 'unseat': an existing person, by person id or exact email. For 'seat', give this or newPersonName, not both. 'invite': the placeholder's person id."
+    "'seat' / 'unseat': an existing person, by person id or exact email. For 'seat', give this or newPersonName, not both."
   ),
   newPersonName: z32.string().max(120).optional().describe(
-    "'seat': the name of a person who has no login yet; a placeholder person is created once and reused for the same exact name. Refused when the name belongs to someone with an account. 'invite': the name of a new person to invite, instead of person."
+    "'seat': the name of a person who has no login yet; a placeholder person is created once and reused for the same exact name. Refused when the name belongs to someone with an account."
   ),
-  email: z32.string().max(320).optional().describe("'invite': where the login link goes. Required for 'invite'."),
   teamId: z32.string().max(200).optional().describe(
     "'seat' / 'unseat': the team, by chain id or entry id. Only needed for Team Lead, which lives in every team; any other role is seated in its home team."
   )
@@ -12285,18 +12284,11 @@ var unseatVariant = z32.object({
   person: z32.string().max(200),
   teamId: z32.string().max(200).optional()
 });
-var inviteVariant = z32.object({
-  action: z32.literal("invite"),
-  email: z32.string().max(320),
-  person: z32.string().max(200).optional(),
-  newPersonName: z32.string().max(120).optional()
-});
-var roleActionUnion = z32.discriminatedUnion("action", [accountableVariant, seatVariant, unseatVariant, inviteVariant]);
+var roleActionUnion = z32.discriminatedUnion("action", [accountableVariant, seatVariant, unseatVariant]);
 var ROLE_ACTION_SPECS = {
   accountable: { params: ["roleId", "canonicalKey", "limit", "cursor"], description: "roleId is required; canonicalKey/limit/cursor are optional." },
   seat: { params: ["roleId", "person", "newPersonName", "teamId"], description: "roleId is required, plus exactly one of person or newPersonName; teamId only for Team Lead." },
-  unseat: { params: ["roleId", "person", "teamId"], description: "roleId and person are required; teamId only for Team Lead." },
-  invite: { params: ["email", "person", "newPersonName"], description: "email is required, plus exactly one of person (a placeholder's id) or newPersonName." }
+  unseat: { params: ["roleId", "person", "teamId"], description: "roleId and person are required; teamId only for Team Lead." }
 };
 function formatHolders(result2) {
   if (result2.holders.length === 0) return [`  holders: none${result2.holdersTruncated ? " found, but the membership scan is incomplete" : ""}`];
@@ -12376,22 +12368,6 @@ function handleRoleSeat(roleId, person, newPersonName, teamId) {
 function handleRoleUnseat(roleId, person, teamId) {
   return runSeatAction("unseat", "organisation.unseatFromRole", { roleId, person, teamId });
 }
-async function handleRoleInvite(email, person, newPersonName) {
-  const params = { email, person, newPersonName };
-  try {
-    requireWriteAccess();
-    const result2 = await kernelMutation("people.invite", {
-      email,
-      targetPersonId: person,
-      displayName: newPersonName,
-      sessionId: getAgentSessionId()
-    });
-    const message = formatInviteSentence(result2, sanitizeSingleLineField);
-    return successResult(message, message, result2);
-  } catch (err) {
-    return roleErrorResult(err, "invite", params);
-  }
-}
 function roleErrorResult(err, action, params = {}) {
   const classified = classifyError(err);
   const definedParams = Object.fromEntries(Object.entries(params).filter(([, v]) => v !== void 0));
@@ -12409,18 +12385,18 @@ function registerRoleTools(server) {
   const roleHandlers = {
     accountable: (data) => handleRoleAccountable(data.roleId, data.canonicalKey, data.limit, data.cursor),
     seat: (data) => handleRoleSeat(data.roleId, data.person, data.newPersonName, data.teamId),
-    unseat: (data) => handleRoleUnseat(data.roleId, data.person, data.teamId),
-    invite: (data) => handleRoleInvite(data.email, data.person, data.newPersonName)
+    unseat: (data) => handleRoleUnseat(data.roleId, data.person, data.teamId)
   };
   server.registerTool(
     "role",
     {
       title: "Role",
-      description: "Workspace roles \u2014 who is accountable for what, and who holds it. Four actions:\n\n- **accountable**: what this role owns (`explicit` \u2014 the canonical ownership row for objective/key_result/tension, data.ownerRoleId for domain), reports on (`reporting`, data.reporterRoleId \u2014 key results and tensions only, a separate fact from ownership), and \u2014 always `not-computed` today, never faked as empty \u2014 inherits via Team-Lead vacancy coverage. Also lists `holders`.\n- **seat**: put a person in this role, by person id or email, or by `newPersonName` for someone with no login yet (a placeholder person, created once per exact name). The role's home team is used; name `teamId` only for Team Lead. A held role refuses a second holder and names the holder; the person keeps their other roles in the team. Needs the team's Team Lead.\n- **unseat**: take this role from a person; their other roles in the team stay. The last active Team Lead of a team is refused.\n- **invite**: send a login link to `email`. Give `person` (a placeholder's id, as `seat` printed it) to invite that person in place: they keep every role they hold. Or give `newPersonName` to invite someone new. A person who already has a login or an invite is refused. Needs a workspace owner or admin.",
+      description: "Workspace roles \u2014 who is accountable for what, and who holds it. Three actions:\n\n- **accountable**: what this role owns (`explicit` \u2014 the canonical ownership row for objective/key_result/tension, data.ownerRoleId for domain), reports on (`reporting`, data.reporterRoleId \u2014 key results and tensions only, a separate fact from ownership), and \u2014 always `not-computed` today, never faked as empty \u2014 inherits via Team-Lead vacancy coverage. Also lists `holders`.\n- **seat**: put a person in this role, by person id or email, or by `newPersonName` for someone with no login yet (a placeholder person, created once per exact name). The role's home team is used; name `teamId` only for Team Lead. A held role refuses a second holder and names the holder; the person keeps their other roles in the team. Needs the team's Team Lead.\n- **unseat**: take this role from a person; their other roles in the team stay. The last active Team Lead of a team is refused. Invite a person, or take them out of a team, with the `people` tool.",
       inputSchema: roleSchema,
       // The hints describe the whole tool, so they say the most it can do: unseat removes a role and can
       // delete a membership row (destructive), and a repeated seat still writes history and audit rows
-      // (not idempotent), even though accountable is a pure read (PR #1508 review).
+      // (not idempotent), even though accountable is a pure read (PR #1508 review). Closed world: nothing here
+      // reaches outside the workspace since invite moved to `people` (TASK-677, DEC-1981).
       annotations: { readOnlyHint: false, idempotentHint: false, destructiveHint: true, openWorldHint: false }
     },
     thinWrapper(async (args) => {
@@ -12435,50 +12411,161 @@ function registerRoleTools(server) {
   );
 }
 
-// src/tools/outcome.ts
+// src/tools/people.ts
 import { z as z33 } from "zod/v3";
+var PEOPLE_ACTIONS = ["invite", "remove"];
+var peopleSchema = z33.object({
+  action: z33.enum(PEOPLE_ACTIONS).describe("'invite': send a login link by email. 'remove': take a person out of a team."),
+  email: z33.string().max(320).optional().describe("'invite': where the login link goes. Required for 'invite'."),
+  person: z33.string().max(320).optional().describe(
+    "'invite': a placeholder's person id, instead of newPersonName. 'remove': the person, by person id or exact email."
+  ),
+  newPersonName: z33.string().max(120).optional().describe("'invite': the name of a new person to invite, instead of person."),
+  teamId: z33.string().max(200).optional().describe("'remove': the team, by chain id or entry id. Required for 'remove'.")
+});
+var inviteVariant = z33.object({
+  action: z33.literal("invite"),
+  email: z33.string().max(320),
+  person: z33.string().max(320).optional(),
+  newPersonName: z33.string().max(120).optional()
+});
+var removeVariant = z33.object({
+  action: z33.literal("remove"),
+  person: z33.string().max(320),
+  teamId: z33.string().max(200)
+});
+var peopleActionUnion = z33.discriminatedUnion("action", [inviteVariant, removeVariant]);
+var PEOPLE_ACTION_SPECS = {
+  invite: { params: ["email", "person", "newPersonName"], description: "email is required, plus exactly one of person (a placeholder's id) or newPersonName." },
+  remove: { params: ["person", "teamId"], description: "person and teamId are required." }
+};
+async function handlePeopleInvite(email, person, newPersonName) {
+  const params = { email, person, newPersonName };
+  try {
+    requireWriteAccess();
+    const result2 = await kernelMutation("people.invite", {
+      email,
+      targetPersonId: person,
+      displayName: newPersonName,
+      sessionId: getAgentSessionId()
+    });
+    const message = formatInviteSentence(result2, sanitizeSingleLineField);
+    return successResult(message, message, result2);
+  } catch (err) {
+    return peopleErrorResult(err, "invite", params);
+  }
+}
+async function handlePeopleRemove(person, teamId) {
+  try {
+    requireWriteAccess();
+    const result2 = await kernelMutation("organisation.removeMembership", {
+      targetPersonRef: person,
+      teamRef: teamId,
+      sessionId: getAgentSessionId()
+    });
+    if (result2.outcome === "refused") {
+      const { reason, requiredAction } = result2.refusal;
+      const message2 = `Refused: ${reason}${requiredAction ? ` ${requiredAction}` : ""}`;
+      return failureResult(
+        message2,
+        "PERMISSION_DENIED",
+        message2,
+        requiredAction ?? "Ask the team's Team Lead to remove them.",
+        void 0,
+        result2
+      );
+    }
+    const who = sanitizeSingleLineField(result2.person);
+    const message = result2.removed ? `Removed ${who} from ${result2.team}.` : `${who} was not assigned to ${result2.team}; nothing changed.`;
+    return successResult(message, message, result2);
+  } catch (err) {
+    return peopleErrorResult(err, "remove", { person, teamId });
+  }
+}
+function peopleErrorResult(err, action, params) {
+  const classified = classifyError(err);
+  const definedParams = Object.fromEntries(Object.entries(params).filter(([, v]) => v !== void 0));
+  const fallbackActions = retryIsFutile(classified.code) ? void 0 : [{ tool: "people", description: `Retry ${action}`, parameters: { action, ...definedParams } }];
+  return failureResult(
+    classified.message,
+    classified.code,
+    classified.message,
+    classified.recovery ?? `Fix the input the message names and call action='${action}' again.`,
+    classified.availableActions ?? fallbackActions,
+    classified.diagnostics
+  );
+}
+function registerPeopleTools(server) {
+  const peopleHandlers = {
+    invite: (data) => handlePeopleInvite(data.email, data.person, data.newPersonName),
+    remove: (data) => handlePeopleRemove(data.person, data.teamId)
+  };
+  server.registerTool(
+    "people",
+    {
+      title: "People",
+      description: "People in the workspace. Two actions:\n\n- **invite**: send a login link to `email`. Give `person` (a placeholder's id, as `role action=seat` printed it) to invite that person in place: they keep every role they hold. Or give `newPersonName` to invite someone new. A person who already has a login or an invite is refused. Needs a workspace owner or admin.\n- **remove**: take `person` out of the team `teamId`; every role they hold there goes with it. To take one role, use `role action=unseat`. Needs the team's Team Lead.",
+      inputSchema: peopleSchema,
+      // TASK-677 (DEC-1981, DEC-74): invite emails an address outside the workspace (open world);
+      // remove deletes a membership row and every role on it (destructive); neither is idempotent.
+      annotations: { readOnlyHint: false, idempotentHint: false, destructiveHint: true, openWorldHint: true }
+    },
+    thinWrapper(async (args) => {
+      const parsed = parseOrFail(peopleSchema, args);
+      if (!parsed.ok) return parsed.result;
+      const { action } = parsed.data;
+      return runWithToolContext(
+        { tool: "people", action },
+        () => dispatchDiscriminated("people", peopleActionUnion, parsed.data, PEOPLE_ACTION_SPECS, peopleHandlers)
+      );
+    })
+  );
+}
+
+// src/tools/outcome.ts
+import { z as z34 } from "zod/v3";
 var OUTCOME_ACTIONS = ["record", "list", "show"];
 var READING_KINDS = ["measurement", "estimate", "correction"];
-var outcomeSchema = z33.object({
-  action: z33.enum(OUTCOME_ACTIONS).describe(
+var outcomeSchema = z34.object({
+  action: z34.enum(OUTCOME_ACTIONS).describe(
     "'record': record a reading (evidence, not a verdict). 'list': list readings, newest first. 'show': the derived view \u2014 current, progress, pace, staleness, recorded completion."
   ),
-  entryId: z33.string().max(200).optional().describe("The key result (or other outcome-bearing) entry, by its chain id. Required for all three actions."),
+  entryId: z34.string().max(200).optional().describe("The key result (or other outcome-bearing) entry, by its chain id. Required for all three actions."),
   // PR #858 review round 3 (Codex P2, PRRT_kwDORS4ils6gXHj9): a JSON number that overflows to
   // `Infinity` (e.g. `1e400`) parses fine in JS and passes a plain `z.number()`, but
   // `callGateway()` serializes it with `JSON.stringify`, which turns `Infinity` into `null` —
   // the backend's `v.number()` validator then rejects a call this tool's own schema accepted.
   // `.finite()` rejects it here, matching the explicit finite-value checks the CLI/other outcome
   // entry surfaces already use.
-  value: z33.number().finite().optional().describe("'record': the measured value. Required for 'record'."),
-  valueText: z33.string().max(500).optional().describe("'record': verbatim as-reported form when the source was not clean, e.g. '~62%'. Display only."),
-  asOf: z33.string().max(64).optional().describe("'record': when the world was in this state, as a parseable date (default: now). Back-dating a backfill is legitimate \u2014 it shows up as asOf earlier than recordedAt."),
-  kind: z33.enum(READING_KINDS).optional().describe("'record': measurement | estimate | correction (default: measurement)."),
-  correctsReadingId: z33.string().max(200).optional().describe("'record': required with kind='correction' \u2014 the reading id this replaces. Refused if that row is already superseded."),
-  recordedByRoleId: z33.string().max(200).optional().describe("'record': the accountable role (default: the entry's reporterRoleId, then its owning role)."),
-  note: z33.string().max(2e3).optional().describe("'record': free-text note recorded with the reading."),
-  source: z33.string().max(500).optional().describe("'record': where the number came from \u2014 a dashboard name, a query, a URL."),
-  limit: z33.number().int().positive().max(200).optional().describe("'list': max rows to return (default and maximum 200).")
+  value: z34.number().finite().optional().describe("'record': the measured value. Required for 'record'."),
+  valueText: z34.string().max(500).optional().describe("'record': verbatim as-reported form when the source was not clean, e.g. '~62%'. Display only."),
+  asOf: z34.string().max(64).optional().describe("'record': when the world was in this state, as a parseable date (default: now). Back-dating a backfill is legitimate \u2014 it shows up as asOf earlier than recordedAt."),
+  kind: z34.enum(READING_KINDS).optional().describe("'record': measurement | estimate | correction (default: measurement)."),
+  correctsReadingId: z34.string().max(200).optional().describe("'record': required with kind='correction' \u2014 the reading id this replaces. Refused if that row is already superseded."),
+  recordedByRoleId: z34.string().max(200).optional().describe("'record': the accountable role (default: the entry's reporterRoleId, then its owning role)."),
+  note: z34.string().max(2e3).optional().describe("'record': free-text note recorded with the reading."),
+  source: z34.string().max(500).optional().describe("'record': where the number came from \u2014 a dashboard name, a query, a URL."),
+  limit: z34.number().int().positive().max(200).optional().describe("'list': max rows to return (default and maximum 200).")
 });
-var recordVariant = z33.object({
-  action: z33.literal("record"),
-  entryId: z33.string().max(200),
-  value: z33.number().finite(),
-  valueText: z33.string().max(500).optional(),
-  asOf: z33.string().max(64).optional(),
-  kind: z33.enum(READING_KINDS).optional(),
-  correctsReadingId: z33.string().max(200).optional(),
-  recordedByRoleId: z33.string().max(200).optional(),
-  note: z33.string().max(2e3).optional(),
-  source: z33.string().max(500).optional()
+var recordVariant = z34.object({
+  action: z34.literal("record"),
+  entryId: z34.string().max(200),
+  value: z34.number().finite(),
+  valueText: z34.string().max(500).optional(),
+  asOf: z34.string().max(64).optional(),
+  kind: z34.enum(READING_KINDS).optional(),
+  correctsReadingId: z34.string().max(200).optional(),
+  recordedByRoleId: z34.string().max(200).optional(),
+  note: z34.string().max(2e3).optional(),
+  source: z34.string().max(500).optional()
 });
-var listVariant2 = z33.object({
-  action: z33.literal("list"),
-  entryId: z33.string().max(200),
-  limit: z33.number().int().positive().max(200).optional()
+var listVariant2 = z34.object({
+  action: z34.literal("list"),
+  entryId: z34.string().max(200),
+  limit: z34.number().int().positive().max(200).optional()
 });
-var showVariant = z33.object({ action: z33.literal("show"), entryId: z33.string().max(200) });
-var outcomeActionUnion = z33.discriminatedUnion("action", [recordVariant, listVariant2, showVariant]);
+var showVariant = z34.object({ action: z34.literal("show"), entryId: z34.string().max(200) });
+var outcomeActionUnion = z34.discriminatedUnion("action", [recordVariant, listVariant2, showVariant]);
 var OUTCOME_ACTION_SPECS = {
   record: {
     params: ["entryId", "value", "valueText", "asOf", "kind", "correctsReadingId", "recordedByRoleId", "note", "source"],
@@ -12762,7 +12849,7 @@ var ALLOWED_RELATION_TYPES = new Set(ALLOWED_RELATION_TYPES_LIST);
 var DATA_HANDLING_SECTION = "### How PB Handles Your Data\n- **The reply is the source of truth**: every reply carries `ok`; on failure it carries `code` and guidance. Read the reply, never an expectation.\n- **Empty-workspace safe**: the orientation resource and this cheatsheet render on a workspace with no entries and no collections.\n- **Workspace-agnostic**: PB is one product used by many teams. Nothing in these instructions is specific to your workspace; your own rules arrive as the rule lists that session start and orient serve you.\n- **Served, not installed**: these instructions, `productbrain://orientation` and `productbrain://agent-cheatsheet` are served over MCP.";
 var AGENT_CHEATSHEET = `# Product Brain \u2014 Agent Cheatsheet
 
-## Core Tools (Serves 15 compound tools, always)
+## Core Tools (Serves 16 compound tools, always)
 | Tool | Purpose | Actions |
 |---|---|---|
 | \`orient\` | Workspace context, governance, active work packages, session start | \`action\`: start, task |
@@ -12778,7 +12865,8 @@ var AGENT_CHEATSHEET = `# Product Brain \u2014 Agent Cheatsheet
 | \`feedback\` | Submit product feedback (any key, no session required); \`list\` reads back your own workspace's feedback (no gate); vendor triage: queue / note / group / status | \`action\`: submit, list, queue, note, group, status |
 | \`shape\` | Review / disposition write-shape (single-concern split) advisories | \`action\`: list, show, agree, dismiss |
 | \`question\` | Routed questions \u2014 create, reassign, answer, force-close, list | \`action\`: create, assign, answer, force-close, list |
-| \`role\` | What a role owns and who holds it; seat (by id, email or new name), unseat, or invite a placeholder in place | \`action\`: accountable, seat, unseat, invite |
+| \`role\` | What a role owns and who holds it; seat (by id, email or new name), unseat | \`action\`: accountable, seat, unseat |
+| \`people\` | Invite a person by email, a placeholder in place or someone new; take a person out of a team | \`action\`: invite, remove |
 | \`outcome\` | Record an outcome measurement and read the ones already recorded | \`action\`: record, list, show |
 
 This table lists actions only. See \`tools/list\` for each tool's input schema; a missing or invalid parameter is named in the call's own reply.
@@ -13247,7 +13335,7 @@ ${entry.labels.map((l) => `- ${l.name ?? l.slug}`).join("\n")}`);
 }
 
 // src/prompts/index.ts
-import { z as z34 } from "zod/v3";
+import { z as z35 } from "zod/v3";
 async function buildReviewAgainstRulesPrompt(domain) {
   const entries = await kernelQuery("chain.listEntries", { collectionSlug: "rules" });
   const rules = entries.slice(0, 50);
@@ -13329,27 +13417,27 @@ function registerPrompts(server) {
   server.prompt(
     "review-against-rules",
     "Review code or a design decision against the rules, focused on a given area. Fetches the rules and asks you to do a structured compliance review.",
-    { domain: z34.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
+    { domain: z35.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
     async ({ domain }) => buildReviewAgainstRulesPrompt(domain)
   );
   server.prompt(
     "name-check",
     "Check variable names, field names, or API names against the glossary for terminology alignment. Flags drift from canonical terms.",
-    { names: z34.string().describe("Comma-separated list of names to check (e.g. 'user_id, workspace_id, entry_status')") },
+    { names: z35.string().describe("Comma-separated list of names to check (e.g. 'user_id, workspace_id, entry_status')") },
     async ({ names }) => buildNameCheckPrompt(names)
   );
   server.prompt(
     "draft-decision-record",
     "Draft a structured decision record from a description of what was decided. Includes context from recent decisions and relevant rules.",
-    { context: z34.string().describe("Description of the decision (e.g. 'We decided to keep one body field per entry because...')") },
+    { context: z35.string().describe("Description of the decision (e.g. 'We decided to keep one body field per entry because...')") },
     async ({ context }) => buildDraftDecisionRecordPrompt(context)
   );
   server.prompt(
     "draft-rule-from-context",
     "Draft a new business rule from an observation or discovery made while coding. Fetches existing rules for the domain to ensure consistency.",
     {
-      observation: z34.string().describe("What you observed or discovered (e.g. 'A workspace can have more than one owner role')"),
-      domain: z34.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
+      observation: z35.string().describe("What you observed or discovered (e.g. 'A workspace can have more than one owner role')"),
+      domain: z35.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
     },
     async ({ observation, domain }) => buildDraftRuleFromContextPrompt(observation, domain)
   );
@@ -13447,7 +13535,7 @@ var INSTRUCTIONS = [
   "",
   "## Writing",
   "",
-  "Write actions (capture, entries update and commit, relations create, batch-create and delete) need an active session and a readwrite key.",
+  "Write actions (capture, entries update and commit, relations create, batch-create and delete, people invite and remove, role seat and unseat) need an active session and a readwrite key.",
   "Pass the `sessionId` that `session action=start` returned on every write: the connection does not remember it.",
   "Use `capture` to create an entry and read its reply: an entry that came back accepted needs no `entries action=commit`.",
   "Link entries with `relations action=create` \u2014 a relation is written only when you ask, with exactly the verb you send.",
@@ -13458,7 +13546,7 @@ var INSTRUCTIONS = [
   "",
   "Every tool and action: `productbrain://agent-cheatsheet`."
 ].join("\n");
-var sessionIdArg = z35.string().max(200).optional().describe(
+var sessionIdArg = z36.string().max(200).optional().describe(
   "The sessionId `session action=start` returned. Pass it on every write: the connection does not remember your session between calls."
 );
 function acceptSessionIdOnEveryTool(server) {
@@ -13514,6 +13602,7 @@ function createProductBrainServer() {
   registerShapeTools(server);
   registerQuestionTools(server);
   registerRoleTools(server);
+  registerPeopleTools(server);
   registerOutcomeTools(server);
   registerResources(server);
   registerPrompts(server);
@@ -13550,4 +13639,4 @@ export {
   createProductBrainServer,
   initFeatureFlags
 };
-//# sourceMappingURL=chunk-UPTW4MKK.js.map
+//# sourceMappingURL=chunk-U6BVSTXX.js.map