@productbrain/mcp 0.0.1-beta.4239 → 0.0.1-beta.4243

package/dist/{chunk-522272VK.js → chunk-3NAU25R5.js}

@@ -42,7 +42,7 @@ import {
   trackSessionCaptureRate,
   trackWriteBackHintServed,
   trackZeroCaptureAuditFired
-} from "./chunk-LSOA2AH2.js";
+} from "./chunk-WTGHEQHB.js";
 
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -790,8 +790,8 @@ function formatFieldGuidance(fields) {
   if (guidedFields.length === 0) return "";
   const lines = ["## Writing Guidance"];
   for (const field of guidedFields) {
-    const displayName = field.label || field.key;
-    lines.push(`- ${displayName}: ${field.writingGuidance}`);
+    const displayName2 = field.label || field.key;
+    lines.push(`- ${displayName2}: ${field.writingGuidance}`);
     if (field.writingExamples && field.writingExamples.length > 0) {
       lines.push(`  Examples: ${field.writingExamples.join(" | ")}`);
     }
@@ -2174,7 +2174,7 @@ async function handleCapture(server, { collection, name, description, context, e
   const profile = await getProfile(resolvedCollection);
   const col = await kernelQuery("chain.getCollection", { slug: resolvedCollection });
   if (!col) {
-    const displayName = resolvedCollection.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+    const displayName2 = resolvedCollection.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
     return {
       content: [{
         type: "text",
@@ -2182,7 +2182,7 @@ async function handleCapture(server, { collection, name, description, context, e
 
 **To create it**, run:
 \`\`\`
-collections action=create slug="${resolvedCollection}" name="${displayName}" description="..."
+collections action=create slug="${resolvedCollection}" name="${displayName2}" description="..."
 \`\`\`
 
 Or use \`collections action=list\` to see available collections.`
@@ -2192,7 +2192,7 @@ Or use \`collections action=list\` to see available collections.`
         `Collection '${resolvedCollection}' not found.`,
         "Create the collection first, or use collections action=list to see available ones.",
         [
-          { tool: "collections", description: "Create collection", parameters: { action: "create", slug: resolvedCollection, name: displayName } },
+          { tool: "collections", description: "Create collection", parameters: { action: "create", slug: resolvedCollection, name: displayName2 } },
           { tool: "collections", description: "List collections", parameters: { action: "list" } }
         ]
       )
@@ -15809,6 +15809,243 @@ function registerShapeTools(server) {
   );
 }
 
+// src/tools/question.ts
+import { z as z34 } from "zod/v3";
+var QUESTION_ACTIONS = ["create", "adopt", "assign", "snooze", "decline", "answer", "force-close"];
+var questionSchema = z34.object({
+  action: z34.enum(QUESTION_ACTIONS).describe(
+    "'create': create a new routed question from text (domains come from `pb question --help` / this tool's own refusal \u2014 never hardcode a slug). 'adopt': attach routing to a tension already captured (e.g. via `pb capture \"TEN: ...\"`) \u2014 the pilot's real birth path; without adopt, captured tensions stay invisible to routing forever. 'assign': confirm ('take it', omit toRole/toPerson) or reassign (supply toRole and/or toPerson) ownership. 'snooze': defer a routed/escalated question (max 2, then it escalates). 'decline': pass on a suggested question, or (as owner/lead) decline an owned one \u2014 reason required. 'answer': close the loop \u2014 creates the answering entry itself unless --entry is given. 'force-close': Team-Lead-only escape hatch \u2014 reason required."
+  ),
+  entryId: z34.string().max(200).optional().describe("Target question's id (human TEN-nnn form or a raw entry id). Required for every action except 'create'."),
+  text: z34.string().max(5e3).optional().describe("'create': the question text. 'answer': the answer text (mutually exclusive with answerEntryId, max 2000 chars)."),
+  domain: z34.string().max(200).optional().describe("'create'/'adopt': the domain slug (see this tool's refusal for the live list)."),
+  blocks: z34.array(z34.string().max(200)).max(50).optional().describe("'create'/'adopt': entry ids this question is blocking (repeatable)."),
+  toRole: z34.string().max(200).optional().describe("'assign': reassign to this role (human ROL-nnn form or a raw entry id)."),
+  toPerson: z34.string().max(200).optional().describe("'assign': reassign to this person (a raw person id)."),
+  reason: z34.string().max(2e3).optional().describe("'decline'/'force-close': required reason."),
+  answerEntryId: z34.string().max(200).optional().describe("'answer': point at an already-written entry instead of supplying text (mutually exclusive with text).")
+});
+var createVariant = z34.object({ action: z34.literal("create"), text: z34.string().min(1).max(5e3), domain: z34.string().max(200).optional(), blocks: z34.array(z34.string().max(200)).max(50).optional() });
+var adoptVariant = z34.object({ action: z34.literal("adopt"), entryId: z34.string().max(200), domain: z34.string().max(200).optional(), blocks: z34.array(z34.string().max(200)).max(50).optional() });
+var assignVariant = z34.object({ action: z34.literal("assign"), entryId: z34.string().max(200), toRole: z34.string().max(200).optional(), toPerson: z34.string().max(200).optional() });
+var snoozeVariant = z34.object({ action: z34.literal("snooze"), entryId: z34.string().max(200) });
+var declineVariant = z34.object({ action: z34.literal("decline"), entryId: z34.string().max(200), reason: z34.string().min(1).max(2e3) });
+var answerVariant = z34.object({ action: z34.literal("answer"), entryId: z34.string().max(200), text: z34.string().max(2e3).optional(), answerEntryId: z34.string().max(200).optional() });
+var forceCloseVariant = z34.object({ action: z34.literal("force-close"), entryId: z34.string().max(200), reason: z34.string().min(1).max(2e3) });
+var questionActionUnion = z34.discriminatedUnion("action", [
+  createVariant,
+  adoptVariant,
+  assignVariant,
+  snoozeVariant,
+  declineVariant,
+  answerVariant,
+  forceCloseVariant
+]);
+var QUESTION_ACTION_SPECS = {
+  create: { params: ["text", "domain", "blocks"], description: "text is required; domain/blocks are optional." },
+  adopt: { params: ["entryId", "domain", "blocks"], description: "entryId is required (the already-captured tension); domain/blocks are optional." },
+  assign: { params: ["entryId", "toRole", "toPerson"], description: "entryId is required; omit toRole/toPerson to self-confirm, or supply one/both to reassign." },
+  snooze: { params: ["entryId"], description: "entryId is required." },
+  decline: { params: ["entryId", "reason"], description: "entryId and reason are both required." },
+  answer: { params: ["entryId", "text", "answerEntryId"], description: "entryId is required; supply exactly one of text or answerEntryId." },
+  "force-close": { params: ["entryId", "reason"], description: "entryId and reason are both required." }
+};
+var HUMAN_ID_PATTERN = /^[A-Za-z]+-\d+$/;
+async function resolveEntryRef(raw, label) {
+  if (!HUMAN_ID_PATTERN.test(raw)) return raw;
+  const entry = await kernelQuery("chain.getEntry", { entryId: raw });
+  if (!entry) throw new Error(`${label} '${raw}' not found.`);
+  return entry._id;
+}
+async function displayName(id) {
+  if (!id) return void 0;
+  try {
+    const entry = await kernelQuery("chain.getEntry", { id });
+    return entry?.name;
+  } catch {
+    return void 0;
+  }
+}
+function domainListSuffix(domainSlugs) {
+  if (!domainSlugs) return "";
+  return domainSlugs.length > 0 ? ` Domains in this workspace: ${domainSlugs.join(", ")}.` : " No domains exist in this workspace yet.";
+}
+async function renderCreateAdoptConfirmation(result2, isAdopt) {
+  const lead = isAdopt ? `${result2.entryId} is now a routed question,` : "Question created and";
+  let base;
+  if (result2.status === "unrouted") {
+    const roleName = await displayName(result2.suggestedRoleId) ?? result2.suggestedRoleId;
+    base = isAdopt ? `${lead} suggested to ${roleName}.` : `${lead} suggested to ${roleName}. Confirm with: pb question assign ${result2.entryId}`;
+  } else {
+    const leadName = await displayName(result2.ownerRoleId) ?? result2.ownerRoleId;
+    base = isAdopt ? `${result2.entryId} is now a routed question. Nothing here says who owns it, so it has gone to ${leadName}.` : `Question created. Nothing here says who owns it, so it has gone to ${leadName}.`;
+  }
+  const blocksHint = " If something is blocked on this, add blocks:[<entry-id>...].";
+  const nudge = result2.nudge ? ` ${result2.nudge}` : "";
+  return `${base}${domainListSuffix(result2.domainSlugs)}${blocksHint}${nudge}`;
+}
+async function handleQuestionCreate(text, domain, blocks) {
+  requireWriteAccess();
+  try {
+    const resolvedBlocks = blocks ? await Promise.all(blocks.map((b) => resolveEntryRef(b, "Blocked entry"))) : void 0;
+    const result2 = await kernelMutation("question.create", { text, domainSlug: domain, blocks: resolvedBlocks });
+    const message = await renderCreateAdoptConfirmation(result2, false);
+    const next = result2.status === "unrouted" ? [{ tool: "question", description: "Confirm or reassign the suggestion", parameters: { action: "assign", entryId: result2.entryId } }] : void 0;
+    return successResult(message, message, result2, next);
+  } catch (err) {
+    return questionErrorResult(err, "create", { text, domain, blocks });
+  }
+}
+async function handleQuestionAdopt(entryId, domain, blocks) {
+  requireWriteAccess();
+  try {
+    const resolvedEntryId = await resolveEntryRef(entryId, "Entry");
+    const resolvedBlocks = blocks ? await Promise.all(blocks.map((b) => resolveEntryRef(b, "Blocked entry"))) : void 0;
+    const result2 = await kernelMutation("question.adopt", { entryId: resolvedEntryId, domainSlug: domain, blocks: resolvedBlocks });
+    const message = await renderCreateAdoptConfirmation(result2, true);
+    return successResult(message, message, result2);
+  } catch (err) {
+    return questionErrorResult(err, "adopt", { entryId, domain, blocks });
+  }
+}
+async function handleQuestionAssign(entryId, toRole, toPerson) {
+  requireWriteAccess();
+  try {
+    const resolvedEntryId = await resolveEntryRef(entryId, "Entry");
+    const resolvedToRoleId = toRole ? await resolveEntryRef(toRole, "Role") : void 0;
+    const result2 = await kernelMutation("question.assign", { entryId: resolvedEntryId, toRoleId: resolvedToRoleId, toPersonId: toPerson });
+    const isReassign = Boolean(toRole || toPerson);
+    let message;
+    if (isReassign) {
+      const who = toPerson ? result2.ownerPersonName ?? result2.ownerPersonId ?? "the target" : await displayName(result2.ownerRoleId) ?? result2.ownerRoleId ?? "the target";
+      message = `${entryId} reassigned to ${who}. They'll see it at their next session.`;
+    } else {
+      message = `${entryId} is yours now.`;
+    }
+    return successResult(message, message, result2);
+  } catch (err) {
+    return questionErrorResult(err, "assign", { entryId, toRole, toPerson });
+  }
+}
+async function handleQuestionSnooze(entryId) {
+  requireWriteAccess();
+  try {
+    const resolvedEntryId = await resolveEntryRef(entryId, "Entry");
+    const result2 = await kernelMutation("question.snooze", { entryId: resolvedEntryId });
+    let message;
+    if (result2.snoozeUntil) {
+      message = `Snoozed until ${new Date(result2.snoozeUntil).toISOString().slice(0, 10)}. ${result2.snoozeCount ?? "?"} of 2 snoozes used.`;
+    } else if (result2.status === "escalated") {
+      const leadName = await displayName(result2.ownerRoleId) ?? "the team lead";
+      message = `You have used both snoozes on this question \u2014 it has been escalated to ${leadName}.`;
+    } else {
+      message = "No snoozes left \u2014 answer it or force-close it.";
+    }
+    return successResult(message, message, result2);
+  } catch (err) {
+    return questionErrorResult(err, "snooze", { entryId });
+  }
+}
+async function handleQuestionDecline(entryId, reason) {
+  requireWriteAccess();
+  try {
+    const resolvedEntryId = await resolveEntryRef(entryId, "Entry");
+    const result2 = await kernelMutation("question.decline", { entryId: resolvedEntryId, reason });
+    let message;
+    if (result2.status === "processed") {
+      message = "Declined and closed.";
+    } else if (result2.isRoot === true) {
+      message = `Declined \u2014 but ${result2.dependentsCount ?? 0} item(s) still depend on it, so it stays with you. Answer it or force-close it.`;
+    } else if (result2.isRoot === false) {
+      const leadName = await displayName(result2.ownerRoleId) ?? result2.ownerRoleId;
+      message = `Declined and escalated to ${leadName}.`;
+    } else if (result2.suggestedRoleId) {
+      const roleName = await displayName(result2.suggestedRoleId) ?? result2.suggestedRoleId;
+      message = `Passed. ${entryId} is now suggested to ${roleName}.`;
+    } else if (result2.ownerRoleId) {
+      const leadName = await displayName(result2.ownerRoleId) ?? result2.ownerRoleId;
+      message = `Passed. Nobody else here owns this, so it has gone to ${leadName}.`;
+    } else {
+      message = "Declined.";
+    }
+    return successResult(message, message, result2);
+  } catch (err) {
+    return questionErrorResult(err, "decline", { entryId, reason });
+  }
+}
+async function handleQuestionAnswer(entryId, text, answerEntryId) {
+  if (text === void 0 && answerEntryId === void 0) {
+    return backpressureResult("question", "answer", QUESTION_ACTION_SPECS.answer, "Give the answer as text, or point at an entry with --entry <id>.");
+  }
+  if (text !== void 0 && answerEntryId !== void 0) {
+    return backpressureResult("question", "answer", QUESTION_ACTION_SPECS.answer, "Use either answer text or --entry, not both.");
+  }
+  requireWriteAccess();
+  try {
+    const resolvedEntryId = await resolveEntryRef(entryId, "Entry");
+    const resolvedAnswerEntryId = answerEntryId ? await resolveEntryRef(answerEntryId, "Answer entry") : void 0;
+    const result2 = await kernelMutation("question.answer", { entryId: resolvedEntryId, text, answerEntryId: resolvedAnswerEntryId });
+    const askerName = result2.askerName ?? "The asker";
+    const pendingNote = result2.answerPending ? " The answer is a draft awaiting accept." : "";
+    const message = result2.idempotent ? `${entryId} is already answered \u2014 no change.` : `Answered. ${askerName} will see the outcome at their next session.${pendingNote}`;
+    return successResult(message, message, result2);
+  } catch (err) {
+    return questionErrorResult(err, "answer", { entryId, text, answerEntryId });
+  }
+}
+async function handleQuestionForceClose(entryId, reason) {
+  requireWriteAccess();
+  try {
+    const resolvedEntryId = await resolveEntryRef(entryId, "Entry");
+    const result2 = await kernelMutation("question.forceClose", { entryId: resolvedEntryId, reason });
+    const message = result2.idempotent ? `${entryId} is already closed \u2014 no change.` : "Force-closed. Reason recorded.";
+    return successResult(message, message, result2);
+  } catch (err) {
+    return questionErrorResult(err, "force-close", { entryId, reason });
+  }
+}
+function questionErrorResult(err, action, params = {}) {
+  const classified = classifyError(err);
+  const definedParams = Object.fromEntries(Object.entries(params).filter(([, v]) => v !== void 0));
+  return failureResult(
+    classified.message,
+    classified.code,
+    classified.message,
+    classified.recovery ?? "Use action='create' with no --domain, or `pb question --help` / this tool's description, to find valid domains and next steps.",
+    classified.availableActions ?? [{ tool: "question", description: `Retry ${action}`, parameters: { action, ...definedParams } }],
+    classified.diagnostics
+  );
+}
+function registerQuestionTools(server) {
+  const questionHandlers = {
+    create: (data) => handleQuestionCreate(data.text, data.domain, data.blocks),
+    adopt: (data) => handleQuestionAdopt(data.entryId, data.domain, data.blocks),
+    assign: (data) => handleQuestionAssign(data.entryId, data.toRole, data.toPerson),
+    snooze: (data) => handleQuestionSnooze(data.entryId),
+    decline: (data) => handleQuestionDecline(data.entryId, data.reason),
+    answer: (data) => handleQuestionAnswer(data.entryId, data.text, data.answerEntryId),
+    "force-close": (data) => handleQuestionForceClose(data.entryId, data.reason)
+  };
+  server.registerTool(
+    "question",
+    {
+      title: "Question",
+      description: "Routed questions \u2014 a question with no owner routes itself to the owning role, the team lead when ambiguous, and up the team-lead chain until someone owns it. Seven write actions:\n\n- **create**: create a new routed question from text. Domains are discovered by using this tool \u2014 an unresolvable `domain` refusal lists the workspace's real slugs; there is no fixed list to memorize.\n- **adopt**: attach routing to a tension already captured (e.g. via `capture` with `collection: tensions`) \u2014 the real birth path for most questions. Without adopt, a captured tension stays invisible to routing forever.\n- **assign**: confirm ('take it', no `toRole`/`toPerson`) or reassign (`toRole`/`toPerson`) ownership.\n- **snooze**: defer a routed/escalated question \u2014 max 2, then it escalates to the team lead.\n- **decline**: pass on a suggested question (never closes it), or \u2014 as the owner/team lead \u2014 decline an owned one (reason required; closes it, or escalates it, depending on dependents).\n- **answer**: close the loop. Creates the answering entry itself from `text`, or points at an existing one via `answerEntryId` \u2014 never both.\n- **force-close**: Team-Lead-only escape hatch (reason required) for a question that cannot otherwise be resolved.\n\n`blocks` (repeatable, on create/adopt) records what a question is holding up \u2014 pass entry ids it blocks.",
+      inputSchema: questionSchema,
+      annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false }
+    },
+    thinWrapper(async (args) => {
+      const parsed = parseOrFail(questionSchema, args);
+      if (!parsed.ok) return parsed.result;
+      const { action } = parsed.data;
+      return runWithToolContext(
+        { tool: "question", action },
+        () => dispatchDiscriminated("question", questionActionUnion, parsed.data, QUESTION_ACTION_SPECS, questionHandlers)
+      );
+    })
+  );
+}
+
 // src/resources/index.ts
 import { existsSync as existsSync3 } from "fs";
 import { dirname, join, resolve as resolve4 } from "path";
@@ -15818,7 +16055,7 @@ import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 // src/resources/agentCheatsheet.ts
 var AGENT_CHEATSHEET = `# Product Brain \u2014 Agent Cheatsheet
 
-## Core Tools (Serves 12 default compound tools; 3 more (chain, chain-review, map) behind PB_MODULES=gitchain)
+## Core Tools (Serves 13 default compound tools; 3 more (chain, chain-review, map) behind PB_MODULES=gitchain)
 | Tool | Purpose | Key params |
 |---|---|---|
 | \`orient\` | Workspace context, governance, active bets, session start | \`action\`: start, task, record-activation |
@@ -15833,6 +16070,7 @@ var AGENT_CHEATSHEET = `# Product Brain \u2014 Agent Cheatsheet
 | \`workspace\` | Check / whoami / status / self-test, usage, governance proposals | \`action\`: check, whoami, status, audit, self-test, usage, proposals-* |
 | \`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/adopt, own, snooze, decline, answer, force-close | \`action\`: create, adopt, assign, snooze, decline, answer, force-close |
 
 ## Collection Prefixes
 GLO (glossary), BR (business-rules), PRI (principles), STD (standards),
@@ -16330,12 +16568,12 @@ ${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";
 function registerPrompts(server) {
   server.prompt(
     "review-against-rules",
     "Review code or a design decision against all business rules for a given domain. 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 }) => {
       const entries = await kernelQuery("chain.listEntries", { collectionSlug: "business-rules" });
       const rules = entries.filter((e) => e.data?.domain === domain);
@@ -16388,7 +16626,7 @@ Provide a structured review with a compliance status for each rule (COMPLIANT /
   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. 'vendor_id, compliance_level, formulator_type')") },
+    { names: z35.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
     async ({ names }) => {
       const terms = await kernelQuery("chain.listEntries", { collectionSlug: "glossary" });
       const glossaryContext = terms.map(
@@ -16424,7 +16662,7 @@ Format as a table: Name | Status | Canonical Form | Action Needed`
   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 use MRSL v3.1 as the conformance baseline because...')") },
+    { context: z35.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
     async ({ context }) => {
       const recentDecisions = await kernelQuery("chain.listEntries", { collectionSlug: "decisions" });
       const sorted = [...recentDecisions].sort((a, b) => (b.data?.date ?? "") > (a.data?.date ?? "") ? 1 : -1).slice(0, 5);
@@ -16462,8 +16700,8 @@ After drafting, I can log it using the capture tool with collection "decisions".
     "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. 'Suppliers can have multiple org types in Gateway')"),
-      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. 'Suppliers can have multiple org types in Gateway')"),
+      domain: z35.string().describe("Which domain this rule belongs to (e.g. 'Governance & Decision-Making')")
     },
     async ({ observation, domain }) => {
       const allRules = await kernelQuery("chain.listEntries", { collectionSlug: "business-rules" });
@@ -16529,7 +16767,7 @@ var INSTRUCTIONS = [
   "- **Self-documenting**: orient and server instructions teach agents how PB works. Cursor rules supplement but don't replace.",
   "",
   "### Tool Rename Notice (WP-484 S3, one release)",
-  "Serves 12 default compound tools (WP-559 adds `shape` \u2014 review/disposition for write-shape advisories); 3 more (chain, chain-review, map) behind PB_MODULES=gitchain.",
+  "Serves 13 default compound tools (WP-559 adds `shape` \u2014 review/disposition for write-shape advisories; WP-638 S3 adds `question` \u2014 routed-question routing/ownership/lifecycle); 3 more (chain, chain-review, map) behind PB_MODULES=gitchain.",
   "Old standalone names are gone \u2014 no alias window (ASM-43: zero external consumers). Map: `start_pb`\u2192`orient action=start`, `record_activation`\u2192`orient action=record-activation`, `session-wrapup`\u2192`session action=wrapup-review|wrapup-commit`, `facilitate`\u2192`session action=resume|commit-constellation`, `update-entry`\u2192`entries action=update`, `commit-entry`\u2192`entries action=commit`, `get-history`\u2192`entries action=history`, `move-entry`\u2192`entries action=move`, `verify-entry`\u2192`entries action=verify`, `graph`\u2192`relations action=find|suggest`, `documents`\u2192`context action=last-verified-brief`, `labels`\u2192`collections action=label-*`, `verify`\u2192`quality action=verify-chain`, `audit`\u2192`quality action=audit`, `health`\u2192`workspace action=check|whoami|status|self-test`, `get-usage-summary`\u2192`workspace action=usage`, `governance-proposals`\u2192`workspace action=proposals-*`, `skills`\u2192`workflows action=load-skill`, `chain-version`\u2192`chain action=version.*`, `chain-branch`\u2192`chain-review action=branch.*`, `create-audience-map-set`/`map-slot`/`map-version`/`map-suggest`\u2192`map action=create-audience-set|slot.*|version.*|suggest`.",
   "",
   "## Your Workspace Principles",
@@ -16599,6 +16837,7 @@ function createProductBrainServer() {
   registerWorkspaceTools(server);
   registerFeedbackTool(server);
   registerShapeTools(server);
+  registerQuestionTools(server);
   if (enabledModules.has("gitchain")) registerGitChainTools(server);
   if (enabledModules.has("gitchain")) registerMapTools(server);
   registerResources(server);
@@ -16739,4 +16978,4 @@ export {
   createProductBrainServer,
   initFeatureFlags
 };
-//# sourceMappingURL=chunk-522272VK.js.map
+//# sourceMappingURL=chunk-3NAU25R5.js.map