@unson/brainbase-mcp 0.24.0 → 0.25.0

package/dist/judgment-frame.d.ts

@@ -1,4 +1,5 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { type JudgmentModelOutcome, type JudgmentModelOutcomeSummary } from './judgment-model-outcome.js';
 /**
  * Judgment frame (brainbase-project ADR-014).
  *
@@ -91,7 +92,9 @@ export interface JudgmentFrameIssue {
     readonly message: string;
 }
 /** Exceptions that ADR-014 F5 returns to a human. The host decides when they block. */
-export type JudgmentFrameEscalationCode = 'objective_unanchored' | 'chosen_violates_philosophy' | 'chosen_philosophy_tension';
+export type JudgmentFrameEscalationCode = 'objective_unanchored' | 'chosen_violates_philosophy' | 'chosen_philosophy_tension'
+/** The chosen option predicts with a world model refuted at its current revision (F5, F6). */
+ | 'chosen_uses_refuted_model';
 export interface JudgmentFrameEscalation {
     readonly code: JudgmentFrameEscalationCode;
     readonly refs: readonly string[];
@@ -101,6 +104,8 @@ export interface JudgmentFrameValidation {
     readonly issues: readonly JudgmentFrameIssue[];
     readonly escalations: readonly JudgmentFrameEscalation[];
 }
+/** True when text looks like it carries a credential. Shared by public frames and outcome records. */
+export declare function containsJudgmentFrameCredential(value: string): boolean;
 /**
  * Compute the digest for the exact two-field public projection.
  * The response adds this digest; it is intentionally separate from the
@@ -118,13 +123,16 @@ export declare function judgmentFrameRecordDigest(value: JudgmentFrameRecord): `
  * Excluded records are returned with a reason so a shrinking catalog is visible.
  */
 export declare function buildJudgmentFrameCatalog(records: readonly JudgmentFrameSourceRecord[]): JudgmentFrameCatalogBuild;
-/** One line per item, grouped by kind, for the model-facing prompt. */
-export declare function renderJudgmentFrameCatalog(catalog: JudgmentFrameCatalog): string;
+/**
+ * One line per item, grouped by kind, for the model-facing prompt. Outcome
+ * summaries, when given, annotate world models; they are not part of the digest.
+ */
+export declare function renderJudgmentFrameCatalog(catalog: JudgmentFrameCatalog, outcomes?: ReadonlyMap<string, JudgmentModelOutcomeSummary>): string;
 /**
  * Check that a frame record only uses catalog references and that every
  * selection is used in at least one option with the role of its kind.
  */
-export declare function validateJudgmentFrameRecord(value: unknown, catalog: JudgmentFrameCatalog): JudgmentFrameValidation;
+export declare function validateJudgmentFrameRecord(value: unknown, catalog: JudgmentFrameCatalog, outcomes?: ReadonlyMap<string, JudgmentModelOutcomeSummary>): JudgmentFrameValidation;
 export declare const judgmentFrameTools: Tool[];
 export type JudgmentFrameRecordsPage = {
     readonly status: 'ok';
@@ -134,9 +142,38 @@ export type JudgmentFrameRecordsPage = {
     readonly code: string;
     readonly message: string;
 };
+export type JudgmentModelOutcomesPage = {
+    readonly status: 'ok';
+    readonly records: readonly unknown[];
+} | {
+    readonly status: 'unavailable' | 'error';
+    readonly code: string;
+    readonly message: string;
+};
+export type JudgmentModelOutcomeAppendResult = {
+    readonly status: 'ok';
+    readonly id: string;
+    readonly recorded_at: string;
+} | {
+    readonly status: 'unavailable' | 'error';
+    readonly code: string;
+    readonly message: string;
+};
 export interface JudgmentFrameToolDependencies {
     /** Read every record of one kind visible to the caller, at most `limit`. */
     readonly loadRecords: (kind: JudgmentFrameKind, limit: number) => Promise<JudgmentFrameRecordsPage>;
+    /**
+     * Read every stored world-model outcome visible to the caller (ADR-014 F6).
+     * When omitted, the catalog and escalations behave as before.
+     */
+    readonly loadModelOutcomes?: () => Promise<JudgmentModelOutcomesPage>;
+}
+export interface JudgmentModelOutcomeToolDependencies extends JudgmentFrameToolDependencies {
+    readonly loadModelOutcomes: () => Promise<JudgmentModelOutcomesPage>;
+    /** Append one validated outcome. The host owns id, time, author, authorization, and storage. */
+    readonly appendModelOutcome: (outcome: JudgmentModelOutcome & {
+        readonly digest: `sha256:${string}`;
+    }) => Promise<JudgmentModelOutcomeAppendResult>;
 }
 export type JudgmentFrameToolResult = {
     readonly status: 'ok';
@@ -150,5 +187,13 @@ export type JudgmentFrameToolResult = {
     };
 };
 export declare function handleJudgmentFrameToolCall(name: string, args: Record<string, unknown>, dependencies: JudgmentFrameToolDependencies): Promise<JudgmentFrameToolResult | null>;
+/**
+ * Opt-in tool for hosts that store world-model outcomes (ADR-014 F6).
+ * Published separately so a host without storage does not expose it.
+ */
+export declare const judgmentModelOutcomeTools: Tool[];
+export declare function handleJudgmentModelOutcomeToolCall(name: string, args: Record<string, unknown>, dependencies: JudgmentModelOutcomeToolDependencies): Promise<JudgmentFrameToolResult | null>;
+export { JUDGMENT_MODEL_OUTCOME_ALTERNATIVES, JUDGMENT_MODEL_OUTCOME_RECORD_VERSION, judgmentModelOutcomeDigest, parseJudgmentModelOutcomeRecords, summarizeJudgmentModelOutcomes, validateJudgmentModelOutcome, } from './judgment-model-outcome.js';
+export type { JudgmentModelOutcome, JudgmentModelOutcomeAlternative, JudgmentModelOutcomeEvidenceKind, JudgmentModelOutcomeEvidenceRef, JudgmentModelOutcomeIssue, JudgmentModelOutcomeIssueCode, JudgmentModelOutcomeStoredRecord, JudgmentModelOutcomeSummary, JudgmentModelOutcomeValidation, JudgmentModelOutcomeVerdict, } from './judgment-model-outcome.js';
 export { judgmentFrameReadTools, handleJudgmentFrameReadToolCall, } from './judgment-frame-read.js';
 export type { JudgmentFrameReadDependencies, JudgmentFrameReadRecord, } from './judgment-frame-read.js';

package/dist/judgment-frame.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { JUDGMENT_MODEL_OUTCOME_ALTERNATIVES, JUDGMENT_MODEL_OUTCOME_RECORD_VERSION, judgmentModelOutcomeDigest, parseJudgmentModelOutcomeRecords, summarizeJudgmentModelOutcomes, validateJudgmentModelOutcome, } from './judgment-model-outcome.js';
 /**
  * Judgment frame (brainbase-project ADR-014).
  *
@@ -50,7 +51,8 @@ const PUBLIC_FRAME_SECRET_PATTERNS = [
     /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/u,
 ];
 const PUBLIC_FRAME_CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/u;
-function containsPublicFrameCredential(value) {
+/** True when text looks like it carries a credential. Shared by public frames and outcome records. */
+export function containsJudgmentFrameCredential(value) {
     return PUBLIC_FRAME_SECRET_PATTERNS.some((pattern) => pattern.test(value));
 }
 function publicFrameRecord(value) {
@@ -164,13 +166,24 @@ const KIND_HEADINGS = {
     objective: '目的（criterionとして使う）',
     model: '世界モデル（predictionとして使う。仮説であり、検証済みとは限らない）',
 };
-/** One line per item, grouped by kind, for the model-facing prompt. */
-export function renderJudgmentFrameCatalog(catalog) {
+function renderOutcomeSummary(summary) {
+    if (!summary)
+        return '';
+    const counts = `支持${summary.supports}・反証${summary.refutes}・判定不能${summary.inconclusive}`;
+    const refuted = summary.refuted_when.length > 0 ? `。反証の条件：${summary.refuted_when.join('／')}` : '';
+    return `（この版の結果：${counts}${refuted}）`;
+}
+/**
+ * One line per item, grouped by kind, for the model-facing prompt. Outcome
+ * summaries, when given, annotate world models; they are not part of the digest.
+ */
+export function renderJudgmentFrameCatalog(catalog, outcomes = new Map()) {
     const lines = [`judgment frame catalog ${catalog.digest}`];
     for (const kind of KINDS) {
         lines.push('', `## ${KIND_HEADINGS[kind]}`);
         for (const item of catalog.items.filter((candidate) => candidate.kind === kind)) {
-            lines.push(`- ${item.id} [${item.status}] ${item.text}${item.applies_when ? `（適用：${item.applies_when}）` : ''}`);
+            const outcome = kind === 'model' ? renderOutcomeSummary(outcomes.get(item.id)) : '';
+            lines.push(`- ${item.id} [${item.status}] ${item.text}${item.applies_when ? `（適用：${item.applies_when}）` : ''}${outcome}`);
         }
     }
     return lines.join('\n');
@@ -179,7 +192,7 @@ export function renderJudgmentFrameCatalog(catalog) {
  * Check that a frame record only uses catalog references and that every
  * selection is used in at least one option with the role of its kind.
  */
-export function validateJudgmentFrameRecord(value, catalog) {
+export function validateJudgmentFrameRecord(value, catalog, outcomes = new Map()) {
     const issues = [];
     const issue = (code, path, message) => issues.push({ code, path, message });
     if (!isRecord(value) || value.record_version !== JUDGMENT_FRAME_RECORD_VERSION) {
@@ -205,7 +218,7 @@ export function validateJudgmentFrameRecord(value, catalog) {
                 if (PUBLIC_FRAME_CONTROL_CHARACTERS.test(candidate)) {
                     issue('frame_public_invalid', `public_frame.${key}`, `${key} contains control characters`);
                 }
-                if (containsPublicFrameCredential(candidate)) {
+                if (containsJudgmentFrameCredential(candidate)) {
                     issue('frame_public_invalid', `public_frame.${key}`, `${key} contains a credential-like value`);
                 }
             }
@@ -311,6 +324,12 @@ export function validateJudgmentFrameRecord(value, catalog) {
             escalations.push({ code: 'chosen_violates_philosophy', refs: violated });
         if (tension.length > 0)
             escalations.push({ code: 'chosen_philosophy_tension', refs: tension });
+        const refuted = [...new Set(chosenUses
+                .filter((use) => isRecord(use) && use.role === 'prediction'
+                && selected.get(String(use.ref)) === 'model' && (outcomes.get(String(use.ref))?.refutes ?? 0) > 0)
+                .map((use) => String(use.ref)))];
+        if (refuted.length > 0)
+            escalations.push({ code: 'chosen_uses_refuted_model', refs: refuted });
     }
     return { valid: issues.length === 0, issues, escalations };
 }
@@ -415,6 +434,24 @@ async function loadFrameCatalog(dependencies) {
     }
     return buildJudgmentFrameCatalog(records);
 }
+async function loadOutcomeSummaries(dependencies, catalog) {
+    if (!dependencies.loadModelOutcomes)
+        return new Map();
+    let page;
+    try {
+        page = await dependencies.loadModelOutcomes();
+    }
+    catch (error) {
+        return toolError('unavailable', 'judgment_model_outcomes_unavailable', `World model outcomes could not be read: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (page.status !== 'ok')
+        return toolError(page.status, page.code, page.message);
+    const parsed = parseJudgmentModelOutcomeRecords(page.records);
+    if (!parsed.ok) {
+        return toolError('error', 'judgment_model_outcomes_invalid', `Stored world model outcome ${parsed.index} is invalid: ${parsed.message}`);
+    }
+    return summarizeJudgmentModelOutcomes(parsed.records, catalog);
+}
 export async function handleJudgmentFrameToolCall(name, args, dependencies) {
     if (name !== 'brainbase_judgment_frame_catalog' && name !== 'brainbase_judgment_frame_record')
         return null;
@@ -425,6 +462,9 @@ export async function handleJudgmentFrameToolCall(name, args, dependencies) {
     if ('status' in loaded)
         return loaded;
     const { catalog, excluded } = loaded;
+    const outcomes = await loadOutcomeSummaries(dependencies, catalog);
+    if (!(outcomes instanceof Map))
+        return outcomes;
     if (name === 'brainbase_judgment_frame_catalog') {
         return {
             status: 'ok',
@@ -433,11 +473,12 @@ export async function handleJudgmentFrameToolCall(name, args, dependencies) {
                 catalog_digest: catalog.digest,
                 counts: Object.fromEntries(KINDS.map((kind) => [kind, catalog.items.filter((item) => item.kind === kind).length])),
                 excluded_count: excluded.length,
-                catalog: renderJudgmentFrameCatalog(catalog),
+                ...(dependencies.loadModelOutcomes ? { models_with_outcomes: outcomes.size } : {}),
+                catalog: renderJudgmentFrameCatalog(catalog, outcomes),
             },
         };
     }
-    const validation = validateJudgmentFrameRecord(args, catalog);
+    const validation = validateJudgmentFrameRecord(args, catalog, outcomes);
     if (!validation.valid) {
         return toolError('error', 'judgment_frame_invalid', 'The judgment frame does not match the catalog contract', {
             issues: validation.issues,
@@ -463,4 +504,100 @@ export async function handleJudgmentFrameToolCall(name, args, dependencies) {
         },
     };
 }
+const outcomeTextSchema = { type: 'string', minLength: 1, maxLength: 2_000 };
+/**
+ * Opt-in tool for hosts that store world-model outcomes (ADR-014 F6).
+ * Published separately so a host without storage does not expose it.
+ */
+export const judgmentModelOutcomeTools = [{
+        name: 'brainbase_judgment_model_outcome_record',
+        description: 'After the result of a judgment is observed, record whether it supports or refutes a world model that the judgment used as a prediction. Read brainbase_judgment_frame_catalog first and pass its catalog_digest and the model id at its current revision. State the prediction made from the model, what was observed, the conditions (facility, period, state) under which the result holds, and at least one evidence reference. A refutation must say, for each of measurement_error, execution_difference, and external_change, why it does not explain the gap; a prediction gap alone is not a refutation. This does not change the model, its revision, or its adoption; adoption and verification stay human decisions. The tool does not judge whether the verdict is semantically right.',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                record_version: { type: 'string', const: JUDGMENT_MODEL_OUTCOME_RECORD_VERSION },
+                catalog_digest: { type: 'string', pattern: '^sha256:[a-f0-9]{64}$' },
+                model: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        id: { type: 'string', minLength: 1, maxLength: 1_000 },
+                        revision: { type: 'string', minLength: 1, maxLength: 64 },
+                    },
+                    required: ['id', 'revision'],
+                },
+                verdict: { type: 'string', enum: ['supports', 'refutes', 'inconclusive'] },
+                prediction: outcomeTextSchema,
+                observed: outcomeTextSchema,
+                conditions: outcomeTextSchema,
+                evidence_refs: {
+                    type: 'array',
+                    minItems: 1,
+                    maxItems: 12,
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            kind: { type: 'string', enum: ['artifact', 'query', 'document', 'judgment'] },
+                            ref: { type: 'string', minLength: 1, maxLength: 800 },
+                            label: { type: 'string', minLength: 1, maxLength: 200 },
+                        },
+                        required: ['kind', 'ref', 'label'],
+                    },
+                },
+                ruled_out: {
+                    type: 'object',
+                    additionalProperties: false,
+                    description: 'Required only when verdict is refutes.',
+                    properties: Object.fromEntries(JUDGMENT_MODEL_OUTCOME_ALTERNATIVES.map((key) => [key, { type: 'string', minLength: 1, maxLength: 1_000 }])),
+                    required: [...JUDGMENT_MODEL_OUTCOME_ALTERNATIVES],
+                },
+                judgment_ref: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: { frame_digest: { type: 'string', pattern: '^sha256:[a-f0-9]{64}$' } },
+                    required: ['frame_digest'],
+                },
+            },
+            required: ['record_version', 'catalog_digest', 'model', 'verdict', 'prediction', 'observed', 'conditions', 'evidence_refs'],
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+    }];
+export async function handleJudgmentModelOutcomeToolCall(name, args, dependencies) {
+    if (name !== 'brainbase_judgment_model_outcome_record')
+        return null;
+    const loaded = await loadFrameCatalog(dependencies);
+    if ('status' in loaded)
+        return loaded;
+    const validation = validateJudgmentModelOutcome(args, loaded.catalog, containsJudgmentFrameCredential);
+    if (!validation.valid) {
+        return toolError('error', 'judgment_model_outcome_invalid', 'The outcome does not match the current catalog contract', {
+            issues: validation.issues,
+            current_catalog_digest: loaded.catalog.digest,
+        });
+    }
+    const digest = judgmentModelOutcomeDigest(validation.outcome);
+    let appended;
+    try {
+        appended = await dependencies.appendModelOutcome({ ...validation.outcome, digest });
+    }
+    catch (error) {
+        return toolError('unavailable', 'judgment_model_outcome_unavailable', `The outcome could not be stored: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (appended.status !== 'ok')
+        return toolError(appended.status, appended.code, appended.message);
+    return {
+        status: 'ok',
+        data: {
+            schema_version: 'brainbase-judgment-model-outcome-v1',
+            id: appended.id,
+            recorded_at: appended.recorded_at,
+            model: validation.outcome.model,
+            verdict: validation.outcome.verdict,
+            digest,
+        },
+    };
+}
+export { JUDGMENT_MODEL_OUTCOME_ALTERNATIVES, JUDGMENT_MODEL_OUTCOME_RECORD_VERSION, judgmentModelOutcomeDigest, parseJudgmentModelOutcomeRecords, summarizeJudgmentModelOutcomes, validateJudgmentModelOutcome, } from './judgment-model-outcome.js';
 export { judgmentFrameReadTools, handleJudgmentFrameReadToolCall, } from './judgment-frame-read.js';

package/dist/judgment-model-outcome.d.ts

@@ -0,0 +1,96 @@
+import type { JudgmentFrameCatalog } from './judgment-frame.js';
+/**
+ * Judgment outcome feedback for world models (brainbase-project ADR-014 F6).
+ *
+ * After a judgment that used a world model as a prediction, the observed
+ * result is appended as a separate record bound to the model's id and
+ * revision. The model itself (revision, validationState, adoptionState) is
+ * never changed here: adoption and promotion stay human decisions.
+ *
+ * Records are checked structurally against the current catalog. Whether a
+ * verdict is semantically right is not judged. A refutation must explain why
+ * measurement error, execution difference, and external change were ruled
+ * out, so a prediction gap alone is never recorded as a refutation.
+ */
+export declare const JUDGMENT_MODEL_OUTCOME_RECORD_VERSION: "judgment-model-outcome.v1";
+export type JudgmentModelOutcomeVerdict = 'supports' | 'refutes' | 'inconclusive';
+export type JudgmentModelOutcomeEvidenceKind = 'artifact' | 'query' | 'document' | 'judgment';
+export declare const JUDGMENT_MODEL_OUTCOME_ALTERNATIVES: readonly ["measurement_error", "execution_difference", "external_change"];
+export type JudgmentModelOutcomeAlternative = typeof JUDGMENT_MODEL_OUTCOME_ALTERNATIVES[number];
+export interface JudgmentModelOutcomeEvidenceRef {
+    readonly kind: JudgmentModelOutcomeEvidenceKind;
+    readonly ref: string;
+    readonly label: string;
+}
+export interface JudgmentModelOutcome {
+    readonly record_version: typeof JUDGMENT_MODEL_OUTCOME_RECORD_VERSION;
+    readonly model: {
+        readonly id: string;
+        readonly revision: string;
+    };
+    readonly verdict: JudgmentModelOutcomeVerdict;
+    /** What the judgment predicted from this model for this case. */
+    readonly prediction: string;
+    /** What was actually observed. */
+    readonly observed: string;
+    /** Facility, period, and state under which the result holds. */
+    readonly conditions: string;
+    readonly evidence_refs: readonly JudgmentModelOutcomeEvidenceRef[];
+    /** Required only for refutes: why each alternative explanation was ruled out. */
+    readonly ruled_out?: Readonly<Record<JudgmentModelOutcomeAlternative, string>>;
+    readonly judgment_ref?: {
+        readonly frame_digest: `sha256:${string}`;
+    };
+}
+/** A record as the host stored it: the outcome plus host-owned id, time, and content digest. */
+export interface JudgmentModelOutcomeStoredRecord extends JudgmentModelOutcome {
+    readonly id: string;
+    readonly recorded_at: string;
+    readonly digest: `sha256:${string}`;
+}
+export interface JudgmentModelOutcomeSummary {
+    readonly supports: number;
+    readonly refutes: number;
+    readonly inconclusive: number;
+    /** Conditions of the most recent refutations, newest first. */
+    readonly refuted_when: readonly string[];
+}
+export type JudgmentModelOutcomeIssueCode = 'outcome_record_invalid' | 'outcome_catalog_mismatch' | 'outcome_model_unknown' | 'outcome_not_model' | 'outcome_revision_mismatch' | 'outcome_ruled_out_missing' | 'outcome_ruled_out_unexpected' | 'outcome_evidence_missing' | 'outcome_text_unsafe';
+export interface JudgmentModelOutcomeIssue {
+    readonly code: JudgmentModelOutcomeIssueCode;
+    readonly path: string;
+    readonly message: string;
+}
+export type JudgmentModelOutcomeValidation = {
+    readonly valid: true;
+    readonly issues: readonly [];
+    readonly outcome: JudgmentModelOutcome;
+} | {
+    readonly valid: false;
+    readonly issues: readonly JudgmentModelOutcomeIssue[];
+};
+/** Digest of the outcome content. Host-owned id and time are not part of it. */
+export declare function judgmentModelOutcomeDigest(outcome: JudgmentModelOutcome): `sha256:${string}`;
+/**
+ * Validate a new outcome against the catalog shown on this turn. The model
+ * must be a world model in the catalog, at its current revision.
+ */
+export declare function validateJudgmentModelOutcome(value: unknown, catalog: JudgmentFrameCatalog, unsafe?: (text: string) => boolean): JudgmentModelOutcomeValidation;
+/**
+ * Parse records returned by the host store. A malformed record or a content
+ * digest mismatch is an error, never skipped silently.
+ */
+export declare function parseJudgmentModelOutcomeRecords(values: readonly unknown[]): {
+    readonly ok: true;
+    readonly records: readonly JudgmentModelOutcomeStoredRecord[];
+} | {
+    readonly ok: false;
+    readonly index: number;
+    readonly message: string;
+};
+/**
+ * Count outcomes per world model at its current catalog revision. Outcomes
+ * recorded against an older revision are not counted: whether a refutation
+ * still holds after a revision is a separate judgment.
+ */
+export declare function summarizeJudgmentModelOutcomes(records: readonly JudgmentModelOutcomeStoredRecord[], catalog: JudgmentFrameCatalog): ReadonlyMap<string, JudgmentModelOutcomeSummary>;

package/dist/judgment-model-outcome.js

@@ -0,0 +1,216 @@
+import { createHash } from 'node:crypto';
+/**
+ * Judgment outcome feedback for world models (brainbase-project ADR-014 F6).
+ *
+ * After a judgment that used a world model as a prediction, the observed
+ * result is appended as a separate record bound to the model's id and
+ * revision. The model itself (revision, validationState, adoptionState) is
+ * never changed here: adoption and promotion stay human decisions.
+ *
+ * Records are checked structurally against the current catalog. Whether a
+ * verdict is semantically right is not judged. A refutation must explain why
+ * measurement error, execution difference, and external change were ruled
+ * out, so a prediction gap alone is never recorded as a refutation.
+ */
+export const JUDGMENT_MODEL_OUTCOME_RECORD_VERSION = 'judgment-model-outcome.v1';
+export const JUDGMENT_MODEL_OUTCOME_ALTERNATIVES = ['measurement_error', 'execution_difference', 'external_change'];
+const VERDICTS = ['supports', 'refutes', 'inconclusive'];
+const EVIDENCE_KINDS = ['artifact', 'query', 'document', 'judgment'];
+const MAX_STATEMENT = 2_000;
+const MAX_RULED_OUT = 1_000;
+const MAX_EVIDENCE = 12;
+const MAX_EVIDENCE_REF = 800;
+const MAX_EVIDENCE_LABEL = 200;
+const MAX_REFUTED_WHEN = 3;
+const MAX_REFUTED_WHEN_TEXT = 120;
+const DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/;
+const CONTROL_CHARACTERS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/u;
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const nonEmpty = (value, max) => typeof value === 'string' && value.trim().length > 0 && value.length <= max;
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (isRecord(value)) {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function clip(value, max) {
+    const chars = [...value];
+    return chars.length <= max ? value : `${chars.slice(0, max - 1).join('')}…`;
+}
+/** Digest of the outcome content. Host-owned id and time are not part of it. */
+export function judgmentModelOutcomeDigest(outcome) {
+    return `sha256:${createHash('sha256').update(canonicalJson(outcomeContent(outcome)), 'utf8').digest('hex')}`;
+}
+function outcomeContent(value) {
+    return {
+        record_version: value.record_version,
+        model: { id: value.model.id, revision: value.model.revision },
+        verdict: value.verdict,
+        prediction: value.prediction,
+        observed: value.observed,
+        conditions: value.conditions,
+        evidence_refs: value.evidence_refs.map(({ kind, ref, label }) => ({ kind, ref, label })),
+        ...(value.ruled_out === undefined ? {} : {
+            ruled_out: Object.fromEntries(JUDGMENT_MODEL_OUTCOME_ALTERNATIVES.map((key) => [key, value.ruled_out[key]])),
+        }),
+        ...(value.judgment_ref === undefined ? {} : { judgment_ref: { frame_digest: value.judgment_ref.frame_digest } }),
+    };
+}
+function checkText(value, path, max, issue, unsafe) {
+    if (!nonEmpty(value, max)) {
+        issue('outcome_record_invalid', path, `${path} must be a non-empty string of at most ${max} characters`);
+        return false;
+    }
+    if (CONTROL_CHARACTERS.test(value)) {
+        issue('outcome_text_unsafe', path, `${path} contains control characters`);
+        return false;
+    }
+    if (unsafe(value)) {
+        issue('outcome_text_unsafe', path, `${path} contains a credential-like value`);
+        return false;
+    }
+    return true;
+}
+/** Structural checks shared by new input and stored records. Catalog checks are separate. */
+function checkOutcomeShape(value, issue, unsafe) {
+    if (value.record_version !== JUDGMENT_MODEL_OUTCOME_RECORD_VERSION) {
+        issue('outcome_record_invalid', 'record_version', `record_version must be ${JUDGMENT_MODEL_OUTCOME_RECORD_VERSION}`);
+    }
+    const model = isRecord(value.model) ? value.model : null;
+    if (!model || !nonEmpty(model.id, 1_000) || !nonEmpty(model.revision, 64)) {
+        issue('outcome_record_invalid', 'model', 'model needs id and revision');
+    }
+    if (!VERDICTS.includes(value.verdict)) {
+        issue('outcome_record_invalid', 'verdict', 'verdict must be supports, refutes, or inconclusive');
+    }
+    checkText(value.prediction, 'prediction', MAX_STATEMENT, issue, unsafe);
+    checkText(value.observed, 'observed', MAX_STATEMENT, issue, unsafe);
+    checkText(value.conditions, 'conditions', MAX_STATEMENT, issue, unsafe);
+    const evidence = Array.isArray(value.evidence_refs) ? value.evidence_refs : null;
+    if (!evidence || evidence.length === 0) {
+        issue('outcome_evidence_missing', 'evidence_refs', 'an outcome needs at least one evidence reference');
+    }
+    else if (evidence.length > MAX_EVIDENCE) {
+        issue('outcome_record_invalid', 'evidence_refs', `evidence_refs allows at most ${MAX_EVIDENCE} entries`);
+    }
+    else {
+        evidence.forEach((entry, index) => {
+            const path = `evidence_refs[${index}]`;
+            if (!isRecord(entry) || !EVIDENCE_KINDS.includes(entry.kind)) {
+                issue('outcome_record_invalid', `${path}.kind`, 'evidence kind must be artifact, query, document, or judgment');
+                return;
+            }
+            checkText(entry.ref, `${path}.ref`, MAX_EVIDENCE_REF, issue, unsafe);
+            checkText(entry.label, `${path}.label`, MAX_EVIDENCE_LABEL, issue, unsafe);
+        });
+    }
+    if (value.verdict === 'refutes') {
+        const ruledOut = isRecord(value.ruled_out) ? value.ruled_out : null;
+        for (const key of JUDGMENT_MODEL_OUTCOME_ALTERNATIVES) {
+            if (!ruledOut || ruledOut[key] === undefined) {
+                issue('outcome_ruled_out_missing', `ruled_out.${key}`, `a refutation must say why ${key} does not explain the gap`);
+            }
+            else {
+                checkText(ruledOut[key], `ruled_out.${key}`, MAX_RULED_OUT, issue, unsafe);
+            }
+        }
+        for (const key of Object.keys(ruledOut ?? {})) {
+            if (!JUDGMENT_MODEL_OUTCOME_ALTERNATIVES.includes(key)) {
+                issue('outcome_record_invalid', `ruled_out.${key}`, 'ruled_out contains an unknown field');
+            }
+        }
+    }
+    else if (value.ruled_out !== undefined) {
+        issue('outcome_ruled_out_unexpected', 'ruled_out', 'ruled_out is only for refutes');
+    }
+    if (value.judgment_ref !== undefined) {
+        const ref = isRecord(value.judgment_ref) ? value.judgment_ref : null;
+        if (!ref || typeof ref.frame_digest !== 'string' || !DIGEST_PATTERN.test(ref.frame_digest) || Object.keys(ref).length !== 1) {
+            issue('outcome_record_invalid', 'judgment_ref', 'judgment_ref needs only frame_digest as sha256');
+        }
+    }
+}
+/**
+ * Validate a new outcome against the catalog shown on this turn. The model
+ * must be a world model in the catalog, at its current revision.
+ */
+export function validateJudgmentModelOutcome(value, catalog, unsafe = () => false) {
+    const issues = [];
+    const issue = (code, path, message) => issues.push({ code, path, message });
+    if (!isRecord(value)) {
+        issue('outcome_record_invalid', '$', 'outcome must be an object');
+        return { valid: false, issues };
+    }
+    if (value.catalog_digest !== catalog.digest) {
+        issue('outcome_catalog_mismatch', 'catalog_digest', 'catalog_digest does not match the current catalog');
+    }
+    checkOutcomeShape(value, issue, unsafe);
+    const model = isRecord(value.model) ? value.model : {};
+    if (typeof model.id === 'string') {
+        const item = catalog.items.find((candidate) => candidate.id === model.id);
+        if (!item) {
+            issue('outcome_model_unknown', 'model.id', `${model.id} is not in the catalog`);
+        }
+        else if (item.kind !== 'model') {
+            issue('outcome_not_model', 'model.id', `${model.id} is a ${item.kind}; outcomes are recorded only for world models`);
+        }
+        else if (model.revision !== item.revision) {
+            issue('outcome_revision_mismatch', 'model.revision', `${model.id} is at revision ${item.revision}, not ${String(model.revision)}`);
+        }
+    }
+    if (issues.length > 0)
+        return { valid: false, issues };
+    return { valid: true, issues: [], outcome: outcomeContent(value) };
+}
+/**
+ * Parse records returned by the host store. A malformed record or a content
+ * digest mismatch is an error, never skipped silently.
+ */
+export function parseJudgmentModelOutcomeRecords(values) {
+    const records = [];
+    for (const [index, value] of values.entries()) {
+        if (!isRecord(value) || !nonEmpty(value.id, 200) || !nonEmpty(value.recorded_at, 64)
+            || Number.isNaN(Date.parse(value.recorded_at)) || typeof value.digest !== 'string' || !DIGEST_PATTERN.test(value.digest)) {
+            return { ok: false, index, message: 'stored outcome needs id, recorded_at, and digest' };
+        }
+        const issues = [];
+        checkOutcomeShape(value, (code, path, message) => issues.push({ code, path, message }), () => false);
+        if (issues.length > 0)
+            return { ok: false, index, message: `${issues[0].path}: ${issues[0].message}` };
+        const content = outcomeContent(value);
+        if (judgmentModelOutcomeDigest(content) !== value.digest) {
+            return { ok: false, index, message: 'stored outcome digest does not match its content' };
+        }
+        records.push({ ...content, id: value.id, recorded_at: value.recorded_at, digest: value.digest });
+    }
+    return { ok: true, records };
+}
+/**
+ * Count outcomes per world model at its current catalog revision. Outcomes
+ * recorded against an older revision are not counted: whether a refutation
+ * still holds after a revision is a separate judgment.
+ */
+export function summarizeJudgmentModelOutcomes(records, catalog) {
+    const current = new Map(catalog.items.filter((item) => item.kind === 'model').map((item) => [item.id, item.revision]));
+    const grouped = new Map();
+    for (const record of records) {
+        if (current.get(record.model.id) !== record.model.revision)
+            continue;
+        grouped.set(record.model.id, [...(grouped.get(record.model.id) ?? []), record]);
+    }
+    const summaries = new Map();
+    for (const [id, group] of grouped) {
+        const refutations = group
+            .filter((record) => record.verdict === 'refutes')
+            .sort((left, right) => Date.parse(right.recorded_at) - Date.parse(left.recorded_at) || right.id.localeCompare(left.id));
+        summaries.set(id, {
+            supports: group.filter((record) => record.verdict === 'supports').length,
+            refutes: refutations.length,
+            inconclusive: group.filter((record) => record.verdict === 'inconclusive').length,
+            refuted_when: refutations.slice(0, MAX_REFUTED_WHEN).map((record) => clip(record.conditions, MAX_REFUTED_WHEN_TEXT)),
+        });
+    }
+    return summaries;
+}