@unson/brainbase-mcp 0.23.3 → 0.23.5

package/dist/graph-foundation-reader.js

@@ -1,3 +1,4 @@
+import { assertPrivatePhilosophyRead, privatePhilosophyAcl } from './private-philosophy-graph.js';
 import { cloneFoundationDefinition, digestFoundationDefinition } from './foundation-catalog.js';
 import { canonicalPortableJson } from './portable-graph.js';
 import { FoundationStoreError } from './foundation-store.js';
@@ -295,7 +296,7 @@ function createPhilosophyRevisionRecord(validated, id, revision, principal) {
         applicability: validated.history.applicability,
         // This is a read-time projection of the current Graph permission. It
         // does not mutate the canonical philosophy payload or Graph ACL.
-        currentAcl: privateCurrentAcl(principal),
+        currentAcl: privatePhilosophyAcl(validated.current.payload) ?? privateCurrentAcl(principal),
         currentScope: cloneJudgmentScope(validated.history.applicability.scope)
     };
 }
@@ -337,7 +338,7 @@ async function readCanonicalPhilosophyRevision(input, trustedContext, query) {
                 applicability: validated.history.applicability,
                 // This is a read-time projection of the current Graph permission. It
                 // does not mutate the canonical philosophy payload or Graph ACL.
-                currentAcl: privateCurrentAcl(trustedContext.principal),
+                currentAcl: privatePhilosophyAcl(validated.current.payload) ?? privateCurrentAcl(trustedContext.principal),
                 currentScope: cloneJudgmentScope(validated.history.applicability.scope)
             }
         };
@@ -398,7 +399,7 @@ async function readPhilosophyRevision(input, trustedContext, query) {
                 applicability: validated.history.applicability,
                 // This is a read-time projection of the current Graph permission. It
                 // does not mutate the canonical philosophy payload or Graph ACL.
-                currentAcl: privateCurrentAcl(trustedContext.principal),
+                currentAcl: privatePhilosophyAcl(validated.current.payload) ?? privateCurrentAcl(trustedContext.principal),
                 currentScope: cloneJudgmentScope(reference.scope)
             }
         };
@@ -414,6 +415,10 @@ async function readPhilosophyRevision(input, trustedContext, query) {
 function validatePhilosophyHistoryAccess(row, id, revision, trustedContext) {
     const history = validatePhilosophyHistoryRow(row, { id, revision });
     const current = validateCurrentRow(row, id, 'philosophy');
+    const historicalAcl = assertPrivatePhilosophyRead(history.payload, trustedContext.principal);
+    const currentAcl = assertPrivatePhilosophyRead(current.payload, trustedContext.principal);
+    if (historicalAcl && !currentAcl)
+        throw new FoundationStoreError('authorization_denied', 'Private philosophy history cannot become legacy');
     const philosophy = current.philosophy;
     if (!philosophy) {
         throw corrupt('Current Graph philosophy applicability is missing');

package/dist/judgment-frame.d.ts

@@ -18,6 +18,17 @@ 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>>;
+/**
+ * A caller-provided summary that may be projected to an owner-only history.
+ * Core never derives this value from an answer, tool response, or body.
+ */
+export interface JudgmentFramePublicFrame {
+    readonly summary: string;
+    readonly reason: string;
+}
+export interface JudgmentFramePublicFrameResponse extends JudgmentFramePublicFrame {
+    readonly digest: `sha256:${string}`;
+}
 export interface JudgmentFrameSourceRecord {
     readonly id: string;
     readonly entity_type: string;
@@ -70,8 +81,10 @@ export interface JudgmentFrameRecord {
     readonly none?: Partial<Record<JudgmentFrameKind, string>>;
     readonly options: readonly JudgmentFrameOption[];
     readonly chosen_option: string;
+    /** Explicit opt-in for the future owner-only public projection. */
+    readonly public_frame?: JudgmentFramePublicFrame;
 }
-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 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' | 'frame_public_invalid';
 export interface JudgmentFrameIssue {
     readonly code: JudgmentFrameIssueCode;
     readonly path: string;
@@ -88,6 +101,18 @@ export interface JudgmentFrameValidation {
     readonly issues: readonly JudgmentFrameIssue[];
     readonly escalations: readonly JudgmentFrameEscalation[];
 }
+/**
+ * Compute the digest for the exact two-field public projection.
+ * The response adds this digest; it is intentionally separate from the
+ * full-record digest returned alongside the projection.
+ */
+export declare function judgmentFramePublicFrameDigest(value: JudgmentFramePublicFrame): `sha256:${string}`;
+/**
+ * Compute the stable digest returned with an accepted frame record.
+ * The explicit public frame is part of the digest so a changed projection
+ * cannot be acknowledged as the same judgment.
+ */
+export declare function judgmentFrameRecordDigest(value: JudgmentFrameRecord): `sha256:${string}`;
 /**
  * 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.

package/dist/judgment-frame.js

@@ -25,6 +25,7 @@ const MAX_NOTE = 2_000;
 const MAX_SELECTIONS = 24;
 const MAX_OPTIONS = 8;
 const MAX_USES = 32;
+const MAX_PUBLIC_FRAME_TEXT = 2_000;
 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;
@@ -40,6 +41,45 @@ function canonicalJson(value) {
     }
     return JSON.stringify(value);
 }
+const PUBLIC_FRAME_KEYS = ['summary', 'reason'];
+const PUBLIC_FRAME_SECRET_PATTERNS = [
+    /(?:^|[\s([{])Bearer\s+[A-Za-z0-9._~+\/-]{8,}(?=$|[\s)\]}.,;])/iu,
+    /\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9_-]{16,}|github_pat_[A-Za-z0-9_-]{16,}|xox[baprs]-[A-Za-z0-9-]{16,}|AIza[A-Za-z0-9_-]{16,}|AKIA[0-9A-Z]{16})\b/u,
+    /(?:access[_-]?token|refresh[_-]?token|api[_-]?key|client[_-]?secret|secret|password|credential|authorization|cookie)\s*(?:=|:)\s*[^\s&#;,]+/iu,
+    /\b[a-z][a-z0-9+.-]*:\/\/[^\s/?#:@]+:[^\s/@]+@/iu,
+    /\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) {
+    return PUBLIC_FRAME_SECRET_PATTERNS.some((pattern) => pattern.test(value));
+}
+function publicFrameRecord(value) {
+    return {
+        record_version: value.record_version,
+        catalog_digest: value.catalog_digest,
+        selections: value.selections,
+        ...(value.none === undefined ? {} : { none: value.none }),
+        options: value.options,
+        chosen_option: value.chosen_option,
+        ...(value.public_frame === undefined ? {} : { public_frame: value.public_frame }),
+    };
+}
+/**
+ * Compute the digest for the exact two-field public projection.
+ * The response adds this digest; it is intentionally separate from the
+ * full-record digest returned alongside the projection.
+ */
+export function judgmentFramePublicFrameDigest(value) {
+    return `sha256:${createHash('sha256').update(canonicalJson({ summary: value.summary, reason: value.reason }), 'utf8').digest('hex')}`;
+}
+/**
+ * Compute the stable digest returned with an accepted frame record.
+ * The explicit public frame is part of the digest so a changed projection
+ * cannot be acknowledged as the same judgment.
+ */
+export function judgmentFrameRecordDigest(value) {
+    return `sha256:${createHash('sha256').update(canonicalJson(publicFrameRecord(value)), 'utf8').digest('hex')}`;
+}
 function itemText(kind, payload) {
     const foundation = isRecord(payload.foundation) ? payload.foundation : {};
     if (kind === 'philosophy') {
@@ -146,6 +186,31 @@ export function validateJudgmentFrameRecord(value, catalog) {
         issue('frame_record_invalid', '$', `record_version must be ${JUDGMENT_FRAME_RECORD_VERSION}`);
         return { valid: false, issues, escalations: [] };
     }
+    if (value.public_frame !== undefined) {
+        if (!isRecord(value.public_frame)) {
+            issue('frame_public_invalid', 'public_frame', 'public_frame must be an object with summary and reason');
+        }
+        else {
+            for (const key of Object.keys(value.public_frame)) {
+                if (!PUBLIC_FRAME_KEYS.includes(key)) {
+                    issue('frame_public_invalid', `public_frame.${key}`, 'public_frame contains an unknown field');
+                }
+            }
+            for (const key of PUBLIC_FRAME_KEYS) {
+                const candidate = value.public_frame[key];
+                if (!nonEmpty(candidate, MAX_PUBLIC_FRAME_TEXT)) {
+                    issue('frame_public_invalid', `public_frame.${key}`, `${key} must be a non-empty string of at most ${MAX_PUBLIC_FRAME_TEXT} characters`);
+                    continue;
+                }
+                if (PUBLIC_FRAME_CONTROL_CHARACTERS.test(candidate)) {
+                    issue('frame_public_invalid', `public_frame.${key}`, `${key} contains control characters`);
+                }
+                if (containsPublicFrameCredential(candidate)) {
+                    issue('frame_public_invalid', `public_frame.${key}`, `${key} contains a credential-like value`);
+                }
+            }
+        }
+    }
     if (value.catalog_digest !== catalog.digest) {
         issue('frame_catalog_mismatch', 'catalog_digest', 'catalog_digest does not match the catalog shown on this turn');
     }
@@ -264,6 +329,15 @@ const frameUseSchema = {
     },
     required: ['ref', 'role', 'note'],
 };
+const publicFrameSchema = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        summary: { type: 'string', minLength: 1, maxLength: MAX_PUBLIC_FRAME_TEXT },
+        reason: { type: 'string', minLength: 1, maxLength: MAX_PUBLIC_FRAME_TEXT },
+    },
+    required: [...PUBLIC_FRAME_KEYS],
+};
 export const judgmentFrameTools = [{
         name: 'brainbase_judgment_frame_catalog',
         description: 'On a judgment-bearing turn, read the catalog of philosophy, objectives, and world models visible to you. Select only what bears on this decision. Status is a label (draft objectives and adopted_unverified models are still usable as hypotheses); it is not a reason to skip them. Then call brainbase_judgment_frame_record with the returned catalog_digest.',
@@ -271,7 +345,7 @@ export const judgmentFrameTools = [{
         annotations: { readOnlyHint: true, destructiveHint: false },
     }, {
         name: 'brainbase_judgment_frame_record',
-        description: 'Record the judgment frame: which catalog references you selected and why, and for each evaluated option how each selected reference was used. Philosophy is a constraint (give verdict satisfied, violated, or tension), an objective is a criterion, a world model is a prediction. Every selection must be used by at least one option. For a kind with no applicable reference, give the reason in none instead of selecting. Name the option you chose. The tool rejects references outside the catalog; it does not judge semantic quality. If escalations are returned, ask the human before acting on the chosen option.',
+        description: 'Record the judgment frame: which catalog references you selected and why, and for each evaluated option how each selected reference was used. Philosophy is a constraint (give verdict satisfied, violated, or tension), an objective is a criterion, a world model is a prediction. Every selection must be used by at least one option. For a kind with no applicable reference, give the reason in none instead of selecting. Name the option you chose. The tool rejects references outside the catalog; it does not judge semantic quality. If escalations are returned, ask the human before acting on the chosen option. Include public_frame only when the caller explicitly intends this exact summary and reason for the future owner-only projection; Core never derives it from an answer, tool response, or internal reasoning. public_frame accepts only non-empty safe summary and reason strings up to 2000 characters.',
         inputSchema: {
             type: 'object',
             additionalProperties: false,
@@ -312,6 +386,7 @@ export const judgmentFrameTools = [{
                     },
                 },
                 chosen_option: { type: 'string', minLength: 1, maxLength: 400 },
+                public_frame: publicFrameSchema,
             },
             required: ['record_version', 'catalog_digest', 'selections', 'options', 'chosen_option'],
         },
@@ -378,6 +453,13 @@ export async function handleJudgmentFrameToolCall(name, args, dependencies) {
             option_count: args.options.length,
             chosen_option: args.chosen_option,
             escalations: validation.escalations,
+            ...(args.public_frame === undefined ? {} : {
+                public_frame: {
+                    ...args.public_frame,
+                    digest: judgmentFramePublicFrameDigest(args.public_frame),
+                },
+            }),
+            digest: judgmentFrameRecordDigest(args),
         },
     };
 }

package/dist/private-philosophy-graph.d.ts

@@ -0,0 +1,13 @@
+import type { FoundationAcl } from './ontology-foundation.js';
+/** An explicit ACL opts a philosophy into owner-only storage; absence is legacy. */
+export declare function privatePhilosophyAcl(payload: unknown): FoundationAcl | undefined;
+export declare function assertPrivatePhilosophyRead(payload: unknown, principal: string): FoundationAcl | undefined;
+/** Validate the existing Graph writer, without changing legacy organization philosophy. */
+export declare function assertPrivatePhilosophyWrite(input: {
+    payload: Record<string, unknown>;
+    currentPayload?: Record<string, unknown>;
+    principal: string;
+    projectCode: string;
+    currentVersion: number;
+    expectedVersion?: number;
+}): void;

package/dist/private-philosophy-graph.js

@@ -0,0 +1,60 @@
+import { FoundationStoreError } from './foundation-store.js';
+import { canonicalPortableJson } from './portable-graph.js';
+import { philosophyRevisionDigest } from './philosophy-revision-reader.js';
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const present = (value) => Object.hasOwn(value, 'acl');
+const fail = (code, message) => {
+    throw new FoundationStoreError(code, message);
+};
+/** An explicit ACL opts a philosophy into owner-only storage; absence is legacy. */
+export function privatePhilosophyAcl(payload) {
+    if (!record(payload))
+        return fail('invalid_input', 'Philosophy payload must be an object');
+    if (!present(payload))
+        return undefined;
+    const acl = payload.acl;
+    if (!record(acl) || typeof acl.ownerId !== 'string' || !acl.ownerId.trim()
+        || acl.visibility !== 'private' || !Array.isArray(acl.readerIds) || acl.readerIds.length !== 0
+        || !Array.isArray(acl.writerIds) || acl.writerIds.length !== 0) {
+        return fail('invalid_input', 'Private philosophy requires one owner and no additional readers or writers');
+    }
+    return { ownerId: acl.ownerId, visibility: 'private', readerIds: [], writerIds: [] };
+}
+export function assertPrivatePhilosophyRead(payload, principal) {
+    const acl = privatePhilosophyAcl(payload);
+    if (acl && acl.ownerId !== principal)
+        fail('authorization_denied', 'Private philosophy is owner-only');
+    return acl;
+}
+/** Validate the existing Graph writer, without changing legacy organization philosophy. */
+export function assertPrivatePhilosophyWrite(input) {
+    const currentAcl = input.currentPayload ? privatePhilosophyAcl(input.currentPayload) : undefined;
+    const nextAcl = privatePhilosophyAcl(input.payload);
+    if (!currentAcl && !nextAcl)
+        return;
+    if (!nextAcl || (currentAcl && currentAcl.ownerId !== input.principal)
+        || nextAcl.ownerId !== input.principal)
+        fail('authorization_denied', 'Private philosophy owner cannot change');
+    if (!Number.isSafeInteger(input.expectedVersion) || input.expectedVersion !== input.currentVersion) {
+        fail('revision_conflict', 'Private philosophy requires the exact current Graph version');
+    }
+    if (currentAcl && canonicalPortableJson(currentAcl) !== canonicalPortableJson(nextAcl)) {
+        fail('authorization_denied', 'Private philosophy ACL cannot change');
+    }
+    if (typeof input.payload.statement !== 'string' || !input.payload.statement.trim()) {
+        fail('invalid_input', 'Private philosophy statement is required');
+    }
+    const applicability = input.payload.judgmentApplicability;
+    if (!record(applicability) || !record(applicability.scope)
+        || applicability.scope.type !== 'project' || applicability.scope.id !== input.projectCode) {
+        fail('authorization_denied', 'Private philosophy must remain in its authenticated project');
+    }
+    // Reuse the immutable revision reader's strict applicability/date contract.
+    philosophyRevisionDigest({ kind: 'philosophy', id: 'private-philosophy-validation', revision: '1',
+        payload: input.payload, applicability: applicability });
+    if (currentAcl && canonicalPortableJson(input.currentPayload.judgmentApplicability)
+        !== canonicalPortableJson(applicability))
+        fail('authorization_denied', 'Private philosophy scope cannot change');
+    if (input.currentPayload && !currentAcl)
+        fail('authorization_denied', 'Legacy philosophy privacy requires a reviewed migration');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.23.3",
+  "version": "0.23.5",
   "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",
@@ -347,6 +347,10 @@
     "./meeting-minutes-storage-http": {
       "types": "./dist/meeting-minutes-storage-http.d.ts",
       "import": "./dist/meeting-minutes-storage-http.js"
+    },
+    "./private-philosophy-graph": {
+      "types": "./dist/private-philosophy-graph.d.ts",
+      "import": "./dist/private-philosophy-graph.js"
     }
   },
   "bin": {
@@ -419,5 +423,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "51eca010f2f8df4d24b44bd705467bee1161719d"
+  "gitHead": "98835ea4b24370a96ea81e80716653b416bcd7c3"
 }

package/ui/judgment-history.js

@@ -849,10 +849,27 @@ function appendReferenceList(doc, references) {
   return list;
 }
 
+function evidenceIdentifier(entry) {
+  const direct = text(entry);
+  if (direct) return direct;
+  if (!isRecord(entry)) return '';
+  const label = text(entry.label);
+  const kind = text(entry.kind);
+  const reference = text(entry.ref);
+  const identity = [kind, reference].filter(Boolean).join(':');
+  if (label && identity) return `${label}（${identity}）`;
+  return label || identity;
+}
+
+function evidenceText(entry) {
+  const status = isRecord(entry) && entry.status === 'verified' ? '確認済み' : '未確認';
+  return `${evidenceIdentifier(entry) || '証拠の識別情報は未確認'}（${status}）`;
+}
+
 function appendSupplement(doc, proof) {
   const execution = isRecord(proof.execution) ? proof.execution : {};
   const outcome = isRecord(proof.outcome) ? proof.outcome : {};
-  const evidence = Array.isArray(outcome.evidence_refs) ? outcome.evidence_refs.filter(Boolean).join('、') : '';
+  const evidence = Array.isArray(outcome.evidence_refs) ? outcome.evidence_refs.filter(Boolean).map(evidenceText).join('、') : '';
   return workspaceDefinition(doc, [
     ['実行', [text(execution.status) || '未記録', text(execution.summary)]],
     ['結果', [text(outcome.status) || '未記録', text(outcome.summary), evidence ? `証拠: ${evidence}` : '']],