@unson/brainbase-mcp 0.22.6 → 0.23.1

package/dist/judgment-frame-read.d.ts

@@ -0,0 +1,34 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { type JudgmentFrameKind, type JudgmentFrameRecordsPage } from './judgment-frame.js';
+type JudgmentFrameReadResult = {
+    readonly status: 'ok';
+    readonly data: {
+        readonly schema_version: 'brainbase-judgment-frame-read-v1';
+        readonly catalog_digest: `sha256:${string}`;
+        readonly records: readonly JudgmentFrameReadRecord[];
+    };
+} | {
+    readonly status: 'unavailable' | 'error';
+    readonly error: {
+        readonly code: string;
+        readonly message: string;
+        readonly details?: unknown;
+    };
+};
+export type JudgmentFrameReadRecord = {
+    readonly kind: JudgmentFrameKind;
+    readonly ref: string;
+    readonly body: string;
+    readonly body_digest: `sha256:${string}`;
+    readonly version: string;
+    readonly version_source: 'graph' | 'body_digest';
+    readonly applicability_scope: string;
+    readonly applicability_scope_source: 'graph' | 'unspecified';
+};
+export type JudgmentFrameReadDependencies = {
+    /** Read every record of one kind visible to the caller, at most `limit`. */
+    readonly loadRecords: (kind: JudgmentFrameKind, limit: number) => Promise<JudgmentFrameRecordsPage>;
+};
+export declare const judgmentFrameReadTools: Tool[];
+export declare function handleJudgmentFrameReadToolCall(name: string, args: Record<string, unknown>, dependencies: JudgmentFrameReadDependencies): Promise<JudgmentFrameReadResult | null>;
+export {};

package/dist/judgment-frame-read.js

@@ -0,0 +1,223 @@
+import { createHash } from 'node:crypto';
+import { buildJudgmentFrameCatalog, } from './judgment-frame.js';
+const KINDS = ['philosophy', 'objective', 'model'];
+const FRAME_PAGE_LIMIT = 500;
+const MAX_SELECTIONS = 24;
+const DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/u;
+const MAX_REF_LENGTH = 1_000;
+const UNSPECIFIED_APPLICABILITY_SCOPE = 'Graphに適用範囲の記載なし';
+const isRecord = (value) => (Boolean(value) && typeof value === 'object' && !Array.isArray(value));
+const text = (value) => (typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined);
+const versionText = (value) => (text(value) ?? (typeof value === 'number' && Number.isFinite(value) ? String(value) : undefined));
+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(',')}}`;
+    }
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? 'null' : serialized;
+}
+function scopeText(value) {
+    const stringValue = text(value);
+    if (stringValue)
+        return stringValue;
+    if (!isRecord(value) && !Array.isArray(value))
+        return undefined;
+    const serialized = canonicalJson(value);
+    return serialized && serialized !== '{}' && serialized !== '[]' ? serialized : undefined;
+}
+function itemBody(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);
+    }
+    // A model title is a label, not a readable world-model body. Require a
+    // meaning/statement so a name-only catalog item cannot become evidence.
+    return text(foundation.meaning) ?? text(payload.statement);
+}
+function recordScope(kind, record) {
+    const payload = isRecord(record.payload) ? record.payload : {};
+    const foundation = isRecord(payload.foundation) ? payload.foundation : {};
+    const recordMetadata = record;
+    const candidates = kind === 'model'
+        ? [
+            payload.applicability_text,
+            payload.applicability_scope,
+            foundation.applicability_text,
+            foundation.applicability_scope,
+            payload.applicability,
+            foundation.applicability,
+        ]
+        : [
+            payload.applicability_scope,
+            payload.applicability_text,
+            foundation.applicability_scope,
+            foundation.applicability_text,
+            payload.applicability,
+            foundation.applicability,
+        ];
+    candidates.push(recordMetadata.applicability_scope, recordMetadata.applicability_text);
+    for (const candidate of candidates) {
+        const value = scopeText(candidate);
+        if (value)
+            return { value, source: 'graph' };
+    }
+    return { value: UNSPECIFIED_APPLICABILITY_SCOPE, source: 'unspecified' };
+}
+function invalidInput() {
+    return {
+        status: 'error',
+        error: {
+            code: 'judgment_frame_read_input_invalid',
+            message: 'Provide one current catalog digest and one or more unique philosophy, objective, or model references.',
+        },
+    };
+}
+function toolError(status, code, message, details) {
+    return { status, error: { code, message, ...(details === undefined ? {} : { details }) } };
+}
+function isSelection(value) {
+    if (!isRecord(value) || Object.keys(value).length !== 2
+        || !Object.hasOwn(value, 'kind') || !Object.hasOwn(value, 'ref'))
+        return false;
+    return KINDS.includes(value.kind)
+        && typeof value.ref === 'string'
+        && value.ref.trim() === value.ref
+        && value.ref.length > 0
+        && value.ref.length <= MAX_REF_LENGTH;
+}
+function parseInput(args) {
+    if (!isRecord(args)
+        || Object.keys(args).length !== 2
+        || !Object.hasOwn(args, 'catalog_digest')
+        || !Object.hasOwn(args, 'selections')
+        || typeof args.catalog_digest !== 'string'
+        || !DIGEST_PATTERN.test(args.catalog_digest)
+        || !Array.isArray(args.selections)
+        || args.selections.length === 0
+        || args.selections.length > MAX_SELECTIONS
+        || !args.selections.every(isSelection))
+        return null;
+    const selections = args.selections;
+    const keys = selections.map((selection) => `${selection.kind}:${selection.ref}`);
+    if (new Set(keys).size !== keys.length)
+        return null;
+    return { catalogDigest: args.catalog_digest, selections };
+}
+async function loadFrameCatalog(dependencies) {
+    const records = [];
+    for (const kind of KINDS) {
+        let page;
+        try {
+            page = await dependencies.loadRecords(kind, FRAME_PAGE_LIMIT);
+        }
+        catch (error) {
+            return toolError('unavailable', 'judgment_frame_catalog_unavailable', `Graph ${kind} records could not be read: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (page.status !== 'ok')
+            return toolError(page.status, page.code, page.message);
+        if (page.records.length >= FRAME_PAGE_LIMIT) {
+            return toolError('error', 'judgment_frame_catalog_truncated', `Graph returned ${page.records.length} ${kind} records; the catalog may be incomplete`);
+        }
+        records.push(...page.records);
+    }
+    return { ...buildJudgmentFrameCatalog(records), records };
+}
+export const judgmentFrameReadTools = [{
+        name: 'brainbase_judgment_frame_read',
+        description: 'On every confirmed turn, after reading the judgment frame catalog, retrieve the full canonical Graph body, version, and applicability scope for every selected philosophy, objective, and world model reference. Pass the exact catalog_digest and selected kind/ref pairs. The read is authorized against the caller-visible Graph and fails on a stale catalog, unknown reference, or empty body. If Graph metadata has no applicability scope, the result says so explicitly; authorization scope is never presented as applicability scope.',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                catalog_digest: { type: 'string', pattern: '^sha256:[a-f0-9]{64}$' },
+                selections: {
+                    type: 'array',
+                    minItems: 1,
+                    maxItems: MAX_SELECTIONS,
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            kind: { type: 'string', enum: [...KINDS] },
+                            ref: { type: 'string', minLength: 1, maxLength: MAX_REF_LENGTH },
+                        },
+                        required: ['kind', 'ref'],
+                    },
+                },
+            },
+            required: ['catalog_digest', 'selections'],
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false },
+    }];
+export async function handleJudgmentFrameReadToolCall(name, args, dependencies) {
+    if (name !== 'brainbase_judgment_frame_read')
+        return null;
+    const input = parseInput(args);
+    if (!input)
+        return invalidInput();
+    const loaded = await loadFrameCatalog(dependencies);
+    if ('status' in loaded)
+        return loaded;
+    const { catalog, records: sourceRecords } = loaded;
+    if (input.catalogDigest !== catalog.digest) {
+        return toolError('error', 'judgment_frame_catalog_mismatch', 'The supplied catalog_digest is stale or was produced from a different visible Graph.', { current_catalog_digest: catalog.digest });
+    }
+    const records = [];
+    const sourceByKey = new Map();
+    for (const record of sourceRecords) {
+        const key = `${record.entity_type}:${record.id}`;
+        if (!sourceByKey.has(key))
+            sourceByKey.set(key, record);
+    }
+    for (const selection of input.selections) {
+        const item = catalog.items.find((candidate) => candidate.kind === selection.kind && candidate.id === selection.ref);
+        if (!item) {
+            return toolError('error', 'judgment_frame_ref_unknown', `${selection.kind}/${selection.ref} is not in the current judgment frame catalog`);
+        }
+        const source = sourceByKey.get(`${selection.kind}:${selection.ref}`);
+        if (!source) {
+            return toolError('error', 'judgment_frame_body_unavailable', `${selection.kind}/${selection.ref} is no longer available in the authorized Graph`);
+        }
+        const payload = isRecord(source.payload) ? source.payload : {};
+        const semanticBody = itemBody(selection.kind, payload);
+        if (!semanticBody)
+            return toolError('error', 'judgment_frame_body_unavailable', `${selection.kind}/${selection.ref} has no readable body`);
+        // The catalog intentionally clips a compact summary. Return the full
+        // canonical payload so model predictions, constraints, and measurements
+        // are not silently discarded by the read step.
+        const body = canonicalJson(payload);
+        const bodyDigest = `sha256:${createHash('sha256').update(body, 'utf8').digest('hex')}`;
+        const foundation = isRecord(payload.foundation) ? payload.foundation : {};
+        const graphVersion = versionText(foundation.revision) ?? versionText(source.version);
+        const version = graphVersion ?? bodyDigest;
+        const versionSource = graphVersion ? 'graph' : 'body_digest';
+        const applicabilityScope = recordScope(selection.kind, source);
+        records.push({
+            kind: selection.kind,
+            ref: selection.ref,
+            body,
+            body_digest: bodyDigest,
+            version,
+            version_source: versionSource,
+            applicability_scope: applicabilityScope.value,
+            applicability_scope_source: applicabilityScope.source,
+        });
+    }
+    return {
+        status: 'ok',
+        data: {
+            schema_version: 'brainbase-judgment-frame-read-v1',
+            catalog_digest: catalog.digest,
+            records,
+        },
+    };
+}

package/dist/judgment-frame.d.ts

@@ -125,3 +125,5 @@ export type JudgmentFrameToolResult = {
     };
 };
 export declare function handleJudgmentFrameToolCall(name: string, args: Record<string, unknown>, dependencies: JudgmentFrameToolDependencies): Promise<JudgmentFrameToolResult | null>;
+export { judgmentFrameReadTools, handleJudgmentFrameReadToolCall, } from './judgment-frame-read.js';
+export type { JudgmentFrameReadDependencies, JudgmentFrameReadRecord, } from './judgment-frame-read.js';

package/dist/judgment-frame.js

@@ -381,3 +381,4 @@ export async function handleJudgmentFrameToolCall(name, args, dependencies) {
         },
     };
 }
+export { judgmentFrameReadTools, handleJudgmentFrameReadToolCall, } from './judgment-frame-read.js';

package/dist/knowledge-continuation.d.ts

@@ -97,6 +97,8 @@ export interface KnowledgeLookupState {
     revision: number;
     status: KnowledgeStatus;
     started_at: number;
+    /** Set when the first validated retrieval action is reserved. Old states may omit it. */
+    retrieval_started_at?: number | null;
     limits: KnowledgeLookupLimits;
     attempts: KnowledgeAttempt[];
     required_fields: string[] | null;

package/dist/knowledge-continuation.js

@@ -20,6 +20,7 @@ export function createKnowledgeLookup({ lookupId, question, now = Date.now(), li
         revision: 0,
         status: 'resolving',
         started_at: now,
+        retrieval_started_at: null,
         limits: {
             attempts: bounded(limits.attempts, 8, 16),
             replans: bounded(limits.replans, 4, 8),
@@ -42,8 +43,51 @@ function terminate(state, reason, status = 'unresolved') {
     state.pending = null;
     return state;
 }
+const hasPendingRetrieval = (state) => state.pending !== null && state.pending.kind !== 'finish';
+const retrievalStartedAt = (state) => {
+    if (typeof state.retrieval_started_at === 'number' && Number.isFinite(state.retrieval_started_at)) {
+        return state.retrieval_started_at;
+    }
+    // States written before retrieval_started_at was introduced can still be
+    // bounded safely once they have evidence of a retrieval reservation.
+    if (state.attempts.length > 0 || hasPendingRetrieval(state))
+        return state.started_at;
+    return null;
+};
+const retrievalPhase = (state) => {
+    if (hasPendingRetrieval(state))
+        return 'in_flight';
+    if (state.attempts.length > 0)
+        return 'attempted';
+    return 'not_started';
+};
+function recordTimedOutPendingRetrieval(state) {
+    const pending = state.pending;
+    if (!pending)
+        return;
+    state.pending = null;
+    if (pending.kind === 'finish')
+        return;
+    if (state.attempts.some((attempt) => attempt.attempt_id === pending.tool_use_id))
+        return;
+    // The host cannot tell whether a timed-out reservation reached the tool.
+    // Keep the reservation as an unknown transport attempt rather than treating
+    // a late or missing result as a successful read.
+    state.attempts.push({
+        attempt_id: pending.tool_use_id,
+        kind: pending.kind,
+        fingerprint: pending.fingerprint,
+        outcome: 'transport_error',
+        references: [],
+        searched_scope: {},
+        missing_fields: state.required_fields ?? []
+    });
+    state.revision += 1;
+}
 function expire(state, now) {
-    if (!isKnowledgeLookupTerminal(state) && now - state.started_at >= state.limits.milliseconds) {
+    const startedAt = retrievalStartedAt(state);
+    if (startedAt !== null && !isKnowledgeLookupTerminal(state) && now - startedAt >= state.limits.milliseconds) {
+        recordTimedOutPendingRetrieval(state);
         terminate(state, 'time_budget_exhausted');
     }
     return state;
@@ -196,8 +240,10 @@ function validFinish(state, action) {
 }
 export function prepareKnowledgeAction(previous, input, toolUseId, now = Date.now()) {
     const state = expire(structuredClone(previous), now);
-    if (isKnowledgeLookupTerminal(state))
+    if (isKnowledgeLookupTerminal(state)) {
+        recordTimedOutPendingRetrieval(state);
         return { state, allowed: false, reason: state.termination_reason ?? state.status };
+    }
     if (state.pending)
         return { state, allowed: false, reason: 'attempt_in_flight' };
     if (!record(input))
@@ -312,6 +358,9 @@ export function prepareKnowledgeAction(previous, input, toolUseId, now = Date.no
         }
         state.replans += 1;
     }
+    if (state.retrieval_started_at == null && state.attempts.length === 0 && !hasPendingRetrieval(state)) {
+        state.retrieval_started_at = now;
+    }
     state.pending = {
         tool_use_id: toolUseId,
         kind: action.kind,
@@ -323,6 +372,14 @@ export function prepareKnowledgeAction(previous, input, toolUseId, now = Date.no
 }
 export function recordKnowledgeResult(previous, input, result, toolUseId, now = Date.now()) {
     const state = structuredClone(previous);
+    if (isKnowledgeLookupTerminal(state)) {
+        // A late PostToolUse must never reopen a finished lookup. Preserve a stale
+        // retrieval reservation as unknown while keeping the terminal state.
+        recordTimedOutPendingRetrieval(state);
+        return state;
+    }
+    if (isKnowledgeLookupTerminal(expire(state, now)))
+        return state;
     if (typeof toolUseId === 'string' && state.finished_calls.includes(toolUseId))
         return state;
     if (!state.pending ||
@@ -411,8 +468,10 @@ export function recordKnowledgeResult(previous, input, result, toolUseId, now =
 }
 export function stopKnowledgeLookup(previous, now = Date.now()) {
     const state = expire(structuredClone(previous), now);
-    if (isKnowledgeLookupTerminal(state))
+    if (isKnowledgeLookupTerminal(state)) {
+        recordTimedOutPendingRetrieval(state);
         return { state, block: false, reason: knowledgeLookupContext(state) };
+    }
     state.stop_requests += 1;
     if (state.stop_requests > state.limits.replans) {
         terminate(state, 'model_did_not_produce_executable_plan');
@@ -444,6 +503,7 @@ export function knowledgeLookupContext(state) {
         revision: state.revision,
         question: state.question,
         status: state.status,
+        retrieval_phase: retrievalPhase(state),
         required_fields: state.required_fields,
         attempts: state.attempts,
         remaining_attempts: Math.max(0, state.limits.attempts - state.attempts.length),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.22.6",
+  "version": "0.23.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",
@@ -407,5 +407,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "2a650ddc4aa96a2a2b8c1fa99eb231750fabbc57"
+  "gitHead": "da34b87b5890ae3bc4c89bffe6faa54a302e3276"
 }

package/ui/objective-editor.css

@@ -243,6 +243,8 @@ textarea.objective-editor-input { min-height: 5.4rem; resize: vertical; }
 .bb-objective-rail { display: block; }
 .bb-objective-rail > .bb-ws-notice { margin: var(--bb-space-4) 0 0; }
 .bb-objective-rail > .bb-ws-actions { padding-top: 22px; }
+.bb-objective-rail > .bb-objective-revision-note { margin: var(--bb-space-4) 0 0; }
+.bb-objective-rail > .bb-objective-revision-note + .bb-ws-actions { padding-top: var(--bb-space-3); }
 .bb-objective-rail .bb-ws-rail-block > p + p,
 .bb-objective-rail .bb-objective-note { margin-top: var(--bb-space-2); }
 .bb-objective-rail .bb-objective-note { color: var(--bb-color-muted); font-size: 12px; }

package/ui/objective-editor.js

@@ -1121,6 +1121,7 @@ function renderObjectiveDetail(doc, state, callbacks) {
   parts.push(workspaceRailBlock(doc, { title: '制約の参照', className: 'bb-objective-constraints-block', content: constraintContent(doc, state, callbacks) }));
   parts.push(workspaceRailBlock(doc, { title: '判断に使えるか', className: 'bb-objective-readiness-block', content: readinessContent(doc, state.readiness) }));
   if (callbacks.canEdit) {
+    parts.push(makeElement('p', { className: 'objective-editor-muted bb-objective-revision-note', text: '直して保存すると同じ目的の新しい版を作ります。保存結果を読み戻して確認し、確認できない場合はその状態を表示します。' }));
     parts.push(workspaceActions(doc, [{ text: '目的を直す', variant: 'primary', onClick: callbacks.onEdit }]));
   }
   return parts;