@trazum/core 1.50.3 → 1.50.5

package/src/config-schema.ts

@@ -1,4 +1,5 @@
 import { BASELINE_FILENAME } from './baseline.js';
+import type { OutcomeVocabulary } from './outcome.js';
 import { mostSpecificMatch } from './glob.js';
 import type { PricingCatalogue } from './pricing.js';
 import { isLocale } from './i18n/index.js';
@@ -213,6 +214,21 @@ export interface TrazumConfig {
    * author's terminal and not in CI.
    */
   baseline?: BaselineConfig;
+  /**
+   * The product's own outcome vocabulary, and which values are successes.
+   *
+   * **Declared rather than guessed, and the second half is why.** `resolved`,
+   * `escalated`, `deflected`, `abandoned` — every product has its own words,
+   * and which of them count as success is a product judgement this tool has no
+   * standing to make. A tool that decided `escalated` was a failure would be
+   * wrong at every company where escalation is the correct, designed outcome
+   * for a whole class of request.
+   *
+   * A value in a log that this never declared is **named as undeclared**
+   * rather than bucketed into either side: a typo in an exporter should show up
+   * as a typo, not as a shift in the success rate.
+   */
+  outcomes?: OutcomeVocabulary;
   /** File extensions directory mode treats as prompts. */
   extensions?: string[];
   /**
@@ -244,6 +260,7 @@ export const CONFIG_KEYS = [
   'baseline',
   'extensions',
   'pricing',
+  'outcomes',
 ] as const;
 
 export const CONFIG_BASELINE_KEYS = ['path', 'maxGrowthTokens', 'maxGrowthPct'] as const;
@@ -254,6 +271,8 @@ export const CONFIG_WAIVE_KEYS = ['gate', 'reason', 'until'] as const;
 
 export const CONFIG_STORE_KEYS = ['keepDays'] as const;
 
+export const CONFIG_OUTCOME_KEYS = ['values', 'success'] as const;
+
 /**
  * The gates a waiver can silence. The list is closed on purpose: a waiver
  * naming a gate that does not exist is a decision about nothing, and the
@@ -561,6 +580,81 @@ function parseSources(raw: unknown, source: string): Record<string, string[]> {
  * gets deleted, and a policy the tool rounded on the operator's behalf is a
  * policy nobody agreed to.
  */
+/**
+ * `outcomes` — the product's own vocabulary, and which of it is success.
+ *
+ * The validation here is unusually strict for this file, and deliberately: an
+ * outcome vocabulary is the input to every rate this product will ever print,
+ * and a typo in it is a silent, permanent distortion of a number people make
+ * decisions on.
+ */
+function parseOutcomes(entry: unknown, source: string): OutcomeVocabulary {
+  if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+    throw new ConfigError(
+      `"outcomes" in ${source} must be an object, for example {"values": ["resolved", "escalated"], "success": ["resolved"]}.`,
+      source,
+    );
+  }
+  const raw = entry as Record<string, unknown>;
+  rejectUnknownKeys(raw, CONFIG_OUTCOME_KEYS, source, 'outcomes.');
+
+  const stringList = (value: unknown, key: string): string[] => {
+    if (
+      !Array.isArray(value) ||
+      value.some((item) => typeof item !== 'string' || item.trim() === '')
+    ) {
+      throw new ConfigError(
+        `"outcomes.${key}" in ${source} must be an array of non-empty strings.`,
+        source,
+      );
+    }
+    return value as string[];
+  };
+
+  if (raw.values === undefined) {
+    throw new ConfigError(`"outcomes.values" in ${source} is required.`, source);
+  }
+  const values = stringList(raw.values, 'values');
+  const duplicates = values.filter((value, index) => values.indexOf(value) !== index);
+  if (duplicates.length > 0) {
+    throw new ConfigError(
+      `"outcomes.values" in ${source} lists ${JSON.stringify(duplicates[0])} more than once.`,
+      source,
+    );
+  }
+
+  /**
+   * **Required, and allowed to be empty.**
+   *
+   * Required because which values mean success is the entire product judgement
+   * this tool refuses to make on somebody's behalf — a tool that decided
+   * `escalated` was a failure would be wrong at every company where escalation
+   * is the correct, designed outcome for a class of request. Leaving it
+   * optional would send that question straight back here, to be answered by a
+   * default nobody chose.
+   *
+   * Allowed to be empty because a product that records only failures has
+   * declared something real. The report then says it cannot state a rate,
+   * rather than inventing one.
+   */
+  if (raw.success === undefined) {
+    throw new ConfigError(
+      `"outcomes.success" in ${source} is required. Which of your outcome values count as success is a judgement about your product rather than about your bill, and this tool has no standing to make it. Use [] if none of them are.`,
+      source,
+    );
+  }
+  const success = stringList(raw.success, 'success');
+  const undeclared = success.filter((value) => !values.includes(value));
+  if (undeclared.length > 0) {
+    throw new ConfigError(
+      `"outcomes.success" in ${source} names ${undeclared.map((v) => JSON.stringify(v)).join(', ')}, which "outcomes.values" does not declare.`,
+      source,
+    );
+  }
+
+  return { values, success };
+}
+
 function parseStore(raw: unknown, source: string): { keepDays?: number } {
   if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
     throw new Error(`"store" in ${source} must be an object, for example {"keepDays": 90}.`);
@@ -770,6 +864,9 @@ export function parseConfig(raw: string, source = CONFIG_FILENAME): TrazumConfig
   if (document.sources !== undefined) config.sources = parseSources(document.sources, source);
   if (document.store !== undefined) config.store = parseStore(document.store, source);
   if (document.waive !== undefined) config.waive = parseWaive(document.waive, source);
+  if (document.outcomes !== undefined) {
+    config.outcomes = parseOutcomes(document.outcomes, source);
+  }
   if (document.baseline !== undefined) {
     config.baseline = parseBaselineConfig(document.baseline, source);
   }

package/src/index.ts

@@ -49,6 +49,29 @@ export type { PlanParseFailure, PlanParseResult } from './plan.js';
 export type { PlanAction, PlanActionKind, PlanAssumption, PlanDocument } from './plan.js';
 export { verifyPlan } from './verify.js';
 export { buildHistory, storedReportFrom, MIN_RUN } from './history.js';
+export { outcomeReport, judgeOutcome, OUTCOME_UNLOCKS } from './outcome.js';
+export {
+  perOutcome,
+  rankPerOutcome,
+  MIN_OUTCOMES_FOR_RATE,
+  MIN_COVERAGE_FOR_RATE,
+} from './per-outcome.js';
+export type {
+  PerOutcome,
+  PerOutcomeRanking,
+  RankedSlice,
+  SliceInput,
+  WithheldReason,
+} from './per-outcome.js';
+export type {
+  OutcomeCoverage,
+  OutcomeReport,
+  OutcomeSlice,
+  OutcomeTally,
+  OutcomeUnlock,
+  OutcomeVerdict,
+  OutcomeVocabulary,
+} from './outcome.js';
 export { gatewayDecision, usageFromResponse, FAILURE_POLICIES } from './gateway.js';
 export type {
   CannotTellCause,

package/src/outcome.ts

@@ -0,0 +1,214 @@
+/**
+ * The counterpart every figure in this product has been missing.
+ *
+ * Everything Trazum reports is a cost. It can say a workload got forty per cent
+ * cheaper and cannot say whether it stopped working — a denominator with no
+ * numerator, since the beginning. The missing field is not something this tool
+ * can compute. It is something only the caller knows.
+ *
+ * ## Recorded, never inferred
+ *
+ * The whole module rests on one refusal. **No absence of complaint counts as
+ * success. No short conversation counts as resolution. No retry counts as
+ * failure on its own.** Every one of those is a plausible-looking heuristic
+ * that would turn a guess into a metric, and a metric somebody would then
+ * optimise against — which is how a tool ends up rewarding conversations that
+ * end early because the user gave up.
+ *
+ * Where nothing was recorded, the report says so and names what recording one
+ * would unlock. That is the `fieldCoverage` discipline from 1.19, applied to
+ * the question that matters most.
+ *
+ * ## The vocabulary is declared, not guessed
+ *
+ * `resolved`, `escalated`, `deflected`, `abandoned`, `thumbs-down` — every
+ * product has its own words, and **which of them count as success is a product
+ * judgement this tool has no standing to make**. A tool that decided
+ * `escalated` was a failure would be wrong at every company where escalation is
+ * the correct, designed outcome for a whole class of request.
+ *
+ * So the config names the values and names which are successes. An outcome in
+ * the log that the config never declared is **named as undeclared**, not
+ * quietly bucketed into one side or the other — a typo in an exporter should
+ * show up as a typo, not as a shift in the success rate.
+ *
+ * ## The privacy line does not move
+ *
+ * An outcome is a small enumerated value. The store keeps it the way it has
+ * kept everything since 1.42: aggregated, never alongside content.
+ */
+
+/** What the config declares. Both halves are required; see the module note. */
+export interface OutcomeVocabulary {
+  /** Every value this product records. Anything else in a log is undeclared. */
+  values: string[];
+  /**
+   * Which of them count as success.
+   *
+   * A subset of `values`, and it may be empty — a vocabulary that records only
+   * failures is a legitimate thing to declare, and it still gives a rate this
+   * tool can report against a cost.
+   */
+  success: string[];
+}
+
+export type OutcomeVerdict = 'success' | 'other' | 'undeclared';
+
+/**
+ * How a single recorded value is judged. Three outcomes, never two.
+ *
+ * `other` is a declared value that is not a success. `undeclared` is a value
+ * nobody wrote down — which is a data-quality finding and not a result, and is
+ * reported as one.
+ */
+export function judgeOutcome(value: string | null, vocabulary: OutcomeVocabulary): OutcomeVerdict | null {
+  if (value === null) return null;
+  if (!vocabulary.values.includes(value)) return 'undeclared';
+  return vocabulary.success.includes(value) ? 'success' : 'other';
+}
+
+/** One value, and what it cost. */
+export interface OutcomeSlice {
+  value: string;
+  verdict: OutcomeVerdict;
+  calls: number;
+  usd: number;
+}
+
+export interface OutcomeCoverage {
+  /** Records that carried an outcome at all. */
+  recorded: number;
+  /** Every record that parsed — the denominator. */
+  parsed: number;
+  /**
+   * Spend on calls that carried no outcome.
+   *
+   * The figure that decides whether a success rate means anything. A rate
+   * computed over eight per cent of the bill is a rate about eight per cent of
+   * the bill, and printing it beside the total without this number is how a
+   * sample becomes a claim about the whole.
+   */
+  unrecordedUsd: number;
+}
+
+export interface OutcomeReport {
+  /** Per recorded value, dearest first. Empty when nothing was recorded. */
+  slices: OutcomeSlice[];
+  coverage: OutcomeCoverage;
+  /**
+   * Values found in the log that the config never declared, with what they
+   * cost. Named rather than bucketed: a typo in an exporter should surface as
+   * a typo and not as a shift in the success rate.
+   */
+  undeclared: OutcomeSlice[];
+  /**
+   * The success rate **by spend**, or null when it cannot honestly be stated.
+   *
+   * By spend rather than by call, because this product's whole subject is
+   * money: a success rate weighted by call count says one thing while the
+   * expensive half of the traffic fails, and the two figures diverge exactly
+   * when it matters.
+   *
+   * Null has one meaning and it is not zero: nothing was recorded. A rate of
+   * zero is a real, terrible measurement, and a tool that spells "nobody told
+   * me" the same way has destroyed the difference between them.
+   */
+  successShareOfRecordedUsd: number | null;
+  /**
+   * Why there is no rate, when there is none. A refusal never arrives bare.
+   */
+  noRate: 'nothing-recorded' | 'no-success-values-declared' | null;
+}
+
+/**
+ * What was recorded, before anybody judged it.
+ *
+ * Deliberately split from the report: `profileUsage` produces this while it
+ * reads a log, knowing nothing about which values mean success, and the
+ * judgement happens where the config is. Measurement and product judgement are
+ * different jobs and this is the seam between them.
+ *
+ * It is also an **aggregate**, never a list of records — the same shape the
+ * store has kept since 1.42. Counting outcomes never means keeping calls.
+ */
+export interface OutcomeTally {
+  /** Per recorded value: how many calls carried it and what they cost. */
+  byValue: Array<{ value: string; calls: number; usd: number }>;
+  recorded: number;
+  parsed: number;
+  unrecordedUsd: number;
+}
+
+export function outcomeReport(
+  tally: OutcomeTally,
+  vocabulary: OutcomeVocabulary | null,
+): OutcomeReport {
+  const coverage: OutcomeCoverage = {
+    recorded: tally.recorded,
+    parsed: tally.parsed,
+    unrecordedUsd: tally.unrecordedUsd,
+  };
+
+  /**
+   * With no vocabulary declared, every recorded value is `undeclared`.
+   *
+   * That is the honest reading rather than an inconvenience: somebody has been
+   * writing outcomes into a log the config never described, so this tool knows
+   * what happened and not what any of it means. It reports the values and their
+   * cost, and declines the rate.
+   */
+  const declared = vocabulary ?? { values: [], success: [] };
+
+  const all: OutcomeSlice[] = [...tally.byValue]
+    .map((entry) => ({
+      value: entry.value,
+      verdict: judgeOutcome(entry.value, declared) as OutcomeVerdict,
+      calls: entry.calls,
+      usd: entry.usd,
+    }))
+    .sort((a, b) => b.usd - a.usd);
+
+  const slices = all.filter((slice) => slice.verdict !== 'undeclared');
+  const undeclared = all.filter((slice) => slice.verdict === 'undeclared');
+
+  /**
+   * The rate's denominator is **declared, recorded spend** — not the whole
+   * bill, and not every recorded value.
+   *
+   * Undeclared values are left out of both halves rather than counted as
+   * failures. A misspelled `resolvd` is a broken exporter, and folding it into
+   * the failure side would report a product regression that never happened —
+   * the direction that gets somebody paged at four in the morning.
+   */
+  const declaredUsd = slices.reduce((sum, slice) => sum + slice.usd, 0);
+  const successUsd = slices
+    .filter((slice) => slice.verdict === 'success')
+    .reduce((sum, slice) => sum + slice.usd, 0);
+
+  let successShareOfRecordedUsd: number | null = null;
+  let noRate: OutcomeReport['noRate'] = null;
+  if (declared.success.length === 0) {
+    noRate = 'no-success-values-declared';
+  } else if (declaredUsd <= 0) {
+    noRate = 'nothing-recorded';
+  } else {
+    successShareOfRecordedUsd = successUsd / declaredUsd;
+  }
+
+  return { slices, coverage, undeclared, successShareOfRecordedUsd, noRate };
+}
+
+/**
+ * What recording an outcome would unlock, for a report that has none.
+ *
+ * Named rather than implied. "No outcome recorded" on its own reads as a
+ * missing feature; the point is that one small enumerated field turns every
+ * cost figure in this product into a cost *per* something.
+ */
+export const OUTCOME_UNLOCKS = [
+  'cost-per-outcome',
+  'success-rate-by-spend',
+  'cheaper-and-still-working',
+] as const;
+
+export type OutcomeUnlock = (typeof OUTCOME_UNLOCKS)[number];

package/src/per-outcome.ts

@@ -0,0 +1,235 @@
+/**
+ * Dollars per outcome — and the three ways this refuses to state one.
+ *
+ * 1.50.4 recorded the numerator. This divides by it, which sounds like
+ * arithmetic and is almost entirely a set of decisions about when *not* to do
+ * the arithmetic. A cost per resolution is the most quotable number this
+ * product will ever print — it ends up in a slide, in a quarterly review, in an
+ * argument about whether to keep a feature — and every way of getting it
+ * slightly wrong is a way of getting somebody's decision badly wrong.
+ *
+ * ## Which bill is the numerator
+ *
+ * The obvious implementation divides the **whole** slice bill by its successes.
+ * It is wrong, and wrong in the direction that makes a product look worse than
+ * it is: any call that carried no outcome is spend with no chance of appearing
+ * in the denominator, so the ratio is inflated by exactly the uninstrumented
+ * share — silently, and by an amount nobody can see from the figure.
+ *
+ * A team that instruments half its traffic would read a cost per resolution
+ * twice the real one, conclude the feature is uneconomic, and kill it.
+ *
+ * So the numerator is **recorded spend only**: the dollars on calls that
+ * carried an outcome. That makes it a ratio over a sample, which is fine and
+ * only fine because the coverage is stated beside it every single time, and
+ * because below a floor it is not stated at all.
+ *
+ * ## Three refusals
+ *
+ * 1. **Too few outcomes is not a rate.** Two resolutions and one figure is
+ *    noise with a dollar sign. The count is shown instead — the same refusal
+ *    `route` makes about small case sets and `history` makes about short runs.
+ * 2. **Too little coverage is not a rate.** A slice where an eighth of the
+ *    spend carried an outcome yields a ratio over an unknown denominator. The
+ *    coverage is shown instead.
+ * 3. **No successes recorded is not a rate of infinity.** A slice that spent
+ *    money and resolved nothing is a real and alarming measurement, and it is
+ *    reported as what it is rather than as a division by zero dressed up.
+ *
+ * ## Two rankings, and the product prints both
+ *
+ * Cheapest per call and cheapest per outcome are **different orders**, and the
+ * whole reason this chapter exists is that a workload can move up one while
+ * moving down the other. Picking one would be this tool making the choice it
+ * spent the last release refusing to make. Both are returned; the disagreement
+ * between them is itself a finding, and it is named.
+ */
+
+import { judgeOutcome } from './outcome.js';
+import type { OutcomeTally, OutcomeVocabulary } from './outcome.js';
+
+/**
+ * Recorded successes a slice needs before a per-outcome figure is stated.
+ *
+ * Ten, matching `history`'s `MIN_RUN` reasoning rather than a fresh number: a
+ * figure over fewer than ten observations moves more from one more observation
+ * than from anything a team could do about it.
+ */
+export const MIN_OUTCOMES_FOR_RATE = 10;
+
+/**
+ * Share of a slice's spend that must carry an outcome before a rate is stated.
+ *
+ * 0.8, the same floor `watch` uses for a measured day. Below it the figure is a
+ * ratio over an unknown denominator, and the gap between what it says and what
+ * is true is not bounded by anything the reader can see.
+ */
+export const MIN_COVERAGE_FOR_RATE = 0.8;
+
+export type WithheldReason =
+  | 'too-few-outcomes'
+  | 'too-little-coverage'
+  | 'no-successes-recorded'
+  | 'no-vocabulary'
+  | 'nothing-recorded';
+
+export interface PerOutcome {
+  /**
+   * Dollars per recorded success, over **recorded spend only**, or null.
+   *
+   * Null is never a zero and never an infinity: `withheld` says which of the
+   * five reasons applies, and a caller that prints the figure without reading
+   * that field will print nothing rather than something wrong.
+   */
+  usdPerSuccess: number | null;
+  withheld: WithheldReason | null;
+  /** Successes counted. Shown in place of the rate when it is withheld. */
+  successes: number;
+  /** Spend on calls that carried a declared outcome — the numerator. */
+  recordedUsd: number;
+  /** Everything the slice spent, recorded or not — for the coverage share. */
+  totalUsd: number;
+  /**
+   * Recorded share of the slice's spend, 0-1. Printed beside the rate every
+   * time it is printed, because a ratio over a sample presented without its
+   * sample size is a claim about the whole.
+   */
+  coverage: number;
+}
+
+export function perOutcome(
+  tally: OutcomeTally,
+  totalUsd: number,
+  vocabulary: OutcomeVocabulary | null,
+): PerOutcome {
+  const declared = vocabulary ?? { values: [], success: [] };
+
+  let successes = 0;
+  let recordedUsd = 0;
+  for (const entry of tally.byValue) {
+    const verdict = judgeOutcome(entry.value, declared);
+    // Undeclared values are in neither the numerator nor the denominator, the
+    // same rule the success rate has: a typo in an exporter is a broken
+    // exporter, not a result.
+    if (verdict === 'undeclared') continue;
+    recordedUsd += entry.usd;
+    if (verdict === 'success') successes += entry.calls;
+  }
+
+  const coverage = totalUsd > 0 ? recordedUsd / totalUsd : 0;
+  const base: Omit<PerOutcome, 'usdPerSuccess' | 'withheld'> = {
+    successes,
+    recordedUsd,
+    totalUsd,
+    coverage,
+  };
+
+  if (vocabulary === null || declared.success.length === 0) {
+    return { ...base, usdPerSuccess: null, withheld: 'no-vocabulary' };
+  }
+  if (tally.recorded === 0) {
+    return { ...base, usdPerSuccess: null, withheld: 'nothing-recorded' };
+  }
+  if (successes === 0) {
+    // Money spent and nothing resolved. A real and alarming measurement, and
+    // reported as one rather than as a division by zero dressed up as a figure.
+    return { ...base, usdPerSuccess: null, withheld: 'no-successes-recorded' };
+  }
+  if (successes < MIN_OUTCOMES_FOR_RATE) {
+    return { ...base, usdPerSuccess: null, withheld: 'too-few-outcomes' };
+  }
+  if (coverage < MIN_COVERAGE_FOR_RATE) {
+    return { ...base, usdPerSuccess: null, withheld: 'too-little-coverage' };
+  }
+  return { ...base, usdPerSuccess: recordedUsd / successes, withheld: null };
+}
+
+export interface RankedSlice {
+  key: string;
+  calls: number;
+  totalUsd: number;
+  per: PerOutcome;
+  /** Dollars per call — the ranking this product has always been able to make. */
+  usdPerCall: number;
+}
+
+export interface PerOutcomeRanking {
+  /** Dearest per call first. Every slice appears. */
+  byCall: RankedSlice[];
+  /**
+   * Dearest per **outcome** first. Only slices with a stated rate appear —
+   * a withheld figure has no position in an order, and giving it one would put
+   * a slice somewhere on the strength of a number this module declined to
+   * state.
+   */
+  byOutcome: RankedSlice[];
+  /**
+   * Slices whose two ranks disagree by more than a place, dearest-per-outcome
+   * first.
+   *
+   * **The finding a total cannot make**: the workload that looks cheap per
+   * call and is expensive per resolution, or the reverse. Somebody optimising
+   * on the first number has been moving the wrong one, and nothing in this
+   * product could tell them until now.
+   */
+  disagreements: Array<{ slice: RankedSlice; callRank: number; outcomeRank: number }>;
+}
+
+export interface SliceInput {
+  key: string;
+  calls: number;
+  totalUsd: number;
+  tally: OutcomeTally;
+}
+
+export function rankPerOutcome(
+  slices: readonly SliceInput[],
+  vocabulary: OutcomeVocabulary | null,
+): PerOutcomeRanking {
+  const ranked: RankedSlice[] = slices.map((slice) => ({
+    key: slice.key,
+    calls: slice.calls,
+    totalUsd: slice.totalUsd,
+    per: perOutcome(slice.tally, slice.totalUsd, vocabulary),
+    usdPerCall: slice.calls > 0 ? slice.totalUsd / slice.calls : 0,
+  }));
+
+  const byCall = [...ranked].sort((a, b) => b.usdPerCall - a.usdPerCall);
+  const byOutcome = ranked
+    .filter((slice) => slice.per.usdPerSuccess !== null)
+    .sort((a, b) => (b.per.usdPerSuccess as number) - (a.per.usdPerSuccess as number));
+
+  const callRankOf = new Map(byCall.map((slice, index) => [slice.key, index]));
+  const disagreements: PerOutcomeRanking['disagreements'] = [];
+  byOutcome.forEach((slice, outcomeRank) => {
+    /**
+     * Compared against this slice's position among **the rankable slices
+     * only**, not among all of them.
+     *
+     * Ranking it at position 4 of ten by call and 1 of three by outcome would
+     * report a disagreement produced entirely by the two lists having different
+     * lengths — an artefact, printed as a finding.
+     */
+    const callRank = byCall
+      .filter((other) => other.per.usdPerSuccess !== null)
+      .findIndex((other) => other.key === slice.key);
+    /**
+     * More than one place — **or** a change at the top.
+     *
+     * The distance threshold alone misses the sharpest case there is: with two
+     * rankable slices a complete reversal is a distance of exactly one, and
+     * that is not noise, it is the finding. Whoever is dearest per call and
+     * whoever is dearest per resolution are the two names in the conversation,
+     * and them being different names is the whole point of computing both.
+     */
+    const changedAtTheTop = (callRank === 0) !== (outcomeRank === 0);
+    if (Math.abs(callRank - outcomeRank) > 1 || changedAtTheTop) {
+      disagreements.push({ slice, callRank, outcomeRank });
+    }
+  });
+  // `callRankOf` is kept for callers that want the position among everything;
+  // the disagreement test deliberately does not use it, for the reason above.
+  void callRankOf;
+
+  return { byCall, byOutcome, disagreements };
+}