@unson/brainbase-mcp 0.23.9 → 0.24.1

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;
+}

package/dist/meeting-source-reader.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Reads meeting lists and full transcripts from the official Plaud and Tactiq
+ * MCP servers. The caller supplies `callTool`; this module owns no connection,
+ * OAuth, credential, storage, or sync state. A transcript is `complete` only
+ * when every page was read. Anything else is returned as a classified failure,
+ * never as an empty or partial transcript.
+ */
+export type MeetingSourceProvider = 'plaud' | 'tactiq';
+/** Calls one MCP tool and returns its `CallToolResult`, or throws. */
+export type MeetingSourceCallTool = (name: string, args: Record<string, unknown>) => Promise<unknown>;
+export type MeetingSourceFailureReason = 'reauth_required' | 'access_required' | 'rate_limited' | 'timeout' | 'not_ready' | 'incomplete' | 'provider_error';
+export type MeetingSourceAccessCause = 'plan' | 'connection' | 'ai_credits' | 'preview_only' | 'unknown';
+export interface MeetingSourceAccessDetail {
+    action: string | null;
+    title: string | null;
+    message: string | null;
+    url: string | null;
+    cause: MeetingSourceAccessCause;
+}
+export interface MeetingSourceFailure {
+    reason: MeetingSourceFailureReason;
+    /** `connection` affects every meeting of the connection; `meeting` only this one. */
+    scope: 'connection' | 'meeting';
+    message: string;
+    retryAt: string | null;
+    access?: MeetingSourceAccessDetail;
+}
+export interface MeetingSourceMeeting {
+    provider: MeetingSourceProvider;
+    externalId: string;
+    title: string | null;
+    startedAt: string | null;
+    durationSeconds: number | null;
+    participants: string[];
+    url: string | null;
+}
+export interface MeetingSourceWindow {
+    since: string;
+    until: string;
+}
+export type MeetingSourceListResult = {
+    status: 'ok';
+    meetings: MeetingSourceMeeting[];
+    complete: boolean;
+    incompleteWindows: MeetingSourceWindow[];
+} | {
+    status: 'failed';
+    failure: MeetingSourceFailure;
+};
+export interface MeetingSourceSegment {
+    speaker: string | null;
+    text: string;
+    startMs: number | null;
+    endMs: number | null;
+}
+export type MeetingSourceTranscriptResult = {
+    status: 'complete';
+    segments: MeetingSourceSegment[];
+    text: string;
+    digest: string;
+    pageCount: number;
+    segmentCount: number;
+} | {
+    status: 'unavailable';
+    failure: MeetingSourceFailure;
+};
+export interface MeetingSourceProviderSummary {
+    kind: 'provider_summary';
+    text: string;
+}
+export type MeetingSourceSummaryResult = {
+    status: 'ok';
+    summary: MeetingSourceProviderSummary | null;
+} | {
+    status: 'unavailable';
+    failure: MeetingSourceFailure;
+};
+export interface TactiqTranscriptRead {
+    meetingId: string;
+    readAt: string;
+}
+export interface TactiqTranscriptBudget {
+    /** Reserves a read for `meetingId`. Re-reading a meeting inside the window is free. */
+    tryAcquire(meetingId: string, now: Date): {
+        ok: true;
+    } | {
+        ok: false;
+        retryAt: string;
+    };
+    /** Reads still inside the window, for the caller to persist across runs. */
+    reads(now: Date): TactiqTranscriptRead[];
+}
+export declare const TACTIQ_TRANSCRIPT_READS_PER_HOUR = 10;
+export declare const TACTIQ_SEARCH_LIMIT = 50;
+export declare function createTactiqTranscriptBudget(options?: {
+    limit?: number;
+    windowMs?: number;
+    reads?: TactiqTranscriptRead[];
+}): TactiqTranscriptBudget;
+/** Speaker-attributed text, normalized the same way as `brainbase-unson` `transcript_hash` input. */
+export declare function meetingTranscriptText(segments: readonly MeetingSourceSegment[]): string;
+export declare function meetingTranscriptDigest(text: string): string;
+export declare function listMeetings(input: {
+    provider: MeetingSourceProvider;
+    callTool: MeetingSourceCallTool;
+    since: string;
+    until: string;
+    plaudUtcOffsetMinutes?: number;
+    plaudPageSize?: number;
+    now?: () => Date;
+}): Promise<MeetingSourceListResult>;
+export declare function readTranscript(input: {
+    provider: MeetingSourceProvider;
+    callTool: MeetingSourceCallTool;
+    meetingId: string;
+    budget?: TactiqTranscriptBudget;
+    plaudPageLimit?: number;
+    now?: () => Date;
+}): Promise<MeetingSourceTranscriptResult>;
+export declare function readProviderSummary(input: {
+    provider: MeetingSourceProvider;
+    callTool: MeetingSourceCallTool;
+    meetingId: string;
+    now?: () => Date;
+}): Promise<MeetingSourceSummaryResult>;

package/dist/meeting-source-reader.js

@@ -0,0 +1,479 @@
+import { createHash } from 'node:crypto';
+export const TACTIQ_TRANSCRIPT_READS_PER_HOUR = 10;
+export const TACTIQ_SEARCH_LIMIT = 50;
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+const MIN_TACTIQ_WINDOW_MS = 60 * 1000;
+const MAX_PAGES = 500;
+export function createTactiqTranscriptBudget(options = {}) {
+    const limit = options.limit ?? TACTIQ_TRANSCRIPT_READS_PER_HOUR;
+    const windowMs = options.windowMs ?? HOUR_MS;
+    let reads = [...(options.reads ?? [])];
+    const prune = (now) => {
+        const floor = now.getTime() - windowMs;
+        reads = reads.filter((read) => Date.parse(read.readAt) > floor);
+    };
+    return {
+        tryAcquire(meetingId, now) {
+            prune(now);
+            if (reads.some((read) => read.meetingId === meetingId))
+                return { ok: true };
+            if (reads.length < limit) {
+                reads.push({ meetingId, readAt: now.toISOString() });
+                return { ok: true };
+            }
+            const oldest = Math.min(...reads.map((read) => Date.parse(read.readAt)));
+            return { ok: false, retryAt: new Date(oldest + windowMs).toISOString() };
+        },
+        reads(now) {
+            prune(now);
+            return reads.map((read) => ({ ...read }));
+        },
+    };
+}
+/** Speaker-attributed text, normalized the same way as `brainbase-unson` `transcript_hash` input. */
+export function meetingTranscriptText(segments) {
+    const lines = [];
+    for (const segment of segments) {
+        const line = normalizeWhitespace(segment.text);
+        if (!line)
+            continue;
+        lines.push(segment.speaker ? `${segment.speaker}: ${line}` : line);
+    }
+    return normalizeMultilineText(lines.join('\n'));
+}
+export function meetingTranscriptDigest(text) {
+    return createHash('sha256').update(text).digest('hex');
+}
+export async function listMeetings(input) {
+    const now = input.now ?? (() => new Date());
+    const since = parseInstant(input.since, 'since');
+    const until = parseInstant(input.until, 'until');
+    if (since > until)
+        throw new RangeError('since must not be after until');
+    try {
+        if (input.provider === 'plaud') {
+            return await listPlaud(input.callTool, since, until, input.plaudUtcOffsetMinutes ?? 540, input.plaudPageSize ?? 50);
+        }
+        return await listTactiq(input.callTool, since, until);
+    }
+    catch (error) {
+        return { status: 'failed', failure: await classifyFailure(error, input.provider, input.callTool, 'connection', now()) };
+    }
+}
+export async function readTranscript(input) {
+    const now = input.now ?? (() => new Date());
+    if (input.provider === 'tactiq') {
+        const budget = input.budget ?? createTactiqTranscriptBudget();
+        const slot = budget.tryAcquire(input.meetingId, now());
+        if (!slot.ok) {
+            return unavailable('rate_limited', 'connection', 'Tactiq transcript read limit reached for this hour', slot.retryAt);
+        }
+    }
+    try {
+        const read = input.provider === 'plaud'
+            ? await readPlaudTranscript(input.callTool, input.meetingId, input.plaudPageLimit ?? 200)
+            : await readTactiqTranscript(input.callTool, input.meetingId);
+        if (read.segments.every((segment) => !normalizeWhitespace(segment.text))) {
+            return unavailable('not_ready', 'meeting', 'The transcript has no utterances yet', null);
+        }
+        const text = meetingTranscriptText(read.segments);
+        return {
+            status: 'complete',
+            segments: read.segments,
+            text,
+            digest: meetingTranscriptDigest(text),
+            pageCount: read.pageCount,
+            segmentCount: read.segments.length,
+        };
+    }
+    catch (error) {
+        if (error instanceof IncompleteTranscriptError) {
+            return unavailable('incomplete', 'meeting', error.message, null);
+        }
+        return { status: 'unavailable', failure: await classifyFailure(error, input.provider, input.callTool, 'meeting', now()) };
+    }
+}
+export async function readProviderSummary(input) {
+    const now = input.now ?? (() => new Date());
+    try {
+        if (input.provider === 'plaud') {
+            const payload = await invoke(input.callTool, 'get_note', { file_id: input.meetingId });
+            return { status: 'ok', summary: toSummary(extractText(payload)) };
+        }
+        const payload = asRecord(await invoke(input.callTool, 'get_meeting', { meetingId: input.meetingId }));
+        const detailed = asRecord(payload?.detailedSummary);
+        if (!detailed || detailed.status !== 'ready')
+            return { status: 'ok', summary: null };
+        return { status: 'ok', summary: toSummary(extractText(detailed.content)) };
+    }
+    catch (error) {
+        return { status: 'unavailable', failure: await classifyFailure(error, input.provider, input.callTool, 'meeting', now()) };
+    }
+}
+// ---------------------------------------------------------------------------
+// Plaud
+async function listPlaud(callTool, since, until, utcOffsetMinutes, pageSize) {
+    // Plaud filters by the server-local display date. Widen by a day on each side
+    // so time-zone differences cannot drop meetings at the edges, then filter by
+    // the exact start time.
+    const dateFrom = localDate(since - DAY_MS, utcOffsetMinutes);
+    const dateTo = localDate(until + DAY_MS, utcOffsetMinutes);
+    const meetings = [];
+    let complete = false;
+    for (let page = 1; page <= MAX_PAGES; page += 1) {
+        const items = extractList(await invoke(callTool, 'list_files', { date_from: dateFrom, date_to: dateTo, page, page_size: pageSize }));
+        for (const item of items) {
+            const meeting = plaudMeeting(item, utcOffsetMinutes);
+            if (!meeting)
+                continue;
+            const started = meeting.startedAt ? Date.parse(meeting.startedAt) : NaN;
+            if (Number.isFinite(started) && (started < since || started > until))
+                continue;
+            meetings.push(meeting);
+        }
+        if (items.length < pageSize) {
+            complete = true;
+            break;
+        }
+    }
+    const window = { since: new Date(since).toISOString(), until: new Date(until).toISOString() };
+    return { status: 'ok', meetings: dedupe(meetings), complete, incompleteWindows: complete ? [] : [window] };
+}
+function plaudMeeting(raw, utcOffsetMinutes) {
+    const item = asRecord(raw);
+    const id = stringValue(item?.id) ?? stringValue(item?.file_id) ?? stringValue(item?.fileId);
+    if (!item || !id)
+        return null;
+    const start = stringValue(item.start_at) ?? stringValue(item.created_at);
+    const startMs = start ? parseLocalInstant(start, utcOffsetMinutes) : NaN;
+    return {
+        provider: 'plaud',
+        externalId: id,
+        title: stringValue(item.name) ?? stringValue(item.title),
+        startedAt: Number.isFinite(startMs) ? new Date(startMs).toISOString() : null,
+        durationSeconds: null,
+        participants: [],
+        url: null,
+    };
+}
+async function readPlaudTranscript(callTool, fileId, limit) {
+    const segments = [];
+    const seenCursors = new Set();
+    let cursor = null;
+    let pageCount = 0;
+    let total = null;
+    do {
+        const args = { file_id: fileId, block: 'transaction', limit };
+        if (cursor)
+            args.cursor = cursor;
+        const payload = asRecord(await invoke(callTool, 'get_transcript', args));
+        if (!payload || !Array.isArray(payload.segments))
+            throw new UnexpectedShapeError('Plaud get_transcript returned no segments');
+        pageCount += 1;
+        if (typeof payload.total === 'number')
+            total = payload.total;
+        for (const raw of payload.segments) {
+            const segment = asRecord(raw);
+            if (!segment)
+                continue;
+            segments.push({
+                speaker: trimmed(segment.speaker) ?? trimmed(segment.original_speaker),
+                text: typeof segment.content === 'string' ? segment.content : (typeof segment.text === 'string' ? segment.text : ''),
+                startMs: numberValue(segment.start_time),
+                endMs: numberValue(segment.end_time),
+            });
+        }
+        cursor = stringValue(payload.next_cursor);
+        if (cursor && seenCursors.has(cursor))
+            throw new IncompleteTranscriptError('Plaud returned the same cursor twice');
+        if (cursor)
+            seenCursors.add(cursor);
+        if (cursor && pageCount >= MAX_PAGES)
+            throw new IncompleteTranscriptError('Plaud transcript exceeded the page limit');
+    } while (cursor);
+    if (total !== null && segments.length < total) {
+        throw new IncompleteTranscriptError(`Plaud returned ${segments.length} of ${total} utterances`);
+    }
+    return { segments, pageCount };
+}
+// ---------------------------------------------------------------------------
+// Tactiq
+async function listTactiq(callTool, since, until) {
+    const meetings = [];
+    const incompleteWindows = [];
+    const windows = [[since, until]];
+    while (windows.length) {
+        const [from, to] = windows.shift();
+        const payload = asRecord(await invoke(callTool, 'search_meetings', {
+            dateFrom: new Date(from).toISOString(),
+            dateTo: new Date(to).toISOString(),
+            limit: TACTIQ_SEARCH_LIMIT,
+        }));
+        const results = Array.isArray(payload?.results) ? payload.results : extractList(payload);
+        if (results.length >= TACTIQ_SEARCH_LIMIT) {
+            if (to - from > MIN_TACTIQ_WINDOW_MS) {
+                const middle = from + Math.floor((to - from) / 2);
+                windows.unshift([from, middle], [middle + 1, to]);
+                continue;
+            }
+            incompleteWindows.push({ since: new Date(from).toISOString(), until: new Date(to).toISOString() });
+        }
+        for (const raw of results) {
+            const meeting = tactiqMeeting(raw);
+            if (meeting)
+                meetings.push(meeting);
+        }
+    }
+    return { status: 'ok', meetings: dedupe(meetings), complete: incompleteWindows.length === 0, incompleteWindows };
+}
+function tactiqMeeting(raw) {
+    const item = asRecord(raw);
+    const id = stringValue(item?.id);
+    if (!item || !id)
+        return null;
+    const created = stringValue(item.createdAt);
+    const createdMs = created ? Date.parse(created) : NaN;
+    return {
+        provider: 'tactiq',
+        externalId: id,
+        title: stringValue(item.title),
+        startedAt: Number.isFinite(createdMs) ? new Date(createdMs).toISOString() : null,
+        durationSeconds: numberValue(item.durationSeconds),
+        participants: Array.isArray(item.attendees) ? item.attendees.filter((value) => typeof value === 'string') : [],
+        url: stringValue(item.url),
+    };
+}
+async function readTactiqTranscript(callTool, meetingId) {
+    const segments = [];
+    let page = 1;
+    let pageCount = 0;
+    for (;;) {
+        const payload = asRecord(await invoke(callTool, 'get_transcript', { meetingId, page }));
+        if (!payload || !Array.isArray(payload.entries))
+            throw new UnexpectedShapeError('Tactiq get_transcript returned no entries');
+        pageCount += 1;
+        for (const raw of payload.entries) {
+            const entry = asRecord(raw);
+            if (!entry)
+                continue;
+            const start = numberValue(entry.startSeconds);
+            const end = numberValue(entry.endSeconds);
+            segments.push({
+                speaker: trimmed(entry.speaker),
+                text: typeof entry.text === 'string' ? entry.text : '',
+                startMs: start === null ? null : Math.round(start * 1000),
+                endMs: end === null ? null : Math.round(end * 1000),
+            });
+        }
+        if (payload.hasMore !== true)
+            break;
+        const totalPages = numberValue(payload.totalPages);
+        if ((totalPages !== null && page >= totalPages) || page >= MAX_PAGES) {
+            throw new IncompleteTranscriptError(`Tactiq reported more pages after page ${page}`);
+        }
+        page += 1;
+    }
+    return { segments, pageCount };
+}
+// ---------------------------------------------------------------------------
+// Tool invocation and failure classification
+class ToolCallError extends Error {
+    body;
+    constructor(message, body) {
+        super(message);
+        this.body = body;
+        this.name = 'ToolCallError';
+    }
+}
+class UnexpectedShapeError extends Error {
+}
+class IncompleteTranscriptError extends Error {
+}
+async function invoke(callTool, name, args) {
+    let result;
+    try {
+        result = await callTool(name, args);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ToolCallError(message, findJsonObject(message));
+    }
+    const record = asRecord(result);
+    if (record?.isError === true) {
+        const text = contentText(record);
+        throw new ToolCallError(text || `${name} failed`, parseJson(text) ?? findJsonObject(text));
+    }
+    return payloadOf(result);
+}
+async function classifyFailure(error, provider, callTool, defaultScope, now) {
+    const message = error instanceof Error ? error.message : String(error);
+    const body = error instanceof ToolCallError ? asRecord(error.body) : null;
+    if (provider === 'tactiq' && (body?.error === 'access_required' || /access_required/.test(message))) {
+        const access = await readAccessOptions(callTool);
+        return {
+            reason: 'access_required',
+            scope: access.cause === 'preview_only' ? 'meeting' : 'connection',
+            message,
+            retryAt: null,
+            access,
+        };
+    }
+    if (/oauth authorization is required|unauthori[sz]ed|\b401\b|invalid[_ ]token|not authenticated|login first|please log ?in|token (?:has )?expired/i.test(message)) {
+        return { reason: 'reauth_required', scope: 'connection', message, retryAt: null };
+    }
+    if (/rate.?limit|\b429\b|too many requests/i.test(message)) {
+        return { reason: 'rate_limited', scope: 'connection', message, retryAt: new Date(now.getTime() + HOUR_MS).toISOString() };
+    }
+    if (/timed? ?out|-32001|ETIMEDOUT|AbortError/i.test(message)) {
+        return { reason: 'timeout', scope: defaultScope, message, retryAt: null };
+    }
+    return { reason: 'provider_error', scope: defaultScope, message, retryAt: null };
+}
+async function readAccessOptions(callTool) {
+    try {
+        const access = asRecord(asRecord(await invoke(callTool, 'get_access_options', {}))?.access);
+        const detail = {
+            action: stringValue(access?.action),
+            title: stringValue(access?.title),
+            message: stringValue(access?.message),
+            url: stringValue(access?.url),
+        };
+        return { ...detail, cause: accessCause(`${detail.action ?? ''} ${detail.title ?? ''} ${detail.message ?? ''}`) };
+    }
+    catch {
+        return { action: null, title: null, message: null, url: null, cause: 'unknown' };
+    }
+}
+function accessCause(text) {
+    const value = text.toLowerCase();
+    if (/preview/.test(value))
+        return 'preview_only';
+    if (/credit/.test(value))
+        return 'ai_credits';
+    if (/plan|upgrade|seat|team/.test(value))
+        return 'plan';
+    if (/connect|permission|authori/.test(value))
+        return 'connection';
+    return 'unknown';
+}
+function unavailable(reason, scope, message, retryAt) {
+    return { status: 'unavailable', failure: { reason, scope, message, retryAt } };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+function payloadOf(result) {
+    const record = asRecord(result);
+    if (!record)
+        return result;
+    if (record.structuredContent !== undefined)
+        return record.structuredContent;
+    if (Array.isArray(record.content)) {
+        const text = contentText(record);
+        return parseJson(text) ?? text;
+    }
+    return result;
+}
+function contentText(record) {
+    if (!Array.isArray(record.content))
+        return '';
+    return record.content
+        .map((item) => asRecord(item))
+        .filter((item) => item?.type === 'text' && typeof item.text === 'string')
+        .map((item) => item.text)
+        .join('\n');
+}
+function extractList(payload) {
+    if (Array.isArray(payload))
+        return payload;
+    const record = asRecord(payload);
+    if (!record)
+        return [];
+    for (const key of ['data', 'files', 'items', 'results', 'records', 'recordings']) {
+        if (Array.isArray(record[key]))
+            return record[key];
+    }
+    return [];
+}
+function extractText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value))
+        return value.map(extractText).filter(Boolean).join('\n');
+    const record = asRecord(value);
+    if (!record)
+        return '';
+    for (const key of ['markdown', 'text', 'content', 'summary', 'data_content', 'data']) {
+        const text = extractText(record[key]);
+        if (text)
+            return text;
+    }
+    return '';
+}
+function toSummary(text) {
+    const normalized = normalizeMultilineText(text);
+    return normalized ? { kind: 'provider_summary', text: normalized } : null;
+}
+function dedupe(meetings) {
+    const seen = new Map();
+    for (const meeting of meetings)
+        if (!seen.has(meeting.externalId))
+            seen.set(meeting.externalId, meeting);
+    return [...seen.values()];
+}
+function parseInstant(value, label) {
+    const ms = Date.parse(value);
+    if (!Number.isFinite(ms))
+        throw new RangeError(`${label} must be an ISO 8601 instant`);
+    return ms;
+}
+/** Plaud times without an offset are server-local; interpret them with the given offset. */
+function parseLocalInstant(value, utcOffsetMinutes) {
+    if (/(?:Z|[+-]\d{2}:?\d{2})$/i.test(value))
+        return Date.parse(value);
+    const ms = Date.parse(`${value.replace(' ', 'T')}Z`);
+    return Number.isFinite(ms) ? ms - utcOffsetMinutes * 60 * 1000 : NaN;
+}
+function localDate(ms, utcOffsetMinutes) {
+    return new Date(ms + utcOffsetMinutes * 60 * 1000).toISOString().slice(0, 10);
+}
+function normalizeWhitespace(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim();
+}
+function normalizeMultilineText(value) {
+    return String(value || '')
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        .replace(/[ \t]+/g, ' ')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function stringValue(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return String(value);
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function trimmed(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function parseJson(text) {
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function findJsonObject(text) {
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    return start >= 0 && end > start ? parseJson(text.slice(start, end + 1)) : null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.23.9",
+  "version": "0.24.1",
   "description": "Local-first Brainbase judgment OS that lets supported AI agents reuse a user's approved goals, priorities, decisions, and judgment criteria.",
   "type": "module",
   "license": "MIT",
@@ -135,6 +135,10 @@
       "types": "./dist/meeting-minutes-lineage-adapters.d.ts",
       "import": "./dist/meeting-minutes-lineage-adapters.js"
     },
+    "./meeting-source-reader": {
+      "types": "./dist/meeting-source-reader.d.ts",
+      "import": "./dist/meeting-source-reader.js"
+    },
     "./meeting-minutes-lineage-http": {
       "types": "./dist/meeting-minutes-lineage-http.d.ts",
       "import": "./dist/meeting-minutes-lineage-http.js"
@@ -423,5 +427,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "ffddfb19cbde2520ba00f8370a251de08cd92ab5"
+  "gitHead": "3a1e004ecb50844069ccca0ad19e05b57cb63f9d"
 }

package/ui/judgment-history.css

@@ -96,6 +96,10 @@
   margin-top: 22px;
 }
 
+.bb-jh .bb-ws-notice > .bb-ws-button {
+  justify-self: start;
+}
+
 .bb-jh-ledger {
   border-top-color: var(--bb-color-border-strong);
 }

package/ui/judgment-history.js

@@ -1089,7 +1089,11 @@ function appendNormalFeedbackComposer(doc, record, {
 function renderNormalRail(doc, rail, row, detail, onClose, options = {}) {
   if (!rail) return;
   rail.replaceChildren();
-  const record = detail ?? row;
+  // The home row keeps the canonical raw record so the selected references
+  // remain readable while the detail request is pending or unavailable.
+  // Once the detail readback succeeds, its normalized record takes priority.
+  const homeRecord = row?.mode === 'normal' ? normalizeNormalRecord(row.record) : null;
+  const record = detail ?? homeRecord ?? row;
   rail.append(workspaceRailHead(doc, {
     kicker: `${NORMAL_ENTRYPOINT_LABELS[record.entrypoint] ?? '入口不明'}の判断`,
     title: text(record.judgment?.summary) || '判断内容は未記録',