@validation-os/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benji Fisher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-CUD5PEXL.js

@@ -0,0 +1,94 @@
+// src/provider.ts
+var StaleVersionError = class extends Error {
+  constructor(register, id, expected, actual) {
+    super(
+      `Stale write to ${register}/${id}: caller had version ${expected}, stored is ${actual}.`
+    );
+    this.register = register;
+    this.id = id;
+    this.expected = expected;
+    this.actual = actual;
+  }
+  register;
+  id;
+  expected;
+  actual;
+  name = "StaleVersionError";
+};
+function isStaleVersionError(e) {
+  return e instanceof StaleVersionError;
+}
+var NotFoundError = class extends Error {
+  constructor(register, id) {
+    super(`No ${register} record with id ${id}.`);
+    this.register = register;
+    this.id = id;
+  }
+  register;
+  id;
+  name = "NotFoundError";
+};
+function isNotFoundError(e) {
+  return e instanceof NotFoundError;
+}
+
+// src/relations.ts
+var RELATIONS = {
+  "assumption-reading": {
+    from: { register: "assumptions", field: "readingIds", cardinality: "many" },
+    to: { register: "readings", field: "assumptionId", cardinality: "one" }
+  },
+  "assumption-depends-on": {
+    from: {
+      register: "assumptions",
+      field: "dependsOnIds",
+      cardinality: "many"
+    },
+    to: { register: "assumptions", field: "enablesIds", cardinality: "many" }
+  },
+  "assumption-contradicts": {
+    from: {
+      register: "assumptions",
+      field: "contradictsIds",
+      cardinality: "many"
+    },
+    to: {
+      register: "assumptions",
+      field: "contradictsIds",
+      cardinality: "many"
+    }
+  },
+  "reading-experiment": {
+    from: { register: "readings", field: "experimentId", cardinality: "one" },
+    to: null
+    // experiment→readings is derived
+  },
+  "reading-goal": {
+    from: { register: "readings", field: "goalId", cardinality: "one" },
+    to: null
+  },
+  "decision-based-on": {
+    from: { register: "decisions", field: "basedOnIds", cardinality: "many" },
+    to: null
+    // never touches the assumption
+  },
+  "decision-resolves": {
+    from: { register: "decisions", field: "resolvesIds", cardinality: "many" },
+    to: null
+    // mooting the assumption is a gated business action, not a link
+  },
+  "goal-based-on": {
+    from: { register: "goals", field: "basedOnIds", cardinality: "many" },
+    to: null
+    // goal linkage is a per-goal view, never stored on the assumption
+  }
+};
+
+export {
+  StaleVersionError,
+  isStaleVersionError,
+  NotFoundError,
+  isNotFoundError,
+  RELATIONS
+};
+//# sourceMappingURL=chunk-CUD5PEXL.js.map

package/dist/chunk-CUD5PEXL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/provider.ts","../src/relations.ts"],"sourcesContent":["/**\n * The `DataProvider` — the single integration seam between the dashboard/API\n * and a concrete backend. Hand-rolled (patterns borrowed from\n * Refine/React-Admin's dataProvider, not forked). One adapter per backend;\n * Firestore is the first. Writing a new adapter is a bounded task: implement\n * these five methods.\n */\nimport type { AnyRecord, Collection, RecordRef, Relation } from \"./types.js\";\n\nexport interface DataProvider {\n  /** Every row of a register — never a filtered view (a filter drops rows). */\n  list(register: Collection): Promise<AnyRecord[]>;\n  get(register: Collection, id: string): Promise<AnyRecord>;\n  create(register: Collection, data: Partial<AnyRecord>): Promise<AnyRecord>;\n  /**\n   * Version-guarded update: `version` is the value the caller loaded. If the\n   * stored version has moved on, the write is rejected with\n   * {@link StaleVersionError} (surfaced to the user as a 409).\n   */\n  update(\n    register: Collection,\n    id: string,\n    patch: Partial<AnyRecord>,\n    version: number,\n  ): Promise<AnyRecord>;\n  /** Set a relation on both ends in one logical write. */\n  link(relation: Relation, from: RecordRef, to: RecordRef): Promise<void>;\n}\n\n/**\n * Thrown when an update carries a version older than what is stored — a\n * concurrent edit landed first. The API turns this into a 409 with\n * plain-language copy; it is never surfaced as version jargon.\n */\nexport class StaleVersionError extends Error {\n  override readonly name = \"StaleVersionError\";\n  constructor(\n    readonly register: Collection,\n    readonly id: string,\n    readonly expected: number,\n    readonly actual: number,\n  ) {\n    super(\n      `Stale write to ${register}/${id}: caller had version ${expected}, ` +\n        `stored is ${actual}.`,\n    );\n  }\n}\n\nexport function isStaleVersionError(e: unknown): e is StaleVersionError {\n  return e instanceof StaleVersionError;\n}\n\n/** Thrown when a get/update targets a record that does not exist (→ 404). */\nexport class NotFoundError extends Error {\n  override readonly name = \"NotFoundError\";\n  constructor(\n    readonly register: Collection,\n    readonly id: string,\n  ) {\n    super(`No ${register} record with id ${id}.`);\n  }\n}\n\nexport function isNotFoundError(e: unknown): e is NotFoundError {\n  return e instanceof NotFoundError;\n}\n","/**\n * Relation config — the single table describing, for each linkable relation,\n * which field on which register holds each end. `link()` sets both ends from\n * this table, so relations stay consistent no matter which side initiated.\n *\n * A `null` `to` end means the inverse is a *derived view*, not a stored field\n * (e.g. \"experiments testing me\" is computed over bar-lines; a decision's\n * `Based on` never touches the assumption). Those relations write one end.\n */\nimport type { Collection, Relation } from \"./types.js\";\n\nexport interface RelationEnd {\n  register: Collection;\n  field: string;\n  cardinality: \"one\" | \"many\";\n}\n\nexport interface RelationSpec {\n  /** The end named by `from` in `link(relation, from, to)`. */\n  from: RelationEnd;\n  /** The end named by `to`; null when the inverse is derived, not stored. */\n  to: RelationEnd | null;\n}\n\nexport const RELATIONS: Record<Relation, RelationSpec> = {\n  \"assumption-reading\": {\n    from: { register: \"assumptions\", field: \"readingIds\", cardinality: \"many\" },\n    to: { register: \"readings\", field: \"assumptionId\", cardinality: \"one\" },\n  },\n  \"assumption-depends-on\": {\n    from: {\n      register: \"assumptions\",\n      field: \"dependsOnIds\",\n      cardinality: \"many\",\n    },\n    to: { register: \"assumptions\", field: \"enablesIds\", cardinality: \"many\" },\n  },\n  \"assumption-contradicts\": {\n    from: {\n      register: \"assumptions\",\n      field: \"contradictsIds\",\n      cardinality: \"many\",\n    },\n    to: {\n      register: \"assumptions\",\n      field: \"contradictsIds\",\n      cardinality: \"many\",\n    },\n  },\n  \"reading-experiment\": {\n    from: { register: \"readings\", field: \"experimentId\", cardinality: \"one\" },\n    to: null, // experiment→readings is derived\n  },\n  \"reading-goal\": {\n    from: { register: \"readings\", field: \"goalId\", cardinality: \"one\" },\n    to: null,\n  },\n  \"decision-based-on\": {\n    from: { register: \"decisions\", field: \"basedOnIds\", cardinality: \"many\" },\n    to: null, // never touches the assumption\n  },\n  \"decision-resolves\": {\n    from: { register: \"decisions\", field: \"resolvesIds\", cardinality: \"many\" },\n    to: null, // mooting the assumption is a gated business action, not a link\n  },\n  \"goal-based-on\": {\n    from: { register: \"goals\", field: \"basedOnIds\", cardinality: \"many\" },\n    to: null, // goal linkage is a per-goal view, never stored on the assumption\n  },\n};\n"],"mappings":";AAkCO,IAAM,oBAAN,cAAgC,MAAM;AAAA,EAE3C,YACW,UACA,IACA,UACA,QACT;AACA;AAAA,MACE,kBAAkB,QAAQ,IAAI,EAAE,wBAAwB,QAAQ,eACjD,MAAM;AAAA,IACvB;AARS;AACA;AACA;AACA;AAAA,EAMX;AAAA,EATW;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EALO,OAAO;AAY3B;AAEO,SAAS,oBAAoB,GAAoC;AACtE,SAAO,aAAa;AACtB;AAGO,IAAM,gBAAN,cAA4B,MAAM;AAAA,EAEvC,YACW,UACA,IACT;AACA,UAAM,MAAM,QAAQ,mBAAmB,EAAE,GAAG;AAHnC;AACA;AAAA,EAGX;AAAA,EAJW;AAAA,EACA;AAAA,EAHO,OAAO;AAO3B;AAEO,SAAS,gBAAgB,GAAgC;AAC9D,SAAO,aAAa;AACtB;;;AC1CO,IAAM,YAA4C;AAAA,EACvD,sBAAsB;AAAA,IACpB,MAAM,EAAE,UAAU,eAAe,OAAO,cAAc,aAAa,OAAO;AAAA,IAC1E,IAAI,EAAE,UAAU,YAAY,OAAO,gBAAgB,aAAa,MAAM;AAAA,EACxE;AAAA,EACA,yBAAyB;AAAA,IACvB,MAAM;AAAA,MACJ,UAAU;AAAA,MACV,OAAO;AAAA,MACP,aAAa;AAAA,IACf;AAAA,IACA,IAAI,EAAE,UAAU,eAAe,OAAO,cAAc,aAAa,OAAO;AAAA,EAC1E;AAAA,EACA,0BAA0B;AAAA,IACxB,MAAM;AAAA,MACJ,UAAU;AAAA,MACV,OAAO;AAAA,MACP,aAAa;AAAA,IACf;AAAA,IACA,IAAI;AAAA,MACF,UAAU;AAAA,MACV,OAAO;AAAA,MACP,aAAa;AAAA,IACf;AAAA,EACF;AAAA,EACA,sBAAsB;AAAA,IACpB,MAAM,EAAE,UAAU,YAAY,OAAO,gBAAgB,aAAa,MAAM;AAAA,IACxE,IAAI;AAAA;AAAA,EACN;AAAA,EACA,gBAAgB;AAAA,IACd,MAAM,EAAE,UAAU,YAAY,OAAO,UAAU,aAAa,MAAM;AAAA,IAClE,IAAI;AAAA,EACN;AAAA,EACA,qBAAqB;AAAA,IACnB,MAAM,EAAE,UAAU,aAAa,OAAO,cAAc,aAAa,OAAO;AAAA,IACxE,IAAI;AAAA;AAAA,EACN;AAAA,EACA,qBAAqB;AAAA,IACnB,MAAM,EAAE,UAAU,aAAa,OAAO,eAAe,aAAa,OAAO;AAAA,IACzE,IAAI;AAAA;AAAA,EACN;AAAA,EACA,iBAAiB;AAAA,IACf,MAAM,EAAE,UAAU,SAAS,OAAO,cAAc,aAAa,OAAO;AAAA,IACpE,IAAI;AAAA;AAAA,EACN;AACF;","names":[]}

package/dist/chunk-PZ5AY32C.js

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-PZ5AY32C.js.map

package/dist/chunk-PZ5AY32C.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-ZNOCENEV.js

@@ -0,0 +1,172 @@
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/derivation/index.ts
+var derivation_exports = {};
+__export(derivation_exports, {
+  GOAL_RUNG_ANCHOR: () => GOAL_RUNG_ANCHOR,
+  RUNG_ANCHOR: () => RUNG_ANCHOR,
+  W0: () => W0,
+  confidence: () => confidence,
+  derivedImpacts: () => derivedImpacts,
+  isGoalRung: () => isGoalRung,
+  readingStrength: () => readingStrength,
+  risk: () => risk,
+  round2: () => round2,
+  sign: () => sign,
+  sourceQuality: () => sourceQuality
+});
+
+// src/derivation/round.ts
+function round2(n) {
+  return Number(n.toFixed(2));
+}
+
+// src/types.ts
+var REGISTERS = [
+  "assumptions",
+  "experiments",
+  "readings",
+  "goals",
+  "decisions",
+  "glossary"
+];
+var TESTING_RUNGS = [
+  "Opinion",
+  "Pitch-deck reaction",
+  "Anecdotal",
+  "Desk research",
+  "Survey at scale",
+  "Prototype usage"
+];
+var GOAL_RUNG_VALUES = ["Signed intent", "Paying users"];
+
+// src/derivation/rung.ts
+var RUNG_ANCHOR = {
+  Opinion: 3,
+  "Pitch-deck reaction": 6,
+  Anecdotal: 10,
+  "Desk research": 15,
+  "Survey at scale": 25,
+  "Prototype usage": 30
+};
+var GOAL_RUNG_ANCHOR = {
+  "Signed intent": { Low: 55, Typical: 68, High: 80 },
+  "Paying users": { Low: 75, Typical: 88, High: 99 }
+};
+var GOAL_RUNG_SET = new Set(GOAL_RUNG_VALUES);
+function isGoalRung(rung) {
+  return GOAL_RUNG_SET.has(rung);
+}
+
+// src/derivation/strength.ts
+function sign(result) {
+  if (result === "Validated") return 1;
+  if (result === "Invalidated") return -1;
+  return 0;
+}
+function readingStrength(input) {
+  const s = sign(input.result);
+  if (s === 0) return 0;
+  if (isGoalRung(input.rung)) {
+    const band = input.magnitudeBand ?? "Typical";
+    return GOAL_RUNG_ANCHOR[input.rung][band] * s;
+  }
+  return (RUNG_ANCHOR[input.rung] ?? 0) * s;
+}
+
+// src/derivation/source-quality.ts
+function sourceQuality(representativeness, credibility) {
+  return round2(representativeness * credibility);
+}
+
+// src/derivation/confidence.ts
+var W0 = 100;
+function confidence(readings) {
+  const scored = readings.filter((r) => r.result === "Validated" || r.result === "Invalidated").map((r) => ({
+    input: r,
+    strength: readingStrength(r),
+    sq: sourceQuality(r.representativeness, r.credibility)
+  })).filter((x) => x.strength !== 0);
+  const best = /* @__PURE__ */ new Map();
+  for (const x of scored) {
+    if (isGoalRung(x.input.rung)) {
+      best.set(x.input.id, x);
+      continue;
+    }
+    const key = x.input.source || x.input.id;
+    const cur = best.get(key);
+    const better = !cur || Math.abs(x.strength) > Math.abs(cur.strength) || Math.abs(x.strength) === Math.abs(cur.strength) && (x.input.date || "") > (cur.input.date || "");
+    if (better) best.set(key, x);
+  }
+  let num = 0;
+  let den = W0;
+  for (const x of best.values()) {
+    const w = Math.abs(x.strength) * x.sq;
+    num += w * x.strength;
+    den += w;
+  }
+  return den > 0 ? round2(num / den) : 0;
+}
+
+// src/derivation/impact.ts
+function derivedImpacts(assumptions, basedOnCounts = {}) {
+  const byId = new Map(assumptions.map((a) => [a.id, a]));
+  const dependents = /* @__PURE__ */ new Map();
+  for (const a of assumptions) dependents.set(a.id, []);
+  for (const a of assumptions) {
+    for (const dep of a.dependsOnIds) dependents.get(dep)?.push(a.id);
+  }
+  const memo = /* @__PURE__ */ new Map();
+  const compute = (id, seen) => {
+    const cached = memo.get(id);
+    if (cached !== void 0) return cached;
+    if (seen.has(id)) return 0;
+    seen.add(id);
+    const a = byId.get(id);
+    if (!a) return 0;
+    if (a.moot) {
+      memo.set(id, 0);
+      return 0;
+    }
+    const seed = a.impact ?? 0;
+    let S = 0;
+    for (const depId of dependents.get(id) ?? []) {
+      const d = byId.get(depId);
+      if (d && !d.moot) S += compute(depId, seen);
+    }
+    S += 100 * (basedOnCounts[id] ?? 0);
+    const value = seed + (100 - seed) * (S / (S + 100));
+    const rounded = round2(value);
+    memo.set(id, rounded);
+    return rounded;
+  };
+  const out = /* @__PURE__ */ new Map();
+  for (const a of assumptions) out.set(a.id, compute(a.id, /* @__PURE__ */ new Set()));
+  return out;
+}
+
+// src/derivation/risk.ts
+function risk(derivedImpact, confidence2) {
+  return round2(derivedImpact * (1 - Math.max(0, confidence2) / 100));
+}
+
+export {
+  REGISTERS,
+  TESTING_RUNGS,
+  GOAL_RUNG_VALUES,
+  round2,
+  RUNG_ANCHOR,
+  GOAL_RUNG_ANCHOR,
+  isGoalRung,
+  sign,
+  readingStrength,
+  sourceQuality,
+  W0,
+  confidence,
+  derivedImpacts,
+  risk,
+  derivation_exports
+};
+//# sourceMappingURL=chunk-ZNOCENEV.js.map

package/dist/chunk-ZNOCENEV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/derivation/index.ts","../src/derivation/round.ts","../src/types.ts","../src/derivation/rung.ts","../src/derivation/strength.ts","../src/derivation/source-quality.ts","../src/derivation/confidence.ts","../src/derivation/impact.ts","../src/derivation/risk.ts"],"sourcesContent":["/**\n * The shared derivation module — pure functions, no I/O.\n *\n * The same module the dashboard, the API (derive-on-write), and Claude Code\n * audits all call, so every writer computes the four derived numbers\n * identically. Ported from `doshi-validation-os/migration/remodel.mjs` and\n * kept in lock-step with `skills/_shared/ontology.yaml`.\n */\nexport { round2 } from \"./round.js\";\nexport {\n  RUNG_ANCHOR,\n  GOAL_RUNG_ANCHOR,\n  isGoalRung,\n} from \"./rung.js\";\nexport { sign, readingStrength } from \"./strength.js\";\nexport type { StrengthInput } from \"./strength.js\";\nexport { sourceQuality } from \"./source-quality.js\";\nexport { confidence, W0 } from \"./confidence.js\";\nexport type { ConfidenceReadingInput } from \"./confidence.js\";\nexport { derivedImpacts } from \"./impact.js\";\nexport type { ImpactAssumptionInput } from \"./impact.js\";\nexport { risk } from \"./risk.js\";\n","/**\n * Round to 2 decimals, matching the migration's `+(n).toFixed(2)`.\n * Derived values are stored/displayed rounded; full precision is only used\n * transiently inside a single computation.\n */\nexport function round2(n: number): number {\n  return Number(n.toFixed(2));\n}\n","/**\n * Shared registry types — the field vocabulary the whole system speaks.\n *\n * These mirror `skills/_shared/registry-schema.md` and `ontology.yaml` (the\n * single source of truth). Field *meaning* lives there; this file is the\n * checkable TypeScript shape the packages import.\n */\n\n/** The six registers plus the `people` reference collection. */\nexport const REGISTERS = [\n  \"assumptions\",\n  \"experiments\",\n  \"readings\",\n  \"goals\",\n  \"decisions\",\n  \"glossary\",\n] as const;\nexport type Register = (typeof REGISTERS)[number];\n\n/** `people` is a reference collection, not one of the six registers. */\nexport type Collection = Register | \"people\";\n\n/** Every stored record carries an id, a version, and timestamps. */\nexport interface BaseRecord {\n  id: string;\n  /** Optimistic-concurrency token; bumped on every write. */\n  version: number;\n  createdAt: string;\n  updatedAt: string;\n}\n\n// ── Vocabularies (canonical select-option lists) ────────────────────────────\n\nexport type AssumptionStatus = \"Draft\" | \"Live\" | \"Invalidated\";\nexport type ExperimentStatus = \"Running\" | \"Closed\";\nexport type GoalStatus = \"Draft\" | \"Active\" | \"Closed\";\nexport type DecisionStatus =\n  | \"Active\"\n  | \"Provisional\"\n  | \"Superseded\"\n  | \"Reversed\";\nexport type GlossaryStatus = \"Active\" | \"Provisional\" | \"Superseded\";\n\nexport type Result = \"Validated\" | \"Invalidated\" | \"Inconclusive\";\nexport type MagnitudeBand = \"Low\" | \"Typical\" | \"High\";\nexport type Feasibility = \"High\" | \"Medium\" | \"Low\";\n\n/** The 8-rung activity-and-strength ladder (order = strength, weakest first). */\nexport const TESTING_RUNGS = [\n  \"Opinion\",\n  \"Pitch-deck reaction\",\n  \"Anecdotal\",\n  \"Desk research\",\n  \"Survey at scale\",\n  \"Prototype usage\",\n] as const;\nexport const GOAL_RUNG_VALUES = [\"Signed intent\", \"Paying users\"] as const;\nexport type TestingRung = (typeof TESTING_RUNGS)[number];\nexport type GoalRung = (typeof GOAL_RUNG_VALUES)[number];\nexport type Rung = TestingRung | GoalRung;\n\n/** Representativeness and Credibility are each picked from these. */\nexport type SourceQualityPick = 1.0 | 0.7 | 0.5;\n\n// ── Records ─────────────────────────────────────────────────────────────────\n\n/** The four derived numbers stored on an assumption (never hand-typed). */\nexport interface AssumptionDerived {\n  derivedImpact: number;\n  risk: number;\n  confidence: number;\n}\n\nexport interface AssumptionRecord extends BaseRecord {\n  Title: string;\n  Description: string;\n  Lens: string | null;\n  Theme: string[];\n  /** The hand-scored seed (0–100), the only hand-scored number here. */\n  Impact: number | null;\n  Status: AssumptionStatus;\n  Owner: string[];\n  Gaps: string[];\n  moot: boolean;\n  dependsOnIds: string[];\n  enablesIds: string[];\n  contradictsIds: string[];\n  readingIds: string[];\n  derived: AssumptionDerived;\n}\n\nexport interface ReadingRecord extends BaseRecord {\n  Title: string;\n  /** First-class link to the artifact — the independence-dedupe key. */\n  Source: string | null;\n  assumptionId: string;\n  experimentId: string | null;\n  goalId: string | null;\n  Rung: Rung;\n  Representativeness: SourceQualityPick;\n  Credibility: SourceQualityPick;\n  /** For Goal-rung readings: the magnitude band from the absolute outcome. */\n  magnitudeBand?: MagnitudeBand;\n  Result: Result;\n  Date: string | null;\n  Owner: string[];\n  derived: { sourceQuality: number; strength: number };\n}\n\nexport interface ExperimentRecord extends BaseRecord {\n  Title: string;\n  Instrument: string | null;\n  Feasibility: Feasibility | null;\n  Status: ExperimentStatus;\n  closureReason: \"Completed\" | \"Early-stop\" | \"Kill\" | null;\n  Owner: string[];\n  Date: string | null;\n  barLineAssumptionIds: string[];\n}\n\nexport interface GoalRecord extends BaseRecord {\n  Title: string;\n  Status: GoalStatus;\n  Outcome: \"Achieved\" | \"Missed\" | \"Dropped\" | null;\n  Owner: string[];\n  Date: string | null;\n  basedOnIds: string[];\n}\n\nexport interface DecisionRecord extends BaseRecord {\n  Title: string;\n  Status: DecisionStatus;\n  Owner: string[];\n  basedOnIds: string[];\n  resolvesIds: string[];\n}\n\nexport interface GlossaryRecord extends BaseRecord {\n  Title: string;\n  Status: GlossaryStatus;\n}\n\n/** A record of any register — the DataProvider's currency. */\nexport type AnyRecord = BaseRecord & Record<string, unknown>;\n\n// ── Relations (both-ends links) ─────────────────────────────────────────────\n\n/** A pointer to one record. */\nexport interface RecordRef {\n  register: Collection;\n  id: string;\n}\n\n/** The relations the dashboard can set (each writes both ends). */\nexport type Relation =\n  | \"assumption-reading\"\n  | \"assumption-depends-on\"\n  | \"assumption-contradicts\"\n  | \"reading-experiment\"\n  | \"reading-goal\"\n  | \"decision-based-on\"\n  | \"decision-resolves\"\n  | \"goal-based-on\";\n","/**\n * The evidence ladder anchors that feed Strength.\n *\n * Source of truth: `skills/_shared/ontology.yaml` → `vocabularies.rung`.\n * Testing rungs carry a single anchor; Goal rungs carry a magnitude band\n * (Low/Typical/High) picked from the absolute outcome.\n */\nimport type { GoalRung, MagnitudeBand, Rung, TestingRung } from \"../types.js\";\nimport { GOAL_RUNG_VALUES } from \"../types.js\";\n\nexport const RUNG_ANCHOR: Record<TestingRung, number> = {\n  Opinion: 3,\n  \"Pitch-deck reaction\": 6,\n  Anecdotal: 10,\n  \"Desk research\": 15,\n  \"Survey at scale\": 25,\n  \"Prototype usage\": 30,\n};\n\nexport const GOAL_RUNG_ANCHOR: Record<GoalRung, Record<MagnitudeBand, number>> =\n  {\n    \"Signed intent\": { Low: 55, Typical: 68, High: 80 },\n    \"Paying users\": { Low: 75, Typical: 88, High: 99 },\n  };\n\nconst GOAL_RUNG_SET = new Set<Rung>(GOAL_RUNG_VALUES);\n\nexport function isGoalRung(rung: Rung): rung is GoalRung {\n  return GOAL_RUNG_SET.has(rung);\n}\n","/**\n * Strength — the signed reading value `s` the Confidence average reads.\n *\n * Formula (`ontology.yaml` → `derivations.strength`):\n *   rung anchor (Goal rungs: × magnitude band) × sign(Result)\n *   — Validated positive, Invalidated negative; 0 unless Validated/Invalidated.\n */\nimport type { MagnitudeBand, Result, Rung } from \"../types.js\";\nimport { GOAL_RUNG_ANCHOR, RUNG_ANCHOR, isGoalRung } from \"./rung.js\";\n\nexport function sign(result: Result): -1 | 0 | 1 {\n  if (result === \"Validated\") return 1;\n  if (result === \"Invalidated\") return -1;\n  return 0;\n}\n\nexport interface StrengthInput {\n  rung: Rung;\n  result: Result;\n  /** Only read for Goal rungs; defaults to \"Typical\" when absent. */\n  magnitudeBand?: MagnitudeBand;\n}\n\nexport function readingStrength(input: StrengthInput): number {\n  const s = sign(input.result);\n  if (s === 0) return 0; // Inconclusive contributes nothing.\n  if (isGoalRung(input.rung)) {\n    const band = input.magnitudeBand ?? \"Typical\";\n    return GOAL_RUNG_ANCHOR[input.rung][band] * s;\n  }\n  return (RUNG_ANCHOR[input.rung] ?? 0) * s;\n}\n","/**\n * Source quality — Representativeness × Credibility.\n *\n * Scales a Reading's *weight* in the Confidence average, within its rung.\n * We keep the raw product as the weight (matching the migration's\n * `remodel.mjs`); the five display anchors {0.25, 0.35, 0.5, 0.7, 1.0} are a\n * storage/display concern, not the weight used in the average.\n */\nimport { round2 } from \"./round.js\";\n\nexport function sourceQuality(\n  representativeness: number,\n  credibility: number,\n): number {\n  return round2(representativeness * credibility);\n}\n","/**\n * Confidence — signed −100…100, 0 = no evidence.\n *\n * Formula (`ontology.yaml` → `derivations.confidence`):\n *   (w0·0 + Σ wi·si) / (w0 + Σ wi),  w0 = 100,\n *   wi = |si| × Source quality,  si = the reading's signed Strength.\n *\n * Only concluded Validated/Invalidated readings enter. Readings sharing a\n * Source against one belief dedupe to the strongest (largest |si|, most\n * recent on ties). Goal-rung readings never dedupe (each closed goal is its\n * own unit). No corroboration bump.\n */\nimport type { MagnitudeBand, Result, Rung } from \"../types.js\";\nimport { round2 } from \"./round.js\";\nimport { isGoalRung } from \"./rung.js\";\nimport { sourceQuality } from \"./source-quality.js\";\nimport { readingStrength } from \"./strength.js\";\n\n/** The neutral prior weight — a hard floor per the guardrails. */\nexport const W0 = 100;\n\nexport interface ConfidenceReadingInput {\n  id: string;\n  /** The independence-dedupe key. Null falls back to the reading's own id. */\n  source: string | null;\n  rung: Rung;\n  result: Result;\n  representativeness: number;\n  credibility: number;\n  /** ISO date; used only as the dedupe tie-break (most recent wins). */\n  date?: string | null;\n  magnitudeBand?: MagnitudeBand;\n}\n\ninterface Scored {\n  input: ConfidenceReadingInput;\n  strength: number;\n  sq: number;\n}\n\nexport function confidence(readings: ConfidenceReadingInput[]): number {\n  const scored: Scored[] = readings\n    .filter((r) => r.result === \"Validated\" || r.result === \"Invalidated\")\n    .map((r) => ({\n      input: r,\n      strength: readingStrength(r),\n      sq: sourceQuality(r.representativeness, r.credibility),\n    }))\n    .filter((x) => x.strength !== 0);\n\n  // Dedupe by Source; goal rungs never dedupe.\n  const best = new Map<string, Scored>();\n  for (const x of scored) {\n    if (isGoalRung(x.input.rung)) {\n      best.set(x.input.id, x);\n      continue;\n    }\n    const key = x.input.source || x.input.id;\n    const cur = best.get(key);\n    const better =\n      !cur ||\n      Math.abs(x.strength) > Math.abs(cur.strength) ||\n      (Math.abs(x.strength) === Math.abs(cur.strength) &&\n        (x.input.date || \"\") > (cur.input.date || \"\"));\n    if (better) best.set(key, x);\n  }\n\n  let num = 0;\n  let den = W0;\n  for (const x of best.values()) {\n    const w = Math.abs(x.strength) * x.sq;\n    num += w * x.strength;\n    den += w;\n  }\n  return den > 0 ? round2(num / den) : 0;\n}\n","/**\n * Derived Impact — propagates dependents' pull into a belief's seed.\n *\n * Formula (`ontology.yaml` → `derivations.derived_impact`):\n *   seed + (100 − seed) × S / (S + 100),  where\n *   S = Σ Derived Impact of assumptions whose `Depends on` names this row\n *       + 100 per standing (Provisional/Active) decision naming it via\n *         `Based on assumption`.\n *   Goals never contribute. Moot rows pin to 0 and contribute nothing.\n *\n * One reverse-topological pass (dependents first) with memoization and a\n * cycle guard, matching `doshi-validation-os/migration/remodel.mjs`.\n */\nimport { round2 } from \"./round.js\";\n\nexport interface ImpactAssumptionInput {\n  id: string;\n  /** The hand-scored seed (0–100); null treated as 0. */\n  impact: number | null;\n  moot?: boolean;\n  /** Ids this assumption depends on. */\n  dependsOnIds: string[];\n}\n\n/**\n * @param assumptions the full register (never a filtered slice — a filter\n *   silently drops dependents from the propagation).\n * @param basedOnCounts id → number of standing decisions with a `Based on`\n *   link to that assumption. Each contributes +100 to S.\n */\nexport function derivedImpacts(\n  assumptions: ImpactAssumptionInput[],\n  basedOnCounts: Record<string, number> = {},\n): Map<string, number> {\n  const byId = new Map(assumptions.map((a) => [a.id, a]));\n\n  // dependents(X) = assumptions whose dependsOnIds includes X.\n  const dependents = new Map<string, string[]>();\n  for (const a of assumptions) dependents.set(a.id, []);\n  for (const a of assumptions) {\n    for (const dep of a.dependsOnIds) dependents.get(dep)?.push(a.id);\n  }\n\n  const memo = new Map<string, number>();\n  const compute = (id: string, seen: Set<string>): number => {\n    const cached = memo.get(id);\n    if (cached !== undefined) return cached;\n    if (seen.has(id)) return 0; // cycle guard\n    seen.add(id);\n    const a = byId.get(id);\n    if (!a) return 0;\n    if (a.moot) {\n      memo.set(id, 0);\n      return 0;\n    }\n    const seed = a.impact ?? 0;\n    let S = 0;\n    for (const depId of dependents.get(id) ?? []) {\n      const d = byId.get(depId);\n      if (d && !d.moot) S += compute(depId, seen);\n    }\n    S += 100 * (basedOnCounts[id] ?? 0);\n    const value = seed + (100 - seed) * (S / (S + 100));\n    const rounded = round2(value);\n    memo.set(id, rounded);\n    return rounded;\n  };\n\n  const out = new Map<string, number>();\n  for (const a of assumptions) out.set(a.id, compute(a.id, new Set()));\n  return out;\n}\n","/**\n * Risk — the belief's live standing.\n *\n * Formula (`ontology.yaml` → `derivations.risk`):\n *   Derived Impact × (1 − max(0, Confidence) / 100)\n * Ranges 0 to Derived Impact. Negative confidence does not raise Risk above\n * Derived Impact (the max(0, …) clamp).\n */\nimport { round2 } from \"./round.js\";\n\nexport function risk(derivedImpact: number, confidence: number): number {\n  return round2(derivedImpact * (1 - Math.max(0, confidence) / 100));\n}\n"],"mappings":"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","names":["confidence"]}

package/dist/derivation/index.d.ts

@@ -0,0 +1,2 @@
+export { C as ConfidenceReadingInput, G as GOAL_RUNG_ANCHOR, I as ImpactAssumptionInput, R as RUNG_ANCHOR, S as StrengthInput, W as W0, c as confidence, d as derivedImpacts, a as isGoalRung, r as readingStrength, b as risk, e as round2, f as sign, s as sourceQuality } from '../index-BSd5_vwB.js';
+import '../types-BS3hq4-i.js';

package/dist/derivation/index.js

@@ -0,0 +1,28 @@
+import {
+  GOAL_RUNG_ANCHOR,
+  RUNG_ANCHOR,
+  W0,
+  confidence,
+  derivedImpacts,
+  isGoalRung,
+  readingStrength,
+  risk,
+  round2,
+  sign,
+  sourceQuality
+} from "../chunk-ZNOCENEV.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  GOAL_RUNG_ANCHOR,
+  RUNG_ANCHOR,
+  W0,
+  confidence,
+  derivedImpacts,
+  isGoalRung,
+  readingStrength,
+  risk,
+  round2,
+  sign,
+  sourceQuality
+};
+//# sourceMappingURL=index.js.map

package/dist/derivation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index-BSd5_vwB.d.ts

@@ -0,0 +1,115 @@
+import { j as GoalRung, M as MagnitudeBand, q as TestingRung, p as Rung, o as Result } from './types-BS3hq4-i.js';
+
+/**
+ * Round to 2 decimals, matching the migration's `+(n).toFixed(2)`.
+ * Derived values are stored/displayed rounded; full precision is only used
+ * transiently inside a single computation.
+ */
+declare function round2(n: number): number;
+
+/**
+ * The evidence ladder anchors that feed Strength.
+ *
+ * Source of truth: `skills/_shared/ontology.yaml` → `vocabularies.rung`.
+ * Testing rungs carry a single anchor; Goal rungs carry a magnitude band
+ * (Low/Typical/High) picked from the absolute outcome.
+ */
+
+declare const RUNG_ANCHOR: Record<TestingRung, number>;
+declare const GOAL_RUNG_ANCHOR: Record<GoalRung, Record<MagnitudeBand, number>>;
+declare function isGoalRung(rung: Rung): rung is GoalRung;
+
+/**
+ * Strength — the signed reading value `s` the Confidence average reads.
+ *
+ * Formula (`ontology.yaml` → `derivations.strength`):
+ *   rung anchor (Goal rungs: × magnitude band) × sign(Result)
+ *   — Validated positive, Invalidated negative; 0 unless Validated/Invalidated.
+ */
+
+declare function sign(result: Result): -1 | 0 | 1;
+interface StrengthInput {
+    rung: Rung;
+    result: Result;
+    /** Only read for Goal rungs; defaults to "Typical" when absent. */
+    magnitudeBand?: MagnitudeBand;
+}
+declare function readingStrength(input: StrengthInput): number;
+
+declare function sourceQuality(representativeness: number, credibility: number): number;
+
+/**
+ * Confidence — signed −100…100, 0 = no evidence.
+ *
+ * Formula (`ontology.yaml` → `derivations.confidence`):
+ *   (w0·0 + Σ wi·si) / (w0 + Σ wi),  w0 = 100,
+ *   wi = |si| × Source quality,  si = the reading's signed Strength.
+ *
+ * Only concluded Validated/Invalidated readings enter. Readings sharing a
+ * Source against one belief dedupe to the strongest (largest |si|, most
+ * recent on ties). Goal-rung readings never dedupe (each closed goal is its
+ * own unit). No corroboration bump.
+ */
+
+/** The neutral prior weight — a hard floor per the guardrails. */
+declare const W0 = 100;
+interface ConfidenceReadingInput {
+    id: string;
+    /** The independence-dedupe key. Null falls back to the reading's own id. */
+    source: string | null;
+    rung: Rung;
+    result: Result;
+    representativeness: number;
+    credibility: number;
+    /** ISO date; used only as the dedupe tie-break (most recent wins). */
+    date?: string | null;
+    magnitudeBand?: MagnitudeBand;
+}
+declare function confidence(readings: ConfidenceReadingInput[]): number;
+
+interface ImpactAssumptionInput {
+    id: string;
+    /** The hand-scored seed (0–100); null treated as 0. */
+    impact: number | null;
+    moot?: boolean;
+    /** Ids this assumption depends on. */
+    dependsOnIds: string[];
+}
+/**
+ * @param assumptions the full register (never a filtered slice — a filter
+ *   silently drops dependents from the propagation).
+ * @param basedOnCounts id → number of standing decisions with a `Based on`
+ *   link to that assumption. Each contributes +100 to S.
+ */
+declare function derivedImpacts(assumptions: ImpactAssumptionInput[], basedOnCounts?: Record<string, number>): Map<string, number>;
+
+declare function risk(derivedImpact: number, confidence: number): number;
+
+/**
+ * The shared derivation module — pure functions, no I/O.
+ *
+ * The same module the dashboard, the API (derive-on-write), and Claude Code
+ * audits all call, so every writer computes the four derived numbers
+ * identically. Ported from `doshi-validation-os/migration/remodel.mjs` and
+ * kept in lock-step with `skills/_shared/ontology.yaml`.
+ */
+
+type index_ConfidenceReadingInput = ConfidenceReadingInput;
+declare const index_GOAL_RUNG_ANCHOR: typeof GOAL_RUNG_ANCHOR;
+type index_ImpactAssumptionInput = ImpactAssumptionInput;
+declare const index_RUNG_ANCHOR: typeof RUNG_ANCHOR;
+type index_StrengthInput = StrengthInput;
+declare const index_W0: typeof W0;
+declare const index_confidence: typeof confidence;
+declare const index_derivedImpacts: typeof derivedImpacts;
+declare const index_isGoalRung: typeof isGoalRung;
+declare const index_readingStrength: typeof readingStrength;
+declare const index_risk: typeof risk;
+declare const index_round2: typeof round2;
+declare const index_sign: typeof sign;
+declare const index_sourceQuality: typeof sourceQuality;
+declare namespace index {
+  export { type index_ConfidenceReadingInput as ConfidenceReadingInput, index_GOAL_RUNG_ANCHOR as GOAL_RUNG_ANCHOR, type index_ImpactAssumptionInput as ImpactAssumptionInput, index_RUNG_ANCHOR as RUNG_ANCHOR, type index_StrengthInput as StrengthInput, index_W0 as W0, index_confidence as confidence, index_derivedImpacts as derivedImpacts, index_isGoalRung as isGoalRung, index_readingStrength as readingStrength, index_risk as risk, index_round2 as round2, index_sign as sign, index_sourceQuality as sourceQuality };
+}
+
+export { type ConfidenceReadingInput as C, GOAL_RUNG_ANCHOR as G, type ImpactAssumptionInput as I, RUNG_ANCHOR as R, type StrengthInput as S, W0 as W, isGoalRung as a, risk as b, confidence as c, derivedImpacts as d, round2 as e, sign as f, index as i, readingStrength as r, sourceQuality as s };

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { R as Relation, C as Collection, A as AssumptionRecord, a as ReadingRecord, D as DecisionRecord, b as AssumptionDerived } from './types-BS3hq4-i.js';
+export { c as AnyRecord, d as AssumptionStatus, B as BaseRecord, e as DecisionStatus, E as ExperimentRecord, f as ExperimentStatus, F as Feasibility, G as GOAL_RUNG_VALUES, g as GlossaryRecord, h as GlossaryStatus, i as GoalRecord, j as GoalRung, k as GoalStatus, M as MagnitudeBand, l as REGISTERS, m as RecordRef, n as Register, o as Result, p as Rung, S as SourceQualityPick, T as TESTING_RUNGS, q as TestingRung } from './types-BS3hq4-i.js';
+export { D as DataProvider, N as NotFoundError, S as StaleVersionError, i as isNotFoundError, a as isStaleVersionError } from './provider-N0ylgK8f.js';
+export { i as derivation, s as recomputeSourceQuality, r as recomputeStrength } from './index-BSd5_vwB.js';
+
+/**
+ * Relation config — the single table describing, for each linkable relation,
+ * which field on which register holds each end. `link()` sets both ends from
+ * this table, so relations stay consistent no matter which side initiated.
+ *
+ * A `null` `to` end means the inverse is a *derived view*, not a stored field
+ * (e.g. "experiments testing me" is computed over bar-lines; a decision's
+ * `Based on` never touches the assumption). Those relations write one end.
+ */
+
+interface RelationEnd {
+    register: Collection;
+    field: string;
+    cardinality: "one" | "many";
+}
+interface RelationSpec {
+    /** The end named by `from` in `link(relation, from, to)`. */
+    from: RelationEnd;
+    /** The end named by `to`; null when the inverse is derived, not stored. */
+    to: RelationEnd | null;
+}
+declare const RELATIONS: Record<Relation, RelationSpec>;
+
+interface RecomputeInput {
+    assumptions: AssumptionRecord[];
+    readings: ReadingRecord[];
+    decisions: DecisionRecord[];
+}
+/** id → recomputed derived tuple for every assumption in the register. */
+declare function recomputeDerived(input: RecomputeInput): Map<string, AssumptionDerived>;
+
+export { AssumptionDerived, AssumptionRecord, Collection, DecisionRecord, RELATIONS, ReadingRecord, type RecomputeInput, Relation, type RelationEnd, type RelationSpec, recomputeDerived };

package/dist/index.js

@@ -0,0 +1,83 @@
+import {
+  NotFoundError,
+  RELATIONS,
+  StaleVersionError,
+  isNotFoundError,
+  isStaleVersionError
+} from "./chunk-CUD5PEXL.js";
+import {
+  GOAL_RUNG_VALUES,
+  REGISTERS,
+  TESTING_RUNGS,
+  confidence,
+  derivation_exports,
+  derivedImpacts,
+  readingStrength,
+  risk,
+  sourceQuality
+} from "./chunk-ZNOCENEV.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/recompute.ts
+var STANDING_DECISION = /* @__PURE__ */ new Set(["Active", "Provisional"]);
+function toConfidenceInput(r) {
+  return {
+    id: r.id,
+    source: r.Source,
+    rung: r.Rung,
+    result: r.Result,
+    representativeness: r.Representativeness,
+    credibility: r.Credibility,
+    date: r.Date,
+    magnitudeBand: r.magnitudeBand
+  };
+}
+function recomputeDerived(input) {
+  const { assumptions, readings, decisions } = input;
+  const readingsByAssumption = /* @__PURE__ */ new Map();
+  for (const a of assumptions) readingsByAssumption.set(a.id, []);
+  for (const r of readings) readingsByAssumption.get(r.assumptionId)?.push(r);
+  const confidenceById = /* @__PURE__ */ new Map();
+  for (const a of assumptions) {
+    const rs = readingsByAssumption.get(a.id) ?? [];
+    confidenceById.set(a.id, confidence(rs.map(toConfidenceInput)));
+  }
+  const basedOnCounts = {};
+  for (const d of decisions) {
+    if (!STANDING_DECISION.has(d.Status)) continue;
+    for (const aid of d.basedOnIds ?? []) {
+      basedOnCounts[aid] = (basedOnCounts[aid] ?? 0) + 1;
+    }
+  }
+  const impactById = derivedImpacts(
+    assumptions.map((a) => ({
+      id: a.id,
+      impact: a.moot ? 0 : a.Impact,
+      moot: a.moot,
+      dependsOnIds: a.dependsOnIds
+    })),
+    basedOnCounts
+  );
+  const out = /* @__PURE__ */ new Map();
+  for (const a of assumptions) {
+    const c = confidenceById.get(a.id) ?? 0;
+    const di = impactById.get(a.id) ?? 0;
+    out.set(a.id, { confidence: c, derivedImpact: di, risk: risk(di, c) });
+  }
+  return out;
+}
+export {
+  GOAL_RUNG_VALUES,
+  NotFoundError,
+  REGISTERS,
+  RELATIONS,
+  StaleVersionError,
+  TESTING_RUNGS,
+  derivation_exports as derivation,
+  isNotFoundError,
+  isStaleVersionError,
+  recomputeDerived,
+  sourceQuality as recomputeSourceQuality,
+  readingStrength as recomputeStrength
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recompute.ts"],"sourcesContent":["/**\n * Derive-on-write glue: recompute the four derived numbers for a whole\n * assumptions register from its readings and standing decisions, using the\n * pure derivation module. The API calls this server-side on every touching\n * write and writes the results back; a batch pass is the backstop for\n * non-dashboard writes.\n *\n * This is the one place that maps stored record shapes → the derivation\n * module's typed inputs, so the pure functions stay decoupled from field\n * names.\n */\nimport {\n  confidence,\n  derivedImpacts,\n  risk,\n  type ConfidenceReadingInput,\n} from \"./derivation/index.js\";\nimport type {\n  AssumptionDerived,\n  AssumptionRecord,\n  DecisionRecord,\n  ReadingRecord,\n} from \"./types.js\";\n\n/** Standing decisions (Provisional/Active) contribute to Derived Impact. */\nconst STANDING_DECISION = new Set([\"Active\", \"Provisional\"]);\n\nfunction toConfidenceInput(r: ReadingRecord): ConfidenceReadingInput {\n  return {\n    id: r.id,\n    source: r.Source,\n    rung: r.Rung,\n    result: r.Result,\n    representativeness: r.Representativeness,\n    credibility: r.Credibility,\n    date: r.Date,\n    magnitudeBand: r.magnitudeBand,\n  };\n}\n\nexport interface RecomputeInput {\n  assumptions: AssumptionRecord[];\n  readings: ReadingRecord[];\n  decisions: DecisionRecord[];\n}\n\n/** id → recomputed derived tuple for every assumption in the register. */\nexport function recomputeDerived(\n  input: RecomputeInput,\n): Map<string, AssumptionDerived> {\n  const { assumptions, readings, decisions } = input;\n\n  // Confidence: group concluded readings by assumption.\n  const readingsByAssumption = new Map<string, ReadingRecord[]>();\n  for (const a of assumptions) readingsByAssumption.set(a.id, []);\n  for (const r of readings) readingsByAssumption.get(r.assumptionId)?.push(r);\n\n  const confidenceById = new Map<string, number>();\n  for (const a of assumptions) {\n    const rs = readingsByAssumption.get(a.id) ?? [];\n    confidenceById.set(a.id, confidence(rs.map(toConfidenceInput)));\n  }\n\n  // Derived Impact: standing-decision `Based on` links count +100 each.\n  const basedOnCounts: Record<string, number> = {};\n  for (const d of decisions) {\n    if (!STANDING_DECISION.has(d.Status)) continue;\n    for (const aid of d.basedOnIds ?? []) {\n      basedOnCounts[aid] = (basedOnCounts[aid] ?? 0) + 1;\n    }\n  }\n  const impactById = derivedImpacts(\n    assumptions.map((a) => ({\n      id: a.id,\n      impact: a.moot ? 0 : a.Impact,\n      moot: a.moot,\n      dependsOnIds: a.dependsOnIds,\n    })),\n    basedOnCounts,\n  );\n\n  const out = new Map<string, AssumptionDerived>();\n  for (const a of assumptions) {\n    const c = confidenceById.get(a.id) ?? 0;\n    const di = impactById.get(a.id) ?? 0;\n    out.set(a.id, { confidence: c, derivedImpact: di, risk: risk(di, c) });\n  }\n  return out;\n}\n\n/** Recompute Source quality + Strength for a single reading. */\nexport {\n  sourceQuality as recomputeSourceQuality,\n  readingStrength as recomputeStrength,\n} from \"./derivation/index.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAyBA,IAAM,oBAAoB,oBAAI,IAAI,CAAC,UAAU,aAAa,CAAC;AAE3D,SAAS,kBAAkB,GAA0C;AACnE,SAAO;AAAA,IACL,IAAI,EAAE;AAAA,IACN,QAAQ,EAAE;AAAA,IACV,MAAM,EAAE;AAAA,IACR,QAAQ,EAAE;AAAA,IACV,oBAAoB,EAAE;AAAA,IACtB,aAAa,EAAE;AAAA,IACf,MAAM,EAAE;AAAA,IACR,eAAe,EAAE;AAAA,EACnB;AACF;AASO,SAAS,iBACd,OACgC;AAChC,QAAM,EAAE,aAAa,UAAU,UAAU,IAAI;AAG7C,QAAM,uBAAuB,oBAAI,IAA6B;AAC9D,aAAW,KAAK,YAAa,sBAAqB,IAAI,EAAE,IAAI,CAAC,CAAC;AAC9D,aAAW,KAAK,SAAU,sBAAqB,IAAI,EAAE,YAAY,GAAG,KAAK,CAAC;AAE1E,QAAM,iBAAiB,oBAAI,IAAoB;AAC/C,aAAW,KAAK,aAAa;AAC3B,UAAM,KAAK,qBAAqB,IAAI,EAAE,EAAE,KAAK,CAAC;AAC9C,mBAAe,IAAI,EAAE,IAAI,WAAW,GAAG,IAAI,iBAAiB,CAAC,CAAC;AAAA,EAChE;AAGA,QAAM,gBAAwC,CAAC;AAC/C,aAAW,KAAK,WAAW;AACzB,QAAI,CAAC,kBAAkB,IAAI,EAAE,MAAM,EAAG;AACtC,eAAW,OAAO,EAAE,cAAc,CAAC,GAAG;AACpC,oBAAc,GAAG,KAAK,cAAc,GAAG,KAAK,KAAK;AAAA,IACnD;AAAA,EACF;AACA,QAAM,aAAa;AAAA,IACjB,YAAY,IAAI,CAAC,OAAO;AAAA,MACtB,IAAI,EAAE;AAAA,MACN,QAAQ,EAAE,OAAO,IAAI,EAAE;AAAA,MACvB,MAAM,EAAE;AAAA,MACR,cAAc,EAAE;AAAA,IAClB,EAAE;AAAA,IACF;AAAA,EACF;AAEA,QAAM,MAAM,oBAAI,IAA+B;AAC/C,aAAW,KAAK,aAAa;AAC3B,UAAM,IAAI,eAAe,IAAI,EAAE,EAAE,KAAK;AACtC,UAAM,KAAK,WAAW,IAAI,EAAE,EAAE,KAAK;AACnC,QAAI,IAAI,EAAE,IAAI,EAAE,YAAY,GAAG,eAAe,IAAI,MAAM,KAAK,IAAI,CAAC,EAAE,CAAC;AAAA,EACvE;AACA,SAAO;AACT;","names":[]}

package/dist/provider-N0ylgK8f.d.ts

@@ -0,0 +1,48 @@
+import { C as Collection, c as AnyRecord, R as Relation, m as RecordRef } from './types-BS3hq4-i.js';
+
+/**
+ * The `DataProvider` — the single integration seam between the dashboard/API
+ * and a concrete backend. Hand-rolled (patterns borrowed from
+ * Refine/React-Admin's dataProvider, not forked). One adapter per backend;
+ * Firestore is the first. Writing a new adapter is a bounded task: implement
+ * these five methods.
+ */
+
+interface DataProvider {
+    /** Every row of a register — never a filtered view (a filter drops rows). */
+    list(register: Collection): Promise<AnyRecord[]>;
+    get(register: Collection, id: string): Promise<AnyRecord>;
+    create(register: Collection, data: Partial<AnyRecord>): Promise<AnyRecord>;
+    /**
+     * Version-guarded update: `version` is the value the caller loaded. If the
+     * stored version has moved on, the write is rejected with
+     * {@link StaleVersionError} (surfaced to the user as a 409).
+     */
+    update(register: Collection, id: string, patch: Partial<AnyRecord>, version: number): Promise<AnyRecord>;
+    /** Set a relation on both ends in one logical write. */
+    link(relation: Relation, from: RecordRef, to: RecordRef): Promise<void>;
+}
+/**
+ * Thrown when an update carries a version older than what is stored — a
+ * concurrent edit landed first. The API turns this into a 409 with
+ * plain-language copy; it is never surfaced as version jargon.
+ */
+declare class StaleVersionError extends Error {
+    readonly register: Collection;
+    readonly id: string;
+    readonly expected: number;
+    readonly actual: number;
+    readonly name = "StaleVersionError";
+    constructor(register: Collection, id: string, expected: number, actual: number);
+}
+declare function isStaleVersionError(e: unknown): e is StaleVersionError;
+/** Thrown when a get/update targets a record that does not exist (→ 404). */
+declare class NotFoundError extends Error {
+    readonly register: Collection;
+    readonly id: string;
+    readonly name = "NotFoundError";
+    constructor(register: Collection, id: string);
+}
+declare function isNotFoundError(e: unknown): e is NotFoundError;
+
+export { type DataProvider as D, NotFoundError as N, StaleVersionError as S, isStaleVersionError as a, isNotFoundError as i };

package/dist/testing.d.ts

@@ -0,0 +1,24 @@
+import { D as DataProvider } from './provider-N0ylgK8f.js';
+import { C as Collection, c as AnyRecord, R as Relation, m as RecordRef } from './types-BS3hq4-i.js';
+
+interface InMemoryProviderOptions {
+    now?: () => string;
+    /** Seed data keyed by register. */
+    seed?: Partial<Record<Collection, AnyRecord[]>>;
+}
+declare class InMemoryProvider implements DataProvider {
+    private readonly store;
+    private readonly now;
+    private counter;
+    constructor(options?: InMemoryProviderOptions);
+    private col;
+    list(register: Collection): Promise<AnyRecord[]>;
+    get(register: Collection, id: string): Promise<AnyRecord>;
+    create(register: Collection, data: Partial<AnyRecord>): Promise<AnyRecord>;
+    update(register: Collection, id: string, patch: Partial<AnyRecord>, version: number): Promise<AnyRecord>;
+    link(relation: Relation, from: RecordRef, to: RecordRef): Promise<void>;
+    private applyEnd;
+}
+declare function createInMemoryProvider(options?: InMemoryProviderOptions): InMemoryProvider;
+
+export { InMemoryProvider, type InMemoryProviderOptions, createInMemoryProvider };

package/dist/testing.js

@@ -0,0 +1,96 @@
+import {
+  NotFoundError,
+  RELATIONS,
+  StaleVersionError
+} from "./chunk-CUD5PEXL.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/testing.ts
+var InMemoryProvider = class {
+  store = /* @__PURE__ */ new Map();
+  now;
+  counter = 0;
+  constructor(options = {}) {
+    this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    for (const [register, rows] of Object.entries(options.seed ?? {})) {
+      const col = this.col(register);
+      for (const r of rows ?? []) col.set(r.id, structuredClone(r));
+    }
+  }
+  col(register) {
+    let c = this.store.get(register);
+    if (!c) {
+      c = /* @__PURE__ */ new Map();
+      this.store.set(register, c);
+    }
+    return c;
+  }
+  async list(register) {
+    return [...this.col(register).values()].map((r) => structuredClone(r));
+  }
+  async get(register, id) {
+    const r = this.col(register).get(id);
+    if (!r) throw new NotFoundError(register, id);
+    return structuredClone(r);
+  }
+  async create(register, data) {
+    const id = data.id ? String(data.id) : `${register}-${++this.counter}`;
+    if (this.col(register).has(id)) {
+      throw new Error(`${register}/${id} already exists`);
+    }
+    const ts = this.now();
+    const { id: _i, ...rest } = data;
+    const record = {
+      ...rest,
+      id,
+      version: 0,
+      createdAt: ts,
+      updatedAt: ts
+    };
+    this.col(register).set(id, record);
+    return structuredClone(record);
+  }
+  async update(register, id, patch, version) {
+    const current = this.col(register).get(id);
+    if (!current) throw new NotFoundError(register, id);
+    if (current.version !== version) {
+      throw new StaleVersionError(register, id, version, current.version);
+    }
+    const { id: _i, version: _v, createdAt: _c, ...safe } = patch;
+    const next = {
+      ...current,
+      ...safe,
+      id,
+      version: current.version + 1,
+      updatedAt: this.now()
+    };
+    this.col(register).set(id, next);
+    return structuredClone(next);
+  }
+  async link(relation, from, to) {
+    const spec = RELATIONS[relation];
+    this.applyEnd(spec.from, from.register, from.id, to.id);
+    if (spec.to) this.applyEnd(spec.to, to.register, to.id, from.id);
+  }
+  applyEnd(end, register, ownerId, otherId) {
+    const rec = this.col(register).get(ownerId);
+    if (!rec) throw new NotFoundError(register, ownerId);
+    if (end.cardinality === "many") {
+      const arr = Array.isArray(rec[end.field]) ? rec[end.field] : [];
+      if (!arr.includes(otherId)) arr.push(otherId);
+      rec[end.field] = arr;
+    } else {
+      rec[end.field] = otherId;
+    }
+    rec.version += 1;
+    rec.updatedAt = this.now();
+  }
+};
+function createInMemoryProvider(options) {
+  return new InMemoryProvider(options);
+}
+export {
+  InMemoryProvider,
+  createInMemoryProvider
+};
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/testing.ts"],"sourcesContent":["/**\n * An in-memory `DataProvider` — the fast, deterministic fake that backs API\n * and dashboard tests (the spec's \"Seam 1\" in-memory adapter). It honours the\n * full contract, including version-guarded writes (409 on stale) and\n * both-ends linking, so tests exercise real behaviour without a database.\n */\nimport { NotFoundError, StaleVersionError } from \"./provider.js\";\nimport type { DataProvider } from \"./provider.js\";\nimport { RELATIONS } from \"./relations.js\";\nimport type { RelationEnd } from \"./relations.js\";\nimport type { AnyRecord, Collection, RecordRef, Relation } from \"./types.js\";\n\nexport interface InMemoryProviderOptions {\n  now?: () => string;\n  /** Seed data keyed by register. */\n  seed?: Partial<Record<Collection, AnyRecord[]>>;\n}\n\nexport class InMemoryProvider implements DataProvider {\n  private readonly store = new Map<Collection, Map<string, AnyRecord>>();\n  private readonly now: () => string;\n  private counter = 0;\n\n  constructor(options: InMemoryProviderOptions = {}) {\n    this.now = options.now ?? (() => new Date().toISOString());\n    for (const [register, rows] of Object.entries(options.seed ?? {})) {\n      const col = this.col(register as Collection);\n      for (const r of rows ?? []) col.set(r.id, structuredClone(r));\n    }\n  }\n\n  private col(register: Collection): Map<string, AnyRecord> {\n    let c = this.store.get(register);\n    if (!c) {\n      c = new Map();\n      this.store.set(register, c);\n    }\n    return c;\n  }\n\n  async list(register: Collection): Promise<AnyRecord[]> {\n    return [...this.col(register).values()].map((r) => structuredClone(r));\n  }\n\n  async get(register: Collection, id: string): Promise<AnyRecord> {\n    const r = this.col(register).get(id);\n    if (!r) throw new NotFoundError(register, id);\n    return structuredClone(r);\n  }\n\n  async create(\n    register: Collection,\n    data: Partial<AnyRecord>,\n  ): Promise<AnyRecord> {\n    const id = data.id ? String(data.id) : `${register}-${++this.counter}`;\n    if (this.col(register).has(id)) {\n      throw new Error(`${register}/${id} already exists`);\n    }\n    const ts = this.now();\n    const { id: _i, ...rest } = data;\n    const record = {\n      ...rest,\n      id,\n      version: 0,\n      createdAt: ts,\n      updatedAt: ts,\n    } as AnyRecord;\n    this.col(register).set(id, record);\n    return structuredClone(record);\n  }\n\n  async update(\n    register: Collection,\n    id: string,\n    patch: Partial<AnyRecord>,\n    version: number,\n  ): Promise<AnyRecord> {\n    const current = this.col(register).get(id);\n    if (!current) throw new NotFoundError(register, id);\n    if (current.version !== version) {\n      throw new StaleVersionError(register, id, version, current.version);\n    }\n    const { id: _i, version: _v, createdAt: _c, ...safe } = patch;\n    const next = {\n      ...current,\n      ...safe,\n      id,\n      version: current.version + 1,\n      updatedAt: this.now(),\n    } as AnyRecord;\n    this.col(register).set(id, next);\n    return structuredClone(next);\n  }\n\n  async link(relation: Relation, from: RecordRef, to: RecordRef): Promise<void> {\n    const spec = RELATIONS[relation];\n    this.applyEnd(spec.from, from.register, from.id, to.id);\n    if (spec.to) this.applyEnd(spec.to, to.register, to.id, from.id);\n  }\n\n  private applyEnd(\n    end: RelationEnd,\n    register: Collection,\n    ownerId: string,\n    otherId: string,\n  ): void {\n    const rec = this.col(register).get(ownerId);\n    if (!rec) throw new NotFoundError(register, ownerId);\n    if (end.cardinality === \"many\") {\n      const arr = Array.isArray(rec[end.field])\n        ? (rec[end.field] as string[])\n        : [];\n      if (!arr.includes(otherId)) arr.push(otherId);\n      rec[end.field] = arr;\n    } else {\n      rec[end.field] = otherId;\n    }\n    rec.version += 1;\n    rec.updatedAt = this.now();\n  }\n}\n\nexport function createInMemoryProvider(\n  options?: InMemoryProviderOptions,\n): InMemoryProvider {\n  return new InMemoryProvider(options);\n}\n"],"mappings":"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","names":[]}

package/dist/types-BS3hq4-i.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Shared registry types — the field vocabulary the whole system speaks.
+ *
+ * These mirror `skills/_shared/registry-schema.md` and `ontology.yaml` (the
+ * single source of truth). Field *meaning* lives there; this file is the
+ * checkable TypeScript shape the packages import.
+ */
+/** The six registers plus the `people` reference collection. */
+declare const REGISTERS: readonly ["assumptions", "experiments", "readings", "goals", "decisions", "glossary"];
+type Register = (typeof REGISTERS)[number];
+/** `people` is a reference collection, not one of the six registers. */
+type Collection = Register | "people";
+/** Every stored record carries an id, a version, and timestamps. */
+interface BaseRecord {
+    id: string;
+    /** Optimistic-concurrency token; bumped on every write. */
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+type AssumptionStatus = "Draft" | "Live" | "Invalidated";
+type ExperimentStatus = "Running" | "Closed";
+type GoalStatus = "Draft" | "Active" | "Closed";
+type DecisionStatus = "Active" | "Provisional" | "Superseded" | "Reversed";
+type GlossaryStatus = "Active" | "Provisional" | "Superseded";
+type Result = "Validated" | "Invalidated" | "Inconclusive";
+type MagnitudeBand = "Low" | "Typical" | "High";
+type Feasibility = "High" | "Medium" | "Low";
+/** The 8-rung activity-and-strength ladder (order = strength, weakest first). */
+declare const TESTING_RUNGS: readonly ["Opinion", "Pitch-deck reaction", "Anecdotal", "Desk research", "Survey at scale", "Prototype usage"];
+declare const GOAL_RUNG_VALUES: readonly ["Signed intent", "Paying users"];
+type TestingRung = (typeof TESTING_RUNGS)[number];
+type GoalRung = (typeof GOAL_RUNG_VALUES)[number];
+type Rung = TestingRung | GoalRung;
+/** Representativeness and Credibility are each picked from these. */
+type SourceQualityPick = 1.0 | 0.7 | 0.5;
+/** The four derived numbers stored on an assumption (never hand-typed). */
+interface AssumptionDerived {
+    derivedImpact: number;
+    risk: number;
+    confidence: number;
+}
+interface AssumptionRecord extends BaseRecord {
+    Title: string;
+    Description: string;
+    Lens: string | null;
+    Theme: string[];
+    /** The hand-scored seed (0–100), the only hand-scored number here. */
+    Impact: number | null;
+    Status: AssumptionStatus;
+    Owner: string[];
+    Gaps: string[];
+    moot: boolean;
+    dependsOnIds: string[];
+    enablesIds: string[];
+    contradictsIds: string[];
+    readingIds: string[];
+    derived: AssumptionDerived;
+}
+interface ReadingRecord extends BaseRecord {
+    Title: string;
+    /** First-class link to the artifact — the independence-dedupe key. */
+    Source: string | null;
+    assumptionId: string;
+    experimentId: string | null;
+    goalId: string | null;
+    Rung: Rung;
+    Representativeness: SourceQualityPick;
+    Credibility: SourceQualityPick;
+    /** For Goal-rung readings: the magnitude band from the absolute outcome. */
+    magnitudeBand?: MagnitudeBand;
+    Result: Result;
+    Date: string | null;
+    Owner: string[];
+    derived: {
+        sourceQuality: number;
+        strength: number;
+    };
+}
+interface ExperimentRecord extends BaseRecord {
+    Title: string;
+    Instrument: string | null;
+    Feasibility: Feasibility | null;
+    Status: ExperimentStatus;
+    closureReason: "Completed" | "Early-stop" | "Kill" | null;
+    Owner: string[];
+    Date: string | null;
+    barLineAssumptionIds: string[];
+}
+interface GoalRecord extends BaseRecord {
+    Title: string;
+    Status: GoalStatus;
+    Outcome: "Achieved" | "Missed" | "Dropped" | null;
+    Owner: string[];
+    Date: string | null;
+    basedOnIds: string[];
+}
+interface DecisionRecord extends BaseRecord {
+    Title: string;
+    Status: DecisionStatus;
+    Owner: string[];
+    basedOnIds: string[];
+    resolvesIds: string[];
+}
+interface GlossaryRecord extends BaseRecord {
+    Title: string;
+    Status: GlossaryStatus;
+}
+/** A record of any register — the DataProvider's currency. */
+type AnyRecord = BaseRecord & Record<string, unknown>;
+/** A pointer to one record. */
+interface RecordRef {
+    register: Collection;
+    id: string;
+}
+/** The relations the dashboard can set (each writes both ends). */
+type Relation = "assumption-reading" | "assumption-depends-on" | "assumption-contradicts" | "reading-experiment" | "reading-goal" | "decision-based-on" | "decision-resolves" | "goal-based-on";
+
+export { type AssumptionRecord as A, type BaseRecord as B, type Collection as C, type DecisionRecord as D, type ExperimentRecord as E, type Feasibility as F, GOAL_RUNG_VALUES as G, type MagnitudeBand as M, type Relation as R, type SourceQualityPick as S, TESTING_RUNGS as T, type ReadingRecord as a, type AssumptionDerived as b, type AnyRecord as c, type AssumptionStatus as d, type DecisionStatus as e, type ExperimentStatus as f, type GlossaryRecord as g, type GlossaryStatus as h, type GoalRecord as i, type GoalRung as j, type GoalStatus as k, REGISTERS as l, type RecordRef as m, type Register as n, type Result as o, type Rung as p, type TestingRung as q };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@validation-os/core",
+  "version": "0.1.0",
+  "description": "The DataProvider seam, the shared derivation module (pure functions), and shared registry types for validation-os.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./derivation": {
+      "types": "./dist/derivation/index.d.ts",
+      "import": "./dist/derivation/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bfish1996/validation-os.git",
+    "directory": "packages/core"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}