@productbrain/mcp 0.0.1-beta.8423 → 0.0.1-beta.8425

package/dist/{chunk-RLXYUP6A.js → chunk-BIHHHC2H.js}

@@ -5033,7 +5033,7 @@ var contextSchema = z15.object({
   ),
   direction: z15.enum(["outgoing", "incoming"]).default("outgoing").optional().describe("For 'chain' action: traversal direction. 'outgoing' follows relations from source, 'incoming' follows relations to source. Default: outgoing."),
   relationType: z15.string().max(200).optional().describe(
-    "Relation type filter. For 'chain': optional filter to traverse only this relation type. For 'cross-cut': required \u2014 scans all relations of this type across the workspace. Examples: 'part_of', 'informs', 'governs', 'blocks', 'depends_on'."
+    "Relation type filter. For 'chain': optional filter to traverse only this relation type. For 'cross-cut': required \u2014 scans all relations of this type across the workspace. Examples: 'part_of', 'informs', 'governs', 'depends_on'."
   ),
   mode: z15.enum(["search", "graph"]).default("search").optional().describe("For gather: 'search' (default) or 'graph' (enhanced with provenance paths). Ignored when mapEntryId is provided."),
   maxHops: z15.number().min(1).max(4).default(2).describe("Relation traversal depth (1=direct only, 2=default, 3=wide net, 4=deep chain walk)"),
@@ -8677,14 +8677,11 @@ async function _handleOrient({ mode = "full", tier, task, startupSignals, invoca
     const fmt = (e) => {
       const type = e.canonicalKey ?? "generic";
       const stratum = e.stratum ?? "?";
-      const confidencePart = e.confidence ? ` [confidence: ${e.confidence}]` : "";
-      const reviewOverdue = e.reviewAt && new Date(e.reviewAt).getTime() < Date.now();
-      const overduePart = reviewOverdue ? " [review overdue]" : "";
       const originPart = e.origin ? ` (origin: ${e.origin})` : "";
       const mark = provenanceMark(e.provenance);
       const anchorSuffix = e.anchoredBy ? ` (${e.anchoredBy})` : "";
       const coherencyPart = coherencyCheckTag(e.coherencyCheckStatus);
-      return `- ${mark}\`${e.entryId ?? e._id}\` [${type} \xB7 ${stratum}] ${e.name}${anchorSuffix}${originPart}${confidencePart}${overduePart}${coherencyPart}`;
+      return `- ${mark}\`${e.entryId ?? e._id}\` [${type} \xB7 ${stratum}] ${e.name}${anchorSuffix}${originPart}${coherencyPart}`;
     };
     const fullCoherence = await buildCoherenceSection();
     if (fullCoherence) {
@@ -10729,9 +10726,9 @@ var auditSchema = z21.object({
     "'run': run the hygiene audit for a work package entry."
   ),
   entryId: z21.string().describe("Work package entry ID to audit, e.g. '<PREFIX>-<n>'"),
-  // Chain: WP-770 K2, DEC-1796 — doneWhen/exclusions run unconditionally in both phases.
+  // Chain: WP-770 K2, DEC-1796 — doneWhen runs unconditionally (DEC-1852) in both phases.
   phase: z21.enum(["shaping", "handoff"]).default("shaping").optional().describe(
-    "'shaping': run the core hygiene gates only. 'handoff': also runs the outcome-coupling gates (KR linkage, verification window). doneWhen/exclusions are checked unconditionally either way. Default: shaping."
+    "'shaping': run the core hygiene gates only. 'handoff': also runs the outcome-coupling gates (KR linkage, verification window). doneWhen is checked unconditionally either way. Default: shaping."
   )
 });
 async function handleAuditRun(entryId, phase) {
@@ -11015,9 +11012,9 @@ var qualitySchema = z22.object({
   context: z22.enum(["capture", "commit", "review"]).default("review").optional().describe("For re-evaluate: evaluation context"),
   collection: z22.string().max(200).optional().describe("For 'verify-chain': collection slug to verify (default: glossary)."),
   mode: z22.enum(["report", "fix"]).optional().describe("For 'verify-chain': 'report' = read-only trust report (default). 'fix' = also update drifted codeMapping statuses."),
-  // Chain: WP-770 K2, DEC-1796 — doneWhen/exclusions run unconditionally in both phases.
+  // Chain: WP-770 K2, DEC-1796 — doneWhen runs unconditionally (DEC-1852) in both phases.
   phase: z22.enum(["shaping", "handoff"]).optional().describe(
-    "For 'audit': 'shaping' runs the core hygiene gates only (default). 'handoff' also runs the outcome-coupling gates (KR linkage, verification window). doneWhen/exclusions are checked unconditionally either way."
+    "For 'audit': 'shaping' runs the core hygiene gates only (default). 'handoff' also runs the outcome-coupling gates (KR linkage, verification window). doneWhen is checked unconditionally either way."
   ),
   story: z22.boolean().optional().describe("For 'spine-check': also run the on-demand one-story LLM judgment (never scheduled; result labelled [unvalidated])."),
   refresh: z22.boolean().optional().describe(
@@ -13797,6 +13794,83 @@ import { dirname, join, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 
+// src/lib/relationTypes.ts
+var ALLOWED_RELATION_TYPES_LIST = [
+  // Core semantic types (in RELATION_TYPE_REGISTRY)
+  "informs",
+  "governs",
+  "surfaces_tension_in",
+  "defines_term_for",
+  "belongs_to",
+  "references",
+  "related_to",
+  "fills_slot",
+  "commits_to",
+  "informed_by",
+  "depends_on",
+  "conflicts_with",
+  "confused_with",
+  // WP-449: Glossary Foundation — negative assertion for agents (spec §4.5)
+  "do_not_confuse_with",
+  "replaces",
+  "part_of",
+  "constrains",
+  // Epistemic types — evidence linking
+  "validates",
+  "invalidates",
+  // Extended types (used in codebase, not in RELATION_TYPE_REGISTRY yet)
+  "governed_by",
+  "alternative_to",
+  "has_proposal",
+  "requests_promotion_of",
+  "resolves",
+  // WP-228 Slice 0: Playing Field relation types
+  "experiences",
+  "addresses",
+  // Tier 1 Hierarchy: DEC-401 (experiments prereqs), DEC-402 (risk views)
+  "threatens",
+  "tests",
+  "produces",
+  // WP-274: Capability tier relation types
+  "realizes",
+  "requires",
+  "invests_in",
+  "enables",
+  // PARKED (park note, 2026-08-23) — these 5 verbs are untouched by a separate
+  // governance-verb-ownership review: no delete, no lock, no whitelist, no picker change,
+  // and no relation of this note to that review. Live source-canonicalKey row counts, from
+  // a read-only pass over an uncapped, exhaustive census of a real workspace (measured
+  // 2026-08-23): follows = 11 rows (decision 2, milestone 5, work_package 4);
+  // extracted_from = 4 rows (decision 1, insight 1, tension 1, work_package 1);
+  // part_of_workstream = 0 rows; stated_by = 0 rows; discussed_in = 0 rows. Whether any of
+  // these should be retired, merged, or promoted is a founder call, deliberately deferred —
+  // not decided here, and not decided by silence either. Re-verify the counts before acting
+  // on them; they will drift.
+  // WP-344 S0a: Evolve-First Ingestion relation types
+  "follows",
+  // sequential/derived — new entry follows/continues from another
+  "extracted_from",
+  // provenance — this entry was extracted from a source document
+  // WP-353 S0: scope-propagated commit relation types (DEC-A captured as exploring per RULE-187)
+  "part_of_workstream",
+  // entry belongs to a workstream anchor confirmed at scope step
+  "stated_by",
+  // entry was stated by a speaker in the source document
+  "discussed_in",
+  // entry was discussed within a particular meeting/doc context
+  // Specification types — WP-363 E2: precision alternatives to governs for decision→governance relations
+  "specializes",
+  // DEC narrows or refines a broader STD/PRI — more specific application of the parent
+  "implements",
+  // DEC/WP realizes a BR/STD in concrete operational form
+  // WP-641 S2a (WP-647): belongs_to vocabulary split — the strategy-scope successor.
+  // The other two successors (authority_domain, domain_routed_to) and `blocks` are no longer
+  // legal to write: a new workspace carries none of them (DEC-1845, TASK-331, TASK-425).
+  "anchored_to"
+  // strategy-scope anchor: a raw strategy entry belongs_to a product (DEC-1523)
+];
+var ALLOWED_RELATION_TYPES = new Set(ALLOWED_RELATION_TYPES_LIST);
+
 // src/resources/agentCheatsheet.ts
 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 principles, standards and rules arrive through `productbrain://orientation`.\n- **Served, not installed**: these instructions, `productbrain://orientation` and `productbrain://agent-cheatsheet` are served over MCP.";
 var AGENT_CHEATSHEET = `# Product Brain \u2014 Agent Cheatsheet
@@ -13828,12 +13902,8 @@ DEC (decisions), STR (strategy), TEN (tensions), FEAT (features),
 BET (bets), INS (insights), ARCH (architecture), TEAM (teams),
 ROL (roles), MTRC (tracking-events), ST (semantic-types)
 
-## Valid Relation Types (24)
-informs, governs, surfaces_tension_in, defines_term_for, belongs_to,
-references, related_to, fills_slot, commits_to, informed_by, depends_on,
-conflicts_with, confused_with, replaces, part_of, constrains,
-governed_by, alternative_to, has_proposal, requests_promotion_of, resolves,
-anchored_to, authority_domain, domain_routed_to
+## Valid Relation Types (${ALLOWED_RELATION_TYPES_LIST.length})
+${ALLOWED_RELATION_TYPES_LIST.join(", ")}
 
 ## Lifecycle Status
 Write via \`update\`: \`draft\` | \`archived\` (\`accepted\` via \`commit\`, never \`update\`). \`active\`/\`deprecated\` are legacy: readable, refused on write.
@@ -13872,7 +13942,7 @@ function buildOrientationMarkdown(collections, standards, businessRules, princip
     wsRules.push({ id: s.entryId ?? "", name: s.name, severity: s.data?.severity ?? void 0, source: "standards" });
   }
   for (const r of businessRules ?? []) {
-    wsRules.push({ id: r.entryId ?? "", name: r.name, severity: r.data?.severity ?? void 0, source: "business-rules" });
+    wsRules.push({ id: r.entryId ?? "", name: r.name, severity: r.data?.severity ?? void 0, source: "rules" });
   }
   if (wsRules.length > 0) {
     const ruleLines2 = wsRules.map((r) => {
@@ -13887,7 +13957,7 @@ These are principles, standards, and rules your team has accepted onto the Chain
     );
   } else {
     sections.push(
-      "## Your Workspace Principles & Rules\nNo active principles, standards, or business rules on the Chain yet.\nUse `capture` with collection `principles`, `standards`, or `business-rules` to add your team's guardrails.\nOnce accepted, they appear here at orient time \u2014 so every agent session starts with your rules visible."
+      "## Your Workspace Principles & Rules\nNo active principles, standards, or rules on the Chain yet.\nUse `capture` with collection `principles`, `standards`, or `rules` to add your team's guardrails.\nOnce accepted, they appear here at orient time \u2014 so every agent session starts with your rules visible."
     );
   }
   sections.push(
@@ -13916,14 +13986,14 @@ Tags for filtering (e.g. \`severity:high\`), relations via \`entryRelations\`, v
   }
   const rulesCount = businessRules ? `${businessRules.length} entries` : "not loaded \u2014 collection may not exist yet";
   sections.push(
-    `## Business Rules
-Collection: \`business-rules\` (${rulesCount}).
-Find rules: \`entries action=search\` for text search, \`entries action=list collection=business-rules\` to browse.
+    `## Rules
+Collection: \`rules\` (${rulesCount}).
+Find rules: \`entries action=search\` for text search, \`entries action=list collection=rules\` to browse.
 Check compliance: use the \`review-against-rules\` prompt (pass a domain).
 Draft a new rule: use the \`draft-rule-from-context\` prompt.`
   );
   sections.push(
-    "## Knowledge Graph\nEntries are connected via typed relations (`entryRelations` table). Relations are bidirectional and collection-agnostic \u2014 any entry can link to any other entry.\n\n**Recommended relation types** (extensible \u2014 any string accepted):\n- `governs` \u2014 a rule constrains behavior of a feature\n- `defines_term_for` \u2014 a glossary term is canonical vocabulary for a feature/area\n- `belongs_to` \u2014 a feature belongs to a product area or parent concept (typed successors: `anchored_to`, `authority_domain`)\n- `informs` \u2014 a decision or insight informs a feature\n- `surfaces_tension_in` \u2014 a tension exists within a feature area\n- `related_to`, `depends_on`, `replaces`, `conflicts_with`, `references`, `confused_with`\n\nEach relation type is defined as a glossary entry (prefix `GT-REL-*`) to prevent terminology drift. **Workflow-owned, NOT generic:** `domain_routed_to` (a question routed to a domain) \u2014 use the `question` tool (`action=create`/`adopt`, `domain=<slug>`), never `relations action=create`; the generic door has no replace/re-judge logic, so a raw write can leave duplicate routing edges and a stale suggested owner.\n\n**Tools:**\n- `context action=gather` \u2014 get the full context around any entry (multi-hop graph traversal)\n- `relations action=suggest` \u2014 discover potential connections for an entry\n- `relations action=create` \u2014 create a typed link between two entries\n- `relations action=find` \u2014 list direct relations for an entry\n\n**Convention:** When creating or updating entries in governed collections, always use `relations action=suggest` to discover and create relevant relations."
+    "## Knowledge Graph\nEntries are connected via typed relations (`entryRelations` table). Relations are bidirectional and collection-agnostic \u2014 any entry can link to any other entry.\n\n**Recommended relation types** (extensible \u2014 any string accepted):\n- `governs` \u2014 a rule constrains behavior of a feature\n- `defines_term_for` \u2014 a glossary term is canonical vocabulary for a feature/area\n- `belongs_to` \u2014 a feature belongs to a product area or parent concept (typed successor: `anchored_to`)\n- `informs` \u2014 a decision or insight informs a feature\n- `surfaces_tension_in` \u2014 a tension exists within a feature area\n- `related_to`, `depends_on`, `replaces`, `conflicts_with`, `references`, `confused_with`\n\nEach relation type is defined as a glossary entry (prefix `GT-REL-*`) to prevent terminology drift.\n\n**Tools:**\n- `context action=gather` \u2014 get the full context around any entry (multi-hop graph traversal)\n- `relations action=suggest` \u2014 discover potential connections for an entry\n- `relations action=create` \u2014 create a typed link between two entries\n- `relations action=find` \u2014 list direct relations for an entry\n\n**Convention:** When creating or updating entries in governed collections, always use `relations action=suggest` to discover and create relevant relations."
   );
   sections.push(
     `## Creating Knowledge
@@ -13955,7 +14025,7 @@ async function buildOrientationResourceText(kernelQuery2, agentSessionId) {
   const [collectionsResult, standardsResult, rulesResult, principlesResult, orientViewResult] = await Promise.allSettled([
     kernelQuery2("chain.listCollections"),
     kernelQuery2("chain.listEntries", { collectionSlug: "standards" }),
-    kernelQuery2("chain.listEntries", { collectionSlug: "business-rules" }),
+    kernelQuery2("chain.listEntries", { collectionSlug: "rules" }),
     kernelQuery2("chain.listEntries", { collectionSlug: "principles" }),
     kernelQuery2("chain.getOrientView", {
       tier: "summary",
@@ -14345,8 +14415,8 @@ ${entry.labels.map((l) => `- ${l.name ?? l.slug}`).join("\n")}`);
 // src/prompts/index.ts
 import { z as z34 } from "zod/v3";
 async function buildReviewAgainstRulesPrompt(domain) {
-  const entries = await kernelQuery("chain.listEntries", { collectionSlug: "business-rules" });
-  const rules = entries.filter((e) => e.data?.domain === domain);
+  const entries = await kernelQuery("chain.listEntries", { collectionSlug: "rules" });
+  const rules = entries.slice(0, 50);
   if (rules.length === 0) {
     return {
       messages: [
@@ -14354,7 +14424,7 @@ async function buildReviewAgainstRulesPrompt(domain) {
           role: "user",
           content: {
             type: "text",
-            text: `No business rules found for domain "${domain}". Use \`entries action=list collection=business-rules\` to see available domains.`
+            text: `No rules found. Use \`entries action=list collection=rules\` to see available rules.`
           }
         }
       ]
@@ -14362,12 +14432,10 @@ async function buildReviewAgainstRulesPrompt(domain) {
   }
   const rulesText = rules.map(
     (r) => `### ${r.entryId ?? ""}: ${r.name}
-Status: ${r.status} | Severity: ${r.data?.severity ?? "unknown"}
-Description: ${readEntryBody(r.data, "description") ?? ""}
-Data Impact: ${r.data?.dataImpact ?? ""}
-Platforms: ${(r.data?.platforms ?? []).join(", ")}
-` + (r.data?.conflictWith ? `CONFLICT: ${r.data.conflictWith.rule} \u2014 ${r.data.conflictWith.nature}
-` : "")
+Status: ${r.status} | Applies: ${r.data?.applies ?? "unspecified"}
+Body: ${readEntryBody(r.data, "body") ?? ""}
+Why: ${r.data?.why ?? ""}
+`
   ).join("\n---\n\n");
   return {
     messages: [
@@ -14375,14 +14443,14 @@ Platforms: ${(r.data?.platforms ?? []).join(", ")}
         role: "user",
         content: {
           type: "text",
-          text: `Review the current code or design against the following business rules for the "${domain}" domain.
+          text: `Review the current code or design against the following rules, focusing on the "${domain}" area.
 
 For each rule, assess:
 1. Is the current implementation compliant?
 2. Are there potential violations or edge cases?
 3. What specific changes would be needed for compliance?
 
-Business Rules:
+Rules (up to 50):
 
 ${rulesText}
 
@@ -14426,7 +14494,7 @@ Format as a table: Name | Status | Canonical Form | Action Needed`
 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.",
+    "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')") },
     async ({ domain }) => buildReviewAgainstRulesPrompt(domain)
   );
@@ -14440,38 +14508,7 @@ function registerPrompts(server) {
     "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...')") },
-    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);
-      const recentContext = sorted.length > 0 ? sorted.map((d) => `- [${d.status}] ${d.name} (${d.data?.date ?? "no date"})`).join("\n") : "No previous decisions recorded.";
-      return {
-        messages: [
-          {
-            role: "user",
-            content: {
-              type: "text",
-              text: `Draft a structured decision record from the following context:
-
-"${context}"
-
-Recent decisions for reference:
-${recentContext}
-
-Structure the decision record with:
-1. **Title**: Concise decision statement
-2. **Decided by**: Who made or approved this decision
-3. **Date**: When it was decided
-4. **Status**: decided / proposed / revisited
-5. **Rationale**: Why this decision was made, including trade-offs considered
-6. **Alternatives considered**: What else was on the table
-7. **Related rules or tensions**: Any business rules or tensions this connects to
-
-After drafting, I can log it using the capture tool with collection "decisions".`
-            }
-          }
-        ]
-      };
-    }
+    async ({ context }) => buildDraftDecisionRecordPrompt(context)
   );
   server.prompt(
     "draft-rule-from-context",
@@ -14483,35 +14520,62 @@ After drafting, I can log it using the capture tool with collection "decisions".
     async ({ observation, domain }) => buildDraftRuleFromContextPrompt(observation, domain)
   );
 }
+async function buildDraftDecisionRecordPrompt(context) {
+  const recentDecisions = await kernelQuery("chain.listEntries", { collectionSlug: "decisions" });
+  const created = (d) => d.createdAt ?? 0;
+  const sorted = [...recentDecisions].sort((a, b) => created(b) - created(a)).slice(0, 5);
+  const recentContext = sorted.length > 0 ? sorted.map((d) => `- [${d.status}] ${d.name}`).join("\n") : "No previous decisions recorded.";
+  return {
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `Draft a structured decision record from the following context:
+
+"${context}"
+
+Recent decisions for reference:
+${recentContext}
+
+Structure the decision record with:
+1. **Title**: Concise decision statement
+2. **Body**: What was decided, including the alternatives considered and the trade-offs
+3. **Why**: The reason behind the decision
+4. **Related rules or tensions**: Any business rules or tensions this connects to
+
+Who decided it and when are recorded by the Chain itself; do not add them as fields. After drafting, I can log it using the capture tool with collection "decisions".`
+        }
+      }
+    ]
+  };
+}
 async function buildDraftRuleFromContextPrompt(observation, domain) {
-  const allRules = await kernelQuery("chain.listEntries", { collectionSlug: "business-rules" });
-  const existingRules = allRules.filter((r) => r.data?.domain === domain);
-  const existingContext = existingRules.length > 0 ? existingRules.map((r) => `${r.entryId ?? ""}: ${r.name} [${r.status}] \u2014 ${readEntryBody(r.data, "description") ?? ""}`).join("\n") : "No existing rules for this domain.";
+  const allRules = await kernelQuery("chain.listEntries", { collectionSlug: "rules" });
+  const existingRules = allRules.slice(0, 25);
+  const existingContext = existingRules.length > 0 ? existingRules.map((r) => `${r.entryId ?? ""}: ${r.name} [${r.status}] \u2014 ${readEntryBody(r.data, "body") ?? ""}`).join("\n") : "No existing rules for this domain.";
   return {
     messages: [
       {
         role: "user",
         content: {
           type: "text",
-          text: `Draft a business rule based on this observation:
+          text: `Draft a rule based on this observation:
 
 "${observation}"
 
 Domain: ${domain}
 
-Existing rules in this domain:
+Existing rules (up to 25):
 ${existingContext}
 
-Draft the rule with these fields (do not specify entryId \u2014 Convex assigns sequential IDs automatically, e.g. <PREFIX>-<n>):
+Draft the rule with these fields (do not specify entryId \u2014 Convex assigns sequential IDs automatically, e.g. RULE-<n>):
 1. **name**: Concise rule title
-2. **data.description**: What the rule states
-3. **data.rationale**: Why this rule matters
-4. **data.dataImpact**: How this affects data models, APIs, or storage
-5. **data.severity**: high / medium / low
-6. **data.platforms**: Which platforms are affected
-7. **data.relatedRules**: Any related existing rules
-
-Make sure the rule is consistent with existing rules and doesn't contradict them. After drafting, I can create it using the capture tool with collection "business-rules".`
+2. **data.body**: What the rule states, and whether it is an enforced invariant or a belief you reason from
+3. **data.why**: Why this rule matters
+4. **data.applies**: everyone / team / role (optional)
+
+Make sure the rule is consistent with existing rules and doesn't contradict them. After drafting, I can create it using the capture tool with collection "rules".`
         }
       }
     ]
@@ -14638,4 +14702,4 @@ export {
   createProductBrainServer,
   initFeatureFlags
 };
-//# sourceMappingURL=chunk-RLXYUP6A.js.map
+//# sourceMappingURL=chunk-BIHHHC2H.js.map