@productbrain/mcp 0.0.1-beta.5561 → 0.0.1-beta.5572

package/dist/{chunk-Y2JXPTBG.js → chunk-C5BIZH5N.js}

@@ -42,7 +42,7 @@ import {
   trackSessionCaptureRate,
   trackWriteBackHintServed,
   trackZeroCaptureAuditFired
-} from "./chunk-O53EBDOP.js";
+} from "./chunk-AFWQI35U.js";
 
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -15634,10 +15634,10 @@ function formatSection(label, rows, truncated, cursorHint) {
   return lines;
 }
 function formatRoleAccountable(result2) {
-  const roleLabel = `${sanitizeSingleLineField(result2.role.name)} (${result2.role.entryId ?? result2.role.id})`;
+  const roleLabel2 = `${sanitizeSingleLineField(result2.role.name)} (${result2.role.entryId ?? result2.role.id})`;
   const explicitCursorHint = result2.nextCursor !== null ? `raise limit or continue with cursor ${result2.nextCursor}` : "raise limit";
   return [
-    `${roleLabel} \u2014 accountability:`,
+    `${roleLabel2} \u2014 accountability:`,
     ...formatSection("explicit (owns)", result2.explicit, result2.explicitTruncated, explicitCursorHint),
     ...formatSection("reporting (reports on)", result2.reporting, result2.reportingTruncated),
     `  inherited: not-computed \u2014 ${result2.inheritedNotComputedReason}`
@@ -15689,6 +15689,234 @@ function registerRoleTools(server) {
   );
 }
 
+// src/tools/outcome.ts
+import { z as z35 } from "zod/v3";
+var OUTCOME_ACTIONS = ["record", "list", "show"];
+var READING_KINDS = ["measurement", "estimate", "correction"];
+var outcomeSchema = z35.object({
+  action: z35.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: z35.string().max(200).optional().describe("The key result (or other outcome-bearing) entry, by its chain id. Required for all three actions."),
+  value: z35.number().optional().describe("'record': the measured value. Required for 'record'."),
+  valueText: z35.string().max(500).optional().describe("'record': verbatim as-reported form when the source was not clean, e.g. '~62%'. Display only."),
+  asOf: z35.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: z35.enum(READING_KINDS).optional().describe("'record': measurement | estimate | correction (default: measurement)."),
+  correctsReadingId: z35.string().max(200).optional().describe("'record': required with kind='correction' \u2014 the reading id this replaces. Refused if that row is already superseded."),
+  recordedByRoleId: z35.string().max(200).optional().describe("'record': the accountable role (default: the entry's reporterRoleId, then ownerRoleId)."),
+  note: z35.string().max(2e3).optional().describe("'record': free-text note recorded with the reading."),
+  source: z35.string().max(500).optional().describe("'record': where the number came from \u2014 a dashboard name, a query, a URL."),
+  limit: z35.number().int().positive().max(200).optional().describe("'list': max rows to return (default and maximum 200).")
+});
+var recordVariant = z35.object({
+  action: z35.literal("record"),
+  entryId: z35.string().max(200),
+  value: z35.number(),
+  valueText: z35.string().max(500).optional(),
+  asOf: z35.string().max(64).optional(),
+  kind: z35.enum(READING_KINDS).optional(),
+  correctsReadingId: z35.string().max(200).optional(),
+  recordedByRoleId: z35.string().max(200).optional(),
+  note: z35.string().max(2e3).optional(),
+  source: z35.string().max(500).optional()
+});
+var listVariant2 = z35.object({
+  action: z35.literal("list"),
+  entryId: z35.string().max(200),
+  limit: z35.number().int().positive().max(200).optional()
+});
+var showVariant = z35.object({ action: z35.literal("show"), entryId: z35.string().max(200) });
+var outcomeActionUnion = z35.discriminatedUnion("action", [recordVariant, listVariant2, showVariant]);
+var OUTCOME_ACTION_SPECS = {
+  record: {
+    params: ["entryId", "value", "valueText", "asOf", "kind", "correctsReadingId", "recordedByRoleId", "note", "source"],
+    description: "entryId and value are required; the rest are optional."
+  },
+  list: { params: ["entryId", "limit"], description: "entryId is required; limit is optional." },
+  show: { params: ["entryId"], description: "entryId is required." }
+};
+function formatRecordReceipt(numericValue, entryId, valueText, receipt) {
+  const tier = receipt.independenceTier ?? "unknown";
+  const lines = [
+    `Recorded ${numericValue}${valueText ? ` ("${sanitizeSingleLineField(valueText)}")` : ""} on ${sanitizeSingleLineField(entryId)}.`,
+    `  attributed: ${receipt.actorKind ?? "unknown"} \xB7 independence: ${tier}`
+  ];
+  if (tier === "provenance_unknown") {
+    lines.push("  (no session named, so provenance is unknown \u2014 that is the honest answer, not an error)");
+  }
+  return lines.join("\n");
+}
+function formatReadingsList(entryId, result2) {
+  const safeEntryId = sanitizeSingleLineField(entryId);
+  const rows = result2?.readings ?? [];
+  if (rows.length === 0) return `No readings recorded on ${safeEntryId} yet.`;
+  const lines = rows.map((row) => {
+    const when = new Date(row.asOf).toISOString().slice(0, 10);
+    const superseded = row.supersededByReadingId ? `  <- superseded by ${row.supersededByReadingId}` : "";
+    const text = row.valueText ? ` ("${sanitizeSingleLineField(row.valueText)}")` : "";
+    const note = row.note ? `  - ${sanitizeSingleLineField(row.note)}` : "";
+    return `  ${when}  ${String(row.value).padStart(8)}${text}  [${row.kind}\xB7${row.independenceTier}]  ${row.readingId}${note}${superseded}`;
+  });
+  const tail = result2?.pageExhausted === false ? "\n  (older readings not loaded - raise --limit)" : "";
+  return `${rows.length} reading(s) on ${safeEntryId}, newest first:
+${lines.join("\n")}${tail}`;
+}
+var pct = (v, unit = "%") => v === void 0 ? "\u2014" : `${Math.round(v * 10) / 10}${unit}`;
+var roleLabel = (role) => role === null ? "not set" : role.name === null ? "a role that no longer exists" : sanitizeSingleLineField(role.name);
+function formatOutcomeShow(result2) {
+  if (!result2) return "No outcome found.";
+  const o = result2.outcome;
+  const unit = o.unit ? ` ${sanitizeSingleLineField(o.unit)}` : "";
+  const lines = [
+    `${sanitizeSingleLineField(result2.entryId)} \u2014 ${sanitizeSingleLineField(result2.name)}`,
+    `  metric      ${o.metric ? sanitizeSingleLineField(o.metric) : "not set"}`,
+    `  current     ${o.current ? `${o.current.value}${unit}` : "no readings yet"}   (${o.readingCount} reading(s))`,
+    `  progress    ${pct(o.progressPct)}   direction ${o.direction}`,
+    `  pace        ${pct(o.pacePct)}   ${o.pacePct === void 0 ? "(no cycle end set)" : o.pacePct >= 0 ? "(ahead of pace)" : "(behind pace)"}`,
+    `  state       ${o.state}${o.hasNoReadings ? " \u2014 never read" : ""}${o.overdueByMs ? ` (by ${Math.floor(o.overdueByMs / 864e5)}d)` : ""}`,
+    `  next due    ${o.nextDueAt ? new Date(o.nextDueAt).toISOString().slice(0, 10) : "no cadence set"}`,
+    `  owner       ${roleLabel(o.ownerRole)}`,
+    `  reporter    ${roleLabel(o.reporterRole)}`,
+    `  completion  recorded as ${o.completion} (source: ${o.completionProvenance})`,
+    `  attestation weakest in cycle: ${o.weakestTierInCycle ?? "none recorded"} \u2014 reported, not enforced`
+  ];
+  if (o.currentResolution === "page-exhausted") {
+    lines.push('  note        every loaded reading is superseded and more remain \u2014 this is not "never read"');
+  }
+  if (result2.readyToCloseInstruction) {
+    lines.push("", `  ${result2.readyToCloseInstruction}`);
+  }
+  return lines.join("\n");
+}
+function outcomeErrorResult(err, action, entryId, params = {}) {
+  const classified = classifyError(err);
+  const definedParams = Object.fromEntries(Object.entries(params).filter(([, v]) => v !== void 0));
+  const isUnverifiedRecordTimeout = action === "record" && classified.code === "GATEWAY_TIMEOUT";
+  const defaultActions = isUnverifiedRecordTimeout ? [
+    { tool: "outcome", description: "Check whether the reading already landed", parameters: { action: "list", entryId } },
+    { tool: "outcome", description: "Check the derived view", parameters: { action: "show", entryId } }
+  ] : [{ tool: "outcome", description: `Retry ${action}`, parameters: { action, ...definedParams } }];
+  return failureResult(
+    classified.message,
+    classified.code,
+    classified.message,
+    classified.recovery ?? "Use action='show' or action='list' with a valid entryId to check the key result exists.",
+    classified.availableActions ?? defaultActions,
+    classified.diagnostics
+  );
+}
+async function handleOutcomeRecord(entryId, value, opts = {}) {
+  requireWriteAccess();
+  if (opts.correctsReadingId !== void 0 && opts.kind !== "correction") {
+    return failureResult(
+      "correctsReadingId is only meaningful with kind='correction'.",
+      "VALIDATION_ERROR",
+      "correctsReadingId is only meaningful with kind='correction'.",
+      "Set kind='correction', or drop correctsReadingId to record an ordinary reading."
+    );
+  }
+  if (opts.kind === "correction" && opts.correctsReadingId === void 0) {
+    return failureResult(
+      "kind='correction' requires correctsReadingId.",
+      "VALIDATION_ERROR",
+      "kind='correction' requires correctsReadingId.",
+      "A correction must name the reading it replaces \u2014 find it with action='list'."
+    );
+  }
+  let asOf;
+  if (opts.asOf !== void 0) {
+    const parsed = Date.parse(opts.asOf);
+    if (Number.isNaN(parsed)) {
+      return failureResult(
+        `asOf must be a parseable date (got "${opts.asOf}").`,
+        "VALIDATION_ERROR",
+        `asOf must be a parseable date (got "${opts.asOf}").`,
+        "Example: asOf='2026-03-01'. Back-dating is legitimate \u2014 a backfill shows up as asOf earlier than recordedAt."
+      );
+    }
+    asOf = parsed;
+  }
+  try {
+    const agentSessionId = getAgentSessionId();
+    const receipt = await kernelMutation("outcomes.recordReading", {
+      entryId,
+      value,
+      ...asOf !== void 0 ? { asOf } : {},
+      ...opts.kind ? { kind: opts.kind } : {},
+      ...opts.correctsReadingId ? { correctsReadingId: opts.correctsReadingId } : {},
+      ...opts.recordedByRoleId ? { recordedByRoleId: opts.recordedByRoleId } : {},
+      ...opts.note ? { note: opts.note } : {},
+      ...opts.source ? { source: opts.source } : {},
+      ...opts.valueText ? { valueText: opts.valueText } : {},
+      ...agentSessionId ? { agentSessionId } : {}
+    });
+    const message = formatRecordReceipt(value, entryId, opts.valueText, receipt);
+    return successResult(message, message, receipt);
+  } catch (err) {
+    return outcomeErrorResult(err, "record", entryId, { entryId, value, ...opts });
+  }
+}
+async function handleOutcomeList(entryId, limit) {
+  try {
+    const result2 = await kernelQuery("outcomes.listReadings", {
+      entryId,
+      ...limit !== void 0 ? { limit } : {}
+    });
+    const message = formatReadingsList(entryId, result2);
+    return successResult(message, message, result2);
+  } catch (err) {
+    return outcomeErrorResult(err, "list", entryId, { entryId, limit });
+  }
+}
+async function handleOutcomeShow(entryId) {
+  try {
+    const result2 = await kernelQuery("outcomes.showOutcome", { entryId });
+    const message = formatOutcomeShow(result2);
+    return successResult(message, message, result2);
+  } catch (err) {
+    return outcomeErrorResult(err, "show", entryId, { entryId });
+  }
+}
+function registerOutcomeTools(server) {
+  const outcomeHandlers = {
+    record: (data) => handleOutcomeRecord(data.entryId, data.value, {
+      valueText: data.valueText,
+      asOf: data.asOf,
+      kind: data.kind,
+      correctsReadingId: data.correctsReadingId,
+      recordedByRoleId: data.recordedByRoleId,
+      note: data.note,
+      source: data.source
+    }),
+    list: (data) => handleOutcomeList(data.entryId, data.limit),
+    show: (data) => handleOutcomeShow(data.entryId)
+  };
+  server.registerTool(
+    "outcome",
+    {
+      title: "Outcome",
+      description: (
+        // Chain IDs stay OUT of this user-facing string (check:chain-id-leaks) — same
+        // precedent role.ts's own docblock names for its Team-Lead-vacancy sentence.
+        "Key-result outcomes \u2014 record and read the measured readings behind a number. Three actions:\n\n- **record**: Record a reading \u2014 evidence, not a verdict; any connector may record one.\n- **list**: List readings, newest first; superseded rows are shown and marked with their replacement.\n- **show**: The derived view \u2014 current, progress, pace, staleness, recorded completion and its provenance, and any close proposal."
+      ),
+      inputSchema: outcomeSchema,
+      // Mixed read/write noun (same as shape's list/show read, agree/dismiss write): record
+      // writes; list/show read.
+      annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false }
+    },
+    thinWrapper(async (args) => {
+      const parsed = parseOrFail(outcomeSchema, args);
+      if (!parsed.ok) return parsed.result;
+      const { action } = parsed.data;
+      return runWithToolContext(
+        { tool: "outcome", action },
+        () => dispatchDiscriminated("outcome", outcomeActionUnion, parsed.data, OUTCOME_ACTION_SPECS, outcomeHandlers)
+      );
+    })
+  );
+}
+
 // src/resources/index.ts
 import { existsSync as existsSync3 } from "fs";
 import { dirname, join, resolve as resolve4 } from "path";
@@ -16201,12 +16429,12 @@ ${entry.labels.map((l) => `- ${l.name ?? l.slug}`).join("\n")}`);
 }
 
 // src/prompts/index.ts
-import { z as z35 } from "zod/v3";
+import { z as z36 } 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: z35.string().describe("Business rule domain (e.g. 'Identity & Access', 'Governance & Decision-Making')") },
+    { domain: z36.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);
@@ -16259,7 +16487,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: z35.string().describe("Comma-separated list of names to check (e.g. 'vendor_id, compliance_level, formulator_type')") },
+    { names: z36.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(
@@ -16295,7 +16523,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: z35.string().describe("Description of the decision (e.g. 'We decided to use MRSL v3.1 as the conformance baseline because...')") },
+    { context: z36.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);
@@ -16333,8 +16561,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: 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')")
+      observation: z36.string().describe("What you observed or discovered (e.g. 'Suppliers can have multiple org types in Gateway')"),
+      domain: z36.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" });
@@ -16473,6 +16701,7 @@ function createProductBrainServer() {
   registerShapeTools(server);
   registerQuestionTools(server);
   registerRoleTools(server);
+  registerOutcomeTools(server);
   if (enabledModules.has("gitchain")) registerGitChainTools(server);
   registerResources(server);
   registerPrompts(server);
@@ -16612,4 +16841,4 @@ export {
   createProductBrainServer,
   initFeatureFlags
 };
-//# sourceMappingURL=chunk-Y2JXPTBG.js.map
+//# sourceMappingURL=chunk-C5BIZH5N.js.map