@unson/brainbase-mcp 0.10.12 → 0.10.14

package/dist/judgment-frame.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Judgment frame (brainbase-project ADR-014).
+ *
+ * A judgment-bearing turn selects the philosophy, objectives, and world models
+ * that bear on the decision from a compact catalog, and records how each
+ * selected reference was used for each option. The catalog is small enough to
+ * show in full; the record is checked structurally, never for semantic quality.
+ *
+ * Status is a label, not a gate: draft objectives and unverified models stay
+ * usable. Only superseded or inactive records are excluded from the catalog.
+ */
+export declare const JUDGMENT_FRAME_CATALOG_VERSION: "judgment-frame-catalog.v1";
+export declare const JUDGMENT_FRAME_RECORD_VERSION: "judgment-frame-record.v1";
+export type JudgmentFrameKind = 'philosophy' | 'objective' | 'model';
+export type JudgmentFrameStatus = 'active' | 'draft' | 'adopted_unverified' | 'verified';
+export type JudgmentFrameRole = 'constraint' | 'criterion' | 'prediction';
+export type JudgmentFrameConstraintVerdict = 'satisfied' | 'violated' | 'tension';
+/** Each kind is used in exactly one way inside an option evaluation. */
+export declare const JUDGMENT_FRAME_ROLE_BY_KIND: Readonly<Record<JudgmentFrameKind, JudgmentFrameRole>>;
+export interface JudgmentFrameSourceRecord {
+    readonly id: string;
+    readonly entity_type: string;
+    readonly version?: number | string;
+    readonly lifecycle_status?: string;
+    readonly payload?: Record<string, unknown>;
+}
+export interface JudgmentFrameCatalogItem {
+    readonly id: string;
+    readonly kind: JudgmentFrameKind;
+    readonly revision: string;
+    readonly status: JudgmentFrameStatus;
+    readonly text: string;
+    readonly applies_when?: string;
+}
+export interface JudgmentFrameCatalog {
+    readonly catalog_version: typeof JUDGMENT_FRAME_CATALOG_VERSION;
+    readonly digest: `sha256:${string}`;
+    readonly items: readonly JudgmentFrameCatalogItem[];
+}
+export interface JudgmentFrameExclusion {
+    readonly id: string;
+    readonly reason: 'inactive' | 'superseded' | 'restates_source_philosophy' | 'missing_text' | 'unsupported_type';
+}
+export interface JudgmentFrameCatalogBuild {
+    readonly catalog: JudgmentFrameCatalog;
+    readonly excluded: readonly JudgmentFrameExclusion[];
+}
+export interface JudgmentFrameSelection {
+    readonly ref: string;
+    readonly kind: JudgmentFrameKind;
+    readonly why: string;
+}
+export interface JudgmentFrameUse {
+    readonly ref: string;
+    readonly role: JudgmentFrameRole;
+    readonly note: string;
+    /** Required for constraint uses: how the option stands against the philosophy. */
+    readonly verdict?: JudgmentFrameConstraintVerdict;
+}
+export interface JudgmentFrameOption {
+    readonly label: string;
+    readonly uses: readonly JudgmentFrameUse[];
+}
+export interface JudgmentFrameRecord {
+    readonly record_version: typeof JUDGMENT_FRAME_RECORD_VERSION;
+    readonly catalog_digest: string;
+    readonly selections: readonly JudgmentFrameSelection[];
+    /** Why no reference of a kind applies. Required for each kind without a selection. */
+    readonly none?: Partial<Record<JudgmentFrameKind, string>>;
+    readonly options: readonly JudgmentFrameOption[];
+    readonly chosen_option: string;
+}
+export type JudgmentFrameIssueCode = 'frame_record_invalid' | 'frame_catalog_mismatch' | 'frame_ref_unknown' | 'frame_kind_mismatch' | 'frame_selection_duplicate' | 'frame_kind_unaddressed' | 'frame_kind_contradiction' | 'frame_use_unselected' | 'frame_role_mismatch' | 'frame_verdict_missing' | 'frame_selection_unused' | 'frame_chosen_unknown';
+export interface JudgmentFrameIssue {
+    readonly code: JudgmentFrameIssueCode;
+    readonly path: string;
+    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 interface JudgmentFrameEscalation {
+    readonly code: JudgmentFrameEscalationCode;
+    readonly refs: readonly string[];
+}
+export interface JudgmentFrameValidation {
+    readonly valid: boolean;
+    readonly issues: readonly JudgmentFrameIssue[];
+    readonly escalations: readonly JudgmentFrameEscalation[];
+}
+/**
+ * Build the compact catalog shown to the model on a judgment-bearing turn.
+ * 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;
+/**
+ * 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;

package/dist/judgment-frame.js

@@ -0,0 +1,251 @@
+import { createHash } from 'node:crypto';
+/**
+ * Judgment frame (brainbase-project ADR-014).
+ *
+ * A judgment-bearing turn selects the philosophy, objectives, and world models
+ * that bear on the decision from a compact catalog, and records how each
+ * selected reference was used for each option. The catalog is small enough to
+ * show in full; the record is checked structurally, never for semantic quality.
+ *
+ * Status is a label, not a gate: draft objectives and unverified models stay
+ * usable. Only superseded or inactive records are excluded from the catalog.
+ */
+export const JUDGMENT_FRAME_CATALOG_VERSION = 'judgment-frame-catalog.v1';
+export const JUDGMENT_FRAME_RECORD_VERSION = 'judgment-frame-record.v1';
+/** Each kind is used in exactly one way inside an option evaluation. */
+export const JUDGMENT_FRAME_ROLE_BY_KIND = Object.freeze({
+    philosophy: 'constraint',
+    objective: 'criterion',
+    model: 'prediction',
+});
+const KINDS = ['philosophy', 'objective', 'model'];
+const MAX_TEXT = 400;
+const MAX_APPLIES_WHEN = 160;
+const MAX_NOTE = 2_000;
+const MAX_SELECTIONS = 24;
+const MAX_OPTIONS = 8;
+const MAX_USES = 32;
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const text = (value) => typeof value === 'string' && value.trim() ? value.trim() : undefined;
+const nonEmpty = (value, max) => typeof value === 'string' && value.trim().length > 0 && value.length <= max;
+function clip(value, max) {
+    const chars = [...value];
+    return chars.length <= max ? value : `${chars.slice(0, max - 1).join('')}…`;
+}
+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 itemText(kind, payload) {
+    const foundation = isRecord(payload.foundation) ? payload.foundation : {};
+    if (kind === 'philosophy') {
+        const statement = text(payload.statement) ?? text(foundation.meaning);
+        const name = text(payload.display_name) ?? text(payload.title);
+        if (!statement)
+            return undefined;
+        return name && name !== statement ? `${name}：${statement}` : statement;
+    }
+    if (kind === 'objective')
+        return text(foundation.desiredState) ?? text(foundation.meaning) ?? text(payload.statement);
+    return text(foundation.meaning) ?? text(payload.statement) ?? text(payload.title);
+}
+function itemStatus(kind, payload) {
+    const foundation = isRecord(payload.foundation) ? payload.foundation : {};
+    if (kind === 'model') {
+        if (foundation.validationState === 'verified')
+            return 'verified';
+        if (foundation.adoptionState === 'approved')
+            return 'adopted_unverified';
+        return 'draft';
+    }
+    const state = text(foundation.adoptionState) ?? text(payload.status);
+    return state === 'active' || state === 'approved' ? 'active' : 'draft';
+}
+function isSuperseded(payload) {
+    const foundation = isRecord(payload.foundation) ? payload.foundation : {};
+    return [payload.status, foundation.adoptionState, foundation.lifecycle]
+        .some((value) => typeof value === 'string' && /^(superseded|retired|rejected)/.test(value));
+}
+/**
+ * Build the compact catalog shown to the model on a judgment-bearing turn.
+ * Excluded records are returned with a reason so a shrinking catalog is visible.
+ */
+export function buildJudgmentFrameCatalog(records) {
+    const philosophyIds = new Set(records.filter((record) => record.entity_type === 'philosophy').map((record) => record.id));
+    const items = [];
+    const excluded = [];
+    for (const record of records) {
+        const kind = KINDS.find((candidate) => candidate === record.entity_type);
+        if (!kind) {
+            excluded.push({ id: record.id, reason: 'unsupported_type' });
+            continue;
+        }
+        const payload = isRecord(record.payload) ? record.payload : {};
+        if (record.lifecycle_status !== undefined && record.lifecycle_status !== 'active') {
+            excluded.push({ id: record.id, reason: 'inactive' });
+            continue;
+        }
+        if (isSuperseded(payload)) {
+            excluded.push({ id: record.id, reason: 'superseded' });
+            continue;
+        }
+        const decomposition = isRecord(payload.decomposition) ? payload.decomposition : {};
+        const sourcePin = isRecord(decomposition.sourcePin) ? decomposition.sourcePin : {};
+        if (kind === 'philosophy' && typeof sourcePin.id === 'string' && sourcePin.id !== record.id && philosophyIds.has(sourcePin.id)) {
+            excluded.push({ id: record.id, reason: 'restates_source_philosophy' });
+            continue;
+        }
+        const body = itemText(kind, payload);
+        if (!body) {
+            excluded.push({ id: record.id, reason: 'missing_text' });
+            continue;
+        }
+        const foundation = isRecord(payload.foundation) ? payload.foundation : {};
+        const appliesWhen = kind === 'model' ? text(payload.applicability_text) : undefined;
+        items.push({
+            id: record.id,
+            kind,
+            revision: text(foundation.revision) ?? String(record.version ?? '1'),
+            status: itemStatus(kind, payload),
+            text: clip(body, MAX_TEXT),
+            ...(appliesWhen ? { applies_when: clip(appliesWhen, MAX_APPLIES_WHEN) } : {}),
+        });
+    }
+    items.sort((left, right) => KINDS.indexOf(left.kind) - KINDS.indexOf(right.kind) || left.id.localeCompare(right.id));
+    const digest = `sha256:${createHash('sha256').update(canonicalJson(items)).digest('hex')}`;
+    return { catalog: { catalog_version: JUDGMENT_FRAME_CATALOG_VERSION, digest, items }, excluded };
+}
+const KIND_HEADINGS = {
+    philosophy: '哲学（constraintとして使う。verdictを付ける）',
+    objective: '目的（criterionとして使う）',
+    model: '世界モデル（predictionとして使う。仮説であり、検証済みとは限らない）',
+};
+/** One line per item, grouped by kind, for the model-facing prompt. */
+export function renderJudgmentFrameCatalog(catalog) {
+    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}）` : ''}`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * 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) {
+    const issues = [];
+    const issue = (code, path, message) => issues.push({ code, path, message });
+    if (!isRecord(value) || value.record_version !== JUDGMENT_FRAME_RECORD_VERSION) {
+        issue('frame_record_invalid', '$', `record_version must be ${JUDGMENT_FRAME_RECORD_VERSION}`);
+        return { valid: false, issues, escalations: [] };
+    }
+    if (value.catalog_digest !== catalog.digest) {
+        issue('frame_catalog_mismatch', 'catalog_digest', 'catalog_digest does not match the catalog shown on this turn');
+    }
+    const byId = new Map(catalog.items.map((item) => [item.id, item]));
+    const selections = Array.isArray(value.selections) ? value.selections : null;
+    if (!selections || selections.length > MAX_SELECTIONS) {
+        issue('frame_record_invalid', 'selections', `selections must be a list of at most ${MAX_SELECTIONS}`);
+    }
+    const selected = new Map();
+    (selections ?? []).forEach((selection, index) => {
+        const path = `selections[${index}]`;
+        if (!isRecord(selection) || !nonEmpty(selection.ref, 1_000) || !nonEmpty(selection.why, MAX_NOTE)
+            || !KINDS.includes(selection.kind)) {
+            issue('frame_record_invalid', path, 'selection needs ref, kind, and why');
+            return;
+        }
+        const item = byId.get(selection.ref);
+        if (!item) {
+            issue('frame_ref_unknown', `${path}.ref`, `${selection.ref} is not in the catalog`);
+            return;
+        }
+        if (item.kind !== selection.kind) {
+            issue('frame_kind_mismatch', `${path}.kind`, `${selection.ref} is a ${item.kind}, not a ${String(selection.kind)}`);
+            return;
+        }
+        if (selected.has(selection.ref)) {
+            issue('frame_selection_duplicate', `${path}.ref`, `${selection.ref} is selected twice`);
+            return;
+        }
+        selected.set(selection.ref, item.kind);
+    });
+    const none = isRecord(value.none) ? value.none : {};
+    for (const kind of KINDS) {
+        const hasSelection = [...selected.values()].includes(kind);
+        const reason = none[kind];
+        if (hasSelection && reason !== undefined) {
+            issue('frame_kind_contradiction', `none.${kind}`, `${kind} has both a selection and a none reason`);
+        }
+        else if (!hasSelection && !nonEmpty(reason, MAX_NOTE)) {
+            issue('frame_kind_unaddressed', `none.${kind}`, `select a ${kind} or give the reason none applies`);
+        }
+    }
+    const options = Array.isArray(value.options) ? value.options : null;
+    if (!options || options.length === 0 || options.length > MAX_OPTIONS) {
+        issue('frame_record_invalid', 'options', `options must list 1 to ${MAX_OPTIONS} evaluated options`);
+    }
+    const used = new Set();
+    const labels = new Set();
+    (options ?? []).forEach((option, optionIndex) => {
+        const path = `options[${optionIndex}]`;
+        if (!isRecord(option) || !nonEmpty(option.label, 400) || !Array.isArray(option.uses) || option.uses.length > MAX_USES) {
+            issue('frame_record_invalid', path, `option needs a label and at most ${MAX_USES} uses`);
+            return;
+        }
+        labels.add(option.label);
+        option.uses.forEach((use, useIndex) => {
+            const usePath = `${path}.uses[${useIndex}]`;
+            if (!isRecord(use) || !nonEmpty(use.ref, 1_000) || !nonEmpty(use.note, MAX_NOTE)) {
+                issue('frame_record_invalid', usePath, 'use needs ref, role, and note');
+                return;
+            }
+            const kind = selected.get(use.ref);
+            if (!kind) {
+                issue('frame_use_unselected', `${usePath}.ref`, `${use.ref} is used but not selected`);
+                return;
+            }
+            if (use.role !== JUDGMENT_FRAME_ROLE_BY_KIND[kind]) {
+                issue('frame_role_mismatch', `${usePath}.role`, `a ${kind} is used as ${JUDGMENT_FRAME_ROLE_BY_KIND[kind]}`);
+                return;
+            }
+            if (use.role === 'constraint' && !['satisfied', 'violated', 'tension'].includes(use.verdict)) {
+                issue('frame_verdict_missing', `${usePath}.verdict`, 'a constraint use needs verdict satisfied, violated, or tension');
+                return;
+            }
+            used.add(use.ref);
+        });
+    });
+    for (const ref of selected.keys()) {
+        if (!used.has(ref))
+            issue('frame_selection_unused', 'selections', `${ref} is selected but not used for any option`);
+    }
+    const chosen = (options ?? []).find((option) => isRecord(option) && option.label === value.chosen_option);
+    if (!nonEmpty(value.chosen_option, 400) || !labels.has(value.chosen_option)) {
+        issue('frame_chosen_unknown', 'chosen_option', 'chosen_option must name one of the option labels');
+    }
+    const escalations = [];
+    if (![...selected.values()].includes('objective') && nonEmpty(none.objective, MAX_NOTE)) {
+        escalations.push({ code: 'objective_unanchored', refs: [] });
+    }
+    const chosenUses = isRecord(chosen) && Array.isArray(chosen.uses) ? chosen.uses : [];
+    if (chosenUses.length > 0) {
+        const verdictRefs = (verdict) => chosenUses
+            .filter((use) => isRecord(use) && use.role === 'constraint' && use.verdict === verdict)
+            .map((use) => String(use.ref));
+        const violated = verdictRefs('violated');
+        const tension = verdictRefs('tension');
+        if (violated.length > 0)
+            escalations.push({ code: 'chosen_violates_philosophy', refs: violated });
+        if (tension.length > 0)
+            escalations.push({ code: 'chosen_philosophy_tension', refs: tension });
+    }
+    return { valid: issues.length === 0, issues, escalations };
+}

package/dist/knowledge-lookup.js

@@ -640,6 +640,25 @@ function unsupported(input, action, error) {
         error: { code: error.code, message: error.message },
     };
 }
+function lookupActionVariant(kind, properties, required) {
+    return {
+        type: 'object',
+        properties: {
+            kind: { const: kind },
+            ...properties,
+            required_fields: {
+                type: 'array',
+                minItems: 1,
+                maxItems: MAX_FIELDS,
+                description: 'Must contain the same public field paths as the top-level required_fields.',
+                items: { type: 'string', minLength: 1, maxLength: MAX_FIELD_LENGTH },
+            },
+            why_different: { type: 'string', minLength: 1, maxLength: MAX_HINT_LENGTH },
+        },
+        required: ['kind', ...required],
+        additionalProperties: false,
+    };
+}
 export const knowledgeLookupTools = [{
         name: 'brainbase_knowledge_lookup',
         description: 'Find and read authorized Graph knowledge by purpose. Each call performs one bounded search, read, relation follow, or finish proposal; project hints never change authorization scope.',
@@ -664,57 +683,49 @@ export const knowledgeLookupTools = [{
                 missing_information: { type: 'array', maxItems: MAX_FIELDS, items: { type: 'string', minLength: 1, maxLength: MAX_HINT_LENGTH } },
                 based_on_attempt_ids: { type: 'array', maxItems: MAX_IDS, items: { type: 'string', minLength: 1, maxLength: 300 } },
                 why_different: { type: 'string', minLength: 1, maxLength: MAX_HINT_LENGTH },
+                // Each variant lists its own properties. Codex renders only the oneOf
+                // variants into the model-facing declaration, so properties declared
+                // beside oneOf are invisible and read/finish calls cannot be written.
                 next_action: {
                     type: 'object',
-                    properties: {
-                        kind: { type: 'string', enum: ['search', 'read', 'follow_relation', 'finish'] },
-                        query: { type: 'string', minLength: 1, maxLength: MAX_TEXT_LENGTH },
-                        entity_types: { type: 'array', maxItems: 10, items: { type: 'string', minLength: 1, maxLength: 100 } },
-                        seed_ids: { type: 'array', minItems: 1, maxItems: MAX_IDS, items: { type: 'string', minLength: 1, maxLength: 1_000 } },
-                        entity_id: { type: 'string', minLength: 1, maxLength: 1_000 },
-                        entity_type: { type: 'string', minLength: 1, maxLength: 100 },
-                        required_fields: {
-                            type: 'array',
-                            minItems: 1,
-                            maxItems: MAX_FIELDS,
-                            description: 'Must contain the same public field paths as the top-level required_fields.',
-                            items: { type: 'string', minLength: 1, maxLength: MAX_FIELD_LENGTH },
-                        },
-                        relation: { type: 'string', minLength: 1, maxLength: MAX_RELATION_LENGTH },
-                        direction: { type: 'string', enum: ['incoming', 'outgoing'] },
-                        target_types: { type: 'array', maxItems: 10, items: { type: 'string', minLength: 1, maxLength: 100 } },
-                        why_different: { type: 'string', minLength: 1, maxLength: MAX_HINT_LENGTH },
-                        assessment: { type: 'string', enum: ['sufficient', 'insufficient'] },
-                        status: { type: 'string', enum: ['satisfied', 'unresolved', 'needs_user_input'] },
-                        reference_ids: { type: 'array', maxItems: MAX_IDS, items: { type: 'string', minLength: 1, maxLength: 1_000 } },
-                        field_evidence: {
-                            type: 'array',
-                            maxItems: MAX_FIELDS,
-                            items: {
-                                type: 'object',
-                                properties: {
-                                    field: { type: 'string', minLength: 1, maxLength: MAX_FIELD_LENGTH },
-                                    reference_id: { type: 'string', minLength: 1, maxLength: 1_000 },
-                                    attempt_id: { type: 'string', minLength: 1, maxLength: 300 },
+                    oneOf: [
+                        lookupActionVariant('search', {
+                            query: { type: 'string', minLength: 1, maxLength: MAX_TEXT_LENGTH },
+                            entity_types: { type: 'array', maxItems: 10, items: { type: 'string', minLength: 1, maxLength: 100 } },
+                            seed_ids: { type: 'array', minItems: 1, maxItems: MAX_IDS, items: { type: 'string', minLength: 1, maxLength: 1_000 } },
+                        }, []),
+                        lookupActionVariant('read', {
+                            entity_id: { type: 'string', minLength: 1, maxLength: 1_000 },
+                            entity_type: { type: 'string', minLength: 1, maxLength: 100 },
+                        }, ['entity_id', 'entity_type']),
+                        lookupActionVariant('follow_relation', {
+                            seed_ids: { type: 'array', minItems: 1, maxItems: MAX_IDS, items: { type: 'string', minLength: 1, maxLength: 1_000 } },
+                            relation: { type: 'string', minLength: 1, maxLength: MAX_RELATION_LENGTH },
+                            direction: { type: 'string', enum: ['incoming', 'outgoing'] },
+                            target_types: { type: 'array', maxItems: 10, items: { type: 'string', minLength: 1, maxLength: 100 } },
+                        }, ['seed_ids', 'relation', 'direction']),
+                        lookupActionVariant('finish', {
+                            assessment: { type: 'string', enum: ['sufficient', 'insufficient'] },
+                            status: { type: 'string', enum: ['satisfied', 'unresolved', 'needs_user_input'] },
+                            reference_ids: { type: 'array', maxItems: MAX_IDS, items: { type: 'string', minLength: 1, maxLength: 1_000 } },
+                            field_evidence: {
+                                type: 'array',
+                                maxItems: MAX_FIELDS,
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        field: { type: 'string', minLength: 1, maxLength: MAX_FIELD_LENGTH },
+                                        reference_id: { type: 'string', minLength: 1, maxLength: 1_000 },
+                                        attempt_id: { type: 'string', minLength: 1, maxLength: 300 },
+                                    },
+                                    required: ['field', 'reference_id', 'attempt_id'],
+                                    additionalProperties: false,
                                 },
-                                required: ['field', 'reference_id', 'attempt_id'],
-                                additionalProperties: false,
                             },
-                        },
-                        unresolved_items: { type: 'array', maxItems: MAX_FIELDS, items: { type: 'string', minLength: 1, maxLength: MAX_HINT_LENGTH } },
-                        termination_reason: { type: 'string', minLength: 1, maxLength: MAX_HINT_LENGTH },
-                    },
-                    oneOf: [
-                        { properties: { kind: { const: 'search' } }, required: ['kind'] },
-                        { properties: { kind: { const: 'read' } }, required: ['kind', 'entity_id', 'entity_type'] },
-                        { properties: { kind: { const: 'follow_relation' } }, required: ['kind', 'seed_ids', 'relation', 'direction'] },
-                        {
-                            properties: { kind: { const: 'finish' } },
-                            required: ['kind', 'assessment', 'status', 'reference_ids', 'field_evidence', 'unresolved_items', 'termination_reason'],
-                        },
+                            unresolved_items: { type: 'array', maxItems: MAX_FIELDS, items: { type: 'string', minLength: 1, maxLength: MAX_HINT_LENGTH } },
+                            termination_reason: { type: 'string', minLength: 1, maxLength: MAX_HINT_LENGTH },
+                        }, ['assessment', 'status', 'reference_ids', 'field_evidence', 'unresolved_items', 'termination_reason']),
                     ],
-                    required: ['kind'],
-                    additionalProperties: false,
                 },
             },
             required: ['question', 'target_hint', 'required_fields'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.10.12",
+  "version": "0.10.14",
   "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",
@@ -27,6 +27,10 @@
       "types": "./dist/judgment-dag-composition.d.ts",
       "import": "./dist/judgment-dag-composition.js"
     },
+    "./judgment-frame": {
+      "types": "./dist/judgment-frame.d.ts",
+      "import": "./dist/judgment-frame.js"
+    },
     "./judgment-value-proof": {
       "types": "./dist/judgment-value-proof.d.ts",
       "import": "./dist/judgment-value-proof.js"
@@ -340,5 +344,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "10493d41000c832bf85c33fc30e920a4c194fe61"
+  "gitHead": "12a3ed63536642f2b00504b38c5a93672737c697"
 }

package/ui/value-proof-review.js

@@ -875,9 +875,14 @@ export function renderValueProofReview(root, state, callbacks = {}, options = {}
   surface.append(renderCoverageNotice(doc, home));
   if (home.coverage.possiblyStalled) {
     surface.append(workspaceNotice(doc, {
-      label: '記録の停止',
+      label: '価値の確認記録の停止',
       tone: 'warning',
-      text: 'しばらく新しい記録がありません。記録が止まっている可能性があります。0件を「何も無かった」とは扱いません。',
+      text: noticeBody(
+        doc,
+        'しばらく新しい価値の確認記録（.value-proof.json）がありません。',
+        'この画面は判断journalのうち価値の確認記録だけを表示しています。判断journalには別の記録（episode/final）が書かれますが、この注意はjournal全体の停止を示しません。journal全体の最新の書き込み状況は、この画面では確認できません。',
+        '保存済み件数や最新時刻が未確認の場合は、0件・成功とは扱いません。',
+      ),
     }));
   }
   surface.append(renderFilters(doc, home, state, callbacks), renderMetrics(doc, home));