@unson/brainbase-mcp 0.4.1 → 0.5.0

package/dist/portable-graph.js

@@ -0,0 +1,240 @@
+import { createHash } from 'node:crypto';
+import { validateCanonicalGraph } from './canonical-graph.js';
+import { retrieveGraph } from './graph-retrieval.js';
+/** The public, read-only interchange format for a canonical Graph v2 snapshot. */
+export const PORTABLE_GRAPH_SCHEMA_VERSION = 1;
+/** Bounds keep an imported snapshot finite before it reaches a runtime or model. */
+export const PORTABLE_GRAPH_MAX_ENTITIES = 10_000;
+export const PORTABLE_GRAPH_MAX_EDGES = 25_000;
+export const PORTABLE_GRAPH_MAX_DECISIONS = 10_000;
+export const PORTABLE_GRAPH_MAX_JSON_BYTES = 8_000_000;
+export const PORTABLE_GRAPH_MAX_JSON_DEPTH = 64;
+/**
+ * Create a detached Graph v2 bundle for transfer between the OSS and
+ * organization runtimes. Personal KG, legacy relationships, source files, and
+ * the local data directory are deliberately outside this contract.
+ */
+export function createPortableGraph(os) {
+    if (!os || typeof os !== 'object' || !('graph' in os) || !('decisions' in os)) {
+        throw new Error('PORTABLE-GRAPH-SOURCE: a PersonalOs with graph and decisions is required');
+    }
+    validateCanonicalGraph(os.graph);
+    if (os.graph.version !== 2) {
+        throw new Error('PORTABLE-GRAPH-V1-REJECTED: only Graph v2 can be exported');
+    }
+    if (!Array.isArray(os.decisions)) {
+        throw new Error('PORTABLE-GRAPH-DECISIONS: decisions must be an array');
+    }
+    const decisionIds = new Set(os.graph.entities.filter((entity) => entity.type === 'decision').map((entity) => entity.id));
+    const decisions = os.decisions
+        .filter((decision) => decisionIds.has(decision.id))
+        .map((decision) => structuredClone(decision))
+        .sort((left, right) => left.id.localeCompare(right.id, 'en'));
+    const bundle = {
+        schemaVersion: PORTABLE_GRAPH_SCHEMA_VERSION,
+        graph: structuredClone(os.graph),
+        decisions
+    };
+    validatePortableGraph(bundle);
+    return bundle;
+}
+/**
+ * Validate the exact portable contract. Unknown top-level fields are rejected
+ * so an organization runtime cannot silently ignore a new capability. Unknown
+ * fields inside Graph records are retained after the canonical Graph validator
+ * accepts them, which keeps forward-compatible metadata lossless.
+ */
+export function validatePortableGraph(value) {
+    assertJsonValue(value, '$', new WeakSet(), 0);
+    if (!isPlainRecord(value))
+        throw new Error('PORTABLE-GRAPH-SHAPE: bundle must be a plain JSON object');
+    const topLevelKeys = Object.getOwnPropertyNames(value).sort();
+    const expected = ['decisions', 'graph', 'schemaVersion'];
+    const unknownKeys = topLevelKeys.filter((key) => !expected.includes(key));
+    if (unknownKeys.length > 0) {
+        throw new Error(`PORTABLE-GRAPH-SHAPE: unknown top-level field ${unknownKeys[0]}`);
+    }
+    if (value.schemaVersion !== PORTABLE_GRAPH_SCHEMA_VERSION) {
+        throw new Error(`PORTABLE-GRAPH-VERSION: unsupported portable schema version ${String(value.schemaVersion)}`);
+    }
+    if (!isPlainRecord(value.graph)) {
+        throw new Error('PORTABLE-GRAPH-SHAPE: graph must be a plain JSON object');
+    }
+    if (value.graph.version === 1) {
+        throw new Error('PORTABLE-GRAPH-V1-REJECTED: portable bundles require Graph v2');
+    }
+    if (!Array.isArray(value.decisions)) {
+        throw new Error('PORTABLE-GRAPH-DECISIONS: decisions must be an array');
+    }
+    const graph = value.graph;
+    if (graph.version !== 2) {
+        // Keep the canonical validator's explicit version error for other future
+        // versions while still making the portable boundary clear to callers.
+        validateCanonicalGraph(graph);
+    }
+    validateCanonicalGraph(graph);
+    if (graph.entities.length > PORTABLE_GRAPH_MAX_ENTITIES) {
+        throw new Error(`PORTABLE-GRAPH-BOUND: graph.entities exceeds ${PORTABLE_GRAPH_MAX_ENTITIES}`);
+    }
+    if (graph.edges.length > PORTABLE_GRAPH_MAX_EDGES) {
+        throw new Error(`PORTABLE-GRAPH-BOUND: graph.edges exceeds ${PORTABLE_GRAPH_MAX_EDGES}`);
+    }
+    if (value.decisions.length > PORTABLE_GRAPH_MAX_DECISIONS) {
+        throw new Error(`PORTABLE-GRAPH-BOUND: decisions exceeds ${PORTABLE_GRAPH_MAX_DECISIONS}`);
+    }
+    validateDecisionRecords(graph, value.decisions);
+    const bytes = Buffer.byteLength(canonicalPortableJson(value), 'utf8');
+    if (bytes > PORTABLE_GRAPH_MAX_JSON_BYTES) {
+        throw new Error(`PORTABLE-GRAPH-BOUND: JSON payload exceeds ${PORTABLE_GRAPH_MAX_JSON_BYTES} bytes`);
+    }
+}
+/** Rehydrate a validated bundle into the shared retrieval input shape. */
+export function hydratePortableGraph(bundle) {
+    validatePortableGraph(bundle);
+    return {
+        dataDir: '',
+        graph: structuredClone(bundle.graph),
+        personalKg: [],
+        relationships: { version: 1, relationships: [] },
+        decisions: structuredClone(bundle.decisions),
+        // sourceCount counts imported source files in the local SSOT. A portable
+        // Graph bundle contains no source files, so zero is the truthful value.
+        sourceCount: 0
+    };
+}
+/** Use exactly the OSS retrieval implementation against a portable bundle. */
+export function retrievePortableGraph(bundle, input, provider) {
+    return retrieveGraph(hydratePortableGraph(bundle), input, provider);
+}
+/** Canonical JSON with recursively sorted object keys and preserved array order. */
+export function canonicalPortableJson(value) {
+    assertJsonValue(value, '$', new WeakSet(), 0);
+    return stableJson(value, 0);
+}
+/** Stable content identity for a portable Graph bundle. */
+export function portableGraphDigest(value) {
+    validatePortableGraph(value);
+    return `sha256:${createHash('sha256').update(canonicalPortableJson(value), 'utf8').digest('hex')}`;
+}
+/** Descriptive alias for callers that prefer the content-identity wording. */
+export const digestPortableGraph = portableGraphDigest;
+function validateDecisionRecords(graph, decisions) {
+    const decisionEntities = new Set(graph.entities.filter((entity) => entity.type === 'decision').map((entity) => entity.id));
+    const records = new Map();
+    decisions.forEach((value, index) => {
+        if (!isPlainRecord(value))
+            throw new Error(`PORTABLE-GRAPH-DECISION-SHAPE at decisions[${index}]`);
+        requireNonEmptyString(value.id, `decisions[${index}].id`);
+        requireNonEmptyString(value.title, `decisions[${index}].title`);
+        requireNonEmptyString(value.decision, `decisions[${index}].decision`);
+        if (records.has(value.id))
+            throw new Error(`PORTABLE-GRAPH-DECISION-ID-UNIQUE: duplicate decision ID ${value.id}`);
+        records.set(value.id, value);
+        optionalString(value.topic, `decisions[${index}].topic`);
+        optionalString(value.rationale, `decisions[${index}].rationale`);
+        optionalString(value.updatedAt, `decisions[${index}].updatedAt`);
+        if (value.effectiveAt !== undefined) {
+            if (typeof value.effectiveAt !== 'string' || !isRfc3339(value.effectiveAt)) {
+                throw new Error(`PORTABLE-GRAPH-DECISION-DATE at decisions[${index}].effectiveAt`);
+            }
+        }
+        if (value.tags !== undefined && (!Array.isArray(value.tags) || value.tags.some((tag) => typeof tag !== 'string'))) {
+            throw new Error(`PORTABLE-GRAPH-DECISION-TAGS at decisions[${index}].tags`);
+        }
+        if (value.supersedes !== undefined) {
+            if (!Array.isArray(value.supersedes) || value.supersedes.some((id) => typeof id !== 'string' || id.trim() === '')) {
+                throw new Error(`PORTABLE-GRAPH-DECISION-SUPERSEDES at decisions[${index}].supersedes`);
+            }
+            const refs = new Set();
+            for (const target of value.supersedes) {
+                if (refs.has(target))
+                    throw new Error(`PORTABLE-GRAPH-DECISION-REFERENCE: duplicate supersedes reference ${target}`);
+                refs.add(target);
+            }
+        }
+    });
+    for (const id of decisionEntities) {
+        if (!records.has(id))
+            throw new Error(`PORTABLE-GRAPH-DECISION-REFERENCE: missing decision record for Graph entity ${id}`);
+    }
+    for (const [id, decision] of records) {
+        const entity = graph.entities.find((candidate) => candidate.id === id);
+        if (!entity || entity.type !== 'decision') {
+            throw new Error(`PORTABLE-GRAPH-DECISION-REFERENCE: decision record ${id} has no Graph decision entity`);
+        }
+        for (const target of decision.supersedes ?? []) {
+            if (!records.has(target)) {
+                throw new Error(`PORTABLE-GRAPH-DECISION-REFERENCE: decision ${id} supersedes missing decision ${target}`);
+            }
+        }
+    }
+}
+function requireNonEmptyString(value, path) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new Error(`PORTABLE-GRAPH-STRING at ${path}`);
+}
+function optionalString(value, path) {
+    if (value !== undefined && typeof value !== 'string')
+        throw new Error(`PORTABLE-GRAPH-STRING at ${path}`);
+}
+function isRfc3339(value) {
+    return /^(?:\d{4})-(?:\d{2})-(?:\d{2})T(?:\d{2}):(?:\d{2}):(?:\d{2})(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/u.test(value) && Number.isFinite(Date.parse(value));
+}
+function isPlainRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function assertJsonValue(value, path, active, depth) {
+    if (depth > PORTABLE_GRAPH_MAX_JSON_DEPTH)
+        throw new Error(`PORTABLE-GRAPH-BOUND: JSON depth exceeds ${PORTABLE_GRAPH_MAX_JSON_DEPTH} at ${path}`);
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new Error(`PORTABLE-GRAPH-JSON: non-finite number at ${path}`);
+        return;
+    }
+    if (typeof value !== 'object')
+        throw new Error(`PORTABLE-GRAPH-JSON: non-JSON value at ${path}`);
+    if (active.has(value))
+        throw new Error(`PORTABLE-GRAPH-JSON: cyclic value at ${path}`);
+    active.add(value);
+    try {
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index += 1) {
+                if (!(index in value))
+                    throw new Error(`PORTABLE-GRAPH-JSON: sparse array at ${path}[${index}]`);
+                assertJsonValue(value[index], `${path}[${index}]`, active, depth + 1);
+            }
+            return;
+        }
+        if (!isPlainRecord(value))
+            throw new Error(`PORTABLE-GRAPH-JSON: value at ${path} must be a plain JSON object`);
+        for (const key of Object.getOwnPropertyNames(value)) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor || !('value' in descriptor))
+                throw new Error(`PORTABLE-GRAPH-JSON: accessor at ${path}.${key}`);
+            assertJsonValue(descriptor.value, `${path}.${key}`, active, depth + 1);
+        }
+        if (Object.getOwnPropertySymbols(value).length > 0)
+            throw new Error(`PORTABLE-GRAPH-JSON: symbol key at ${path}`);
+    }
+    finally {
+        active.delete(value);
+    }
+}
+function stableJson(value, depth) {
+    if (depth > PORTABLE_GRAPH_MAX_JSON_DEPTH)
+        throw new Error(`PORTABLE-GRAPH-BOUND: JSON depth exceeds ${PORTABLE_GRAPH_MAX_JSON_DEPTH}`);
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableJson(item, depth + 1)).join(',')}]`;
+    const record = value;
+    const pairs = Object.getOwnPropertyNames(record).sort().map((key) => `${JSON.stringify(key)}:${stableJson(record[key], depth + 1)}`);
+    return `{${pairs.join(',')}}`;
+}

package/dist/server.d.ts

@@ -1,7 +1,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 export declare const toolDefinitions: readonly [{
     readonly name: "get_context";
-    readonly description: "Return initial AI context from local Graph and Personal KG canonical files.";
+    readonly description: "Return an initial owner context snapshot. For a question needing related judgments or evidence, use search with an explicit relation plan; this snapshot is not a retrieval answer.";
     readonly inputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -35,19 +35,58 @@ export declare const toolDefinitions: readonly [{
     };
 }, {
     readonly name: "search";
-    readonly description: "Search all canonical local stores: Graph entities, Personal KG, relationships, and decisions. Use this for people and projects.";
+    readonly description: "Find canonical Graph candidates, follow explicit typed relations, and return evidence and missing information. Use seedIds from resolve_entity/list_entities or previous results and steps from the observed relation catalog. Configured embeddings enable semantic discovery; without them discovery is lexical and reported as limited. Never treat similarity as proof or empty results as absence. Personal KG has its own search tool.";
     readonly inputSchema: {
         readonly type: "object";
         readonly required: readonly ["query"];
+        readonly additionalProperties: false;
         readonly properties: {
             readonly dataDir: {
                 readonly type: "string";
             };
+            readonly asOf: {
+                readonly type: "string";
+                readonly format: "date-time";
+                readonly description: "Compatibility alias for as_of.";
+            };
             readonly query: {
                 readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly seedIds: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly maxItems: 10;
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Canonical IDs chosen by the calling model; no embeddings needed.";
+            };
+            readonly steps: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly maxItems: 3;
+                readonly items: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["relation", "direction"];
+                    readonly properties: {
+                        readonly relation: {
+                            readonly enum: readonly ["member_of", "participates_in", "accountable_for", "owned_by", "governs", "supersedes"];
+                        };
+                        readonly direction: {
+                            readonly enum: readonly ["incoming", "outgoing"];
+                        };
+                        readonly targetType: {
+                            readonly enum: readonly ["person", "org", "project", "decision"];
+                        };
+                    };
+                };
             };
             readonly limit: {
-                readonly type: "number";
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 50;
             };
             readonly project: {
                 readonly type: "string";

package/dist/server.js

@@ -1,4 +1,7 @@
+import { createOrganizationGraphConfig, createOrganizationGraphClient } from './organization-graph.js';
 import { createHash } from 'node:crypto';
+import { retrieveGraph } from './graph-retrieval.js';
+import { createEmbeddingProviderFromEnv } from './embedding-provider.js';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
@@ -22,8 +25,16 @@ const argsSchema = z.object({
     ontologyVersion: z.string().optional(),
     asOf: z.string().datetime({ offset: true }).optional(),
     project: z.string().min(1).optional(),
-    as_of: z.string().datetime({ offset: true }).optional()
+    as_of: z.string().datetime({ offset: true }).optional(),
+    seedIds: z.array(z.string().min(1)).min(1).max(10).optional(),
+    steps: z.array(z.object({
+        relation: z.enum(['member_of', 'participates_in', 'accountable_for', 'owned_by', 'governs', 'supersedes']),
+        direction: z.enum(['incoming', 'outgoing']),
+        targetType: z.enum(['person', 'org', 'project', 'decision']).optional()
+    }).strict()).min(1).max(3).optional(),
+    mode: z.never().optional()
 });
+const searchArgsSchema = argsSchema.pick({ dataDir: true, query: true, limit: true, project: true, as_of: true, asOf: true, seedIds: true, steps: true, mode: true }).strict();
 const mentionSpanSchema = z.object({
     start: z.number().int().nonnegative(),
     end: z.number().int().positive()
@@ -117,7 +128,7 @@ const connectedSchemas = {
 export const toolDefinitions = [
     {
         name: 'get_context',
-        description: 'Return initial AI context from local Graph and Personal KG canonical files.',
+        description: 'Return an initial owner context snapshot. For a question needing related judgments or evidence, use search with an explicit relation plan; this snapshot is not a retrieval answer.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -140,14 +151,24 @@ export const toolDefinitions = [
     },
     {
         name: 'search',
-        description: 'Search all canonical local stores: Graph entities, Personal KG, relationships, and decisions. Use this for people and projects.',
+        description: 'Find canonical Graph candidates, follow explicit typed relations, and return evidence and missing information. Use seedIds from resolve_entity/list_entities or previous results and steps from the observed relation catalog. Configured embeddings enable semantic discovery; without them discovery is lexical and reported as limited. Never treat similarity as proof or empty results as absence. Personal KG has its own search tool.',
         inputSchema: {
             type: 'object',
             required: ['query'],
+            additionalProperties: false,
             properties: {
                 dataDir: { type: 'string' },
-                query: { type: 'string' },
-                limit: { type: 'number' },
+                asOf: { type: 'string', format: 'date-time', description: 'Compatibility alias for as_of.' },
+                query: { type: 'string', minLength: 1 },
+                seedIds: { type: 'array', minItems: 1, maxItems: 10, items: { type: 'string' }, description: 'Canonical IDs chosen by the calling model; no embeddings needed.' },
+                steps: { type: 'array', minItems: 1, maxItems: 3, items: {
+                        type: 'object', additionalProperties: false, required: ['relation', 'direction'], properties: {
+                            relation: { enum: ['member_of', 'participates_in', 'accountable_for', 'owned_by', 'governs', 'supersedes'] },
+                            direction: { enum: ['incoming', 'outgoing'] },
+                            targetType: { enum: ['person', 'org', 'project', 'decision'] }
+                        }
+                    } },
+                limit: { type: 'integer', minimum: 1, maximum: 50 },
                 project: { type: 'string', description: 'Optional canonical project ID, name, or alias.' },
                 as_of: { type: 'string', format: 'date-time', description: 'RFC 3339 validity instant. Defaults to now.' }
             }
@@ -330,6 +351,15 @@ export const toolDefinitions = [
         }
     }
 ];
+let embeddingProvider;
+let embeddingProviderInitialized = false;
+function configuredEmbeddingProvider() {
+    if (!embeddingProviderInitialized) {
+        embeddingProvider = createEmbeddingProviderFromEnv();
+        embeddingProviderInitialized = true;
+    }
+    return embeddingProvider;
+}
 export async function callBrainbaseTool(name, rawArgs = {}) {
     if (name in connectedSchemas) {
         return callConnectedOnboardingTool(name, rawArgs);
@@ -337,7 +367,7 @@ export async function callBrainbaseTool(name, rawArgs = {}) {
     if (name === 'resolve_entity') {
         return callResolveEntityTool(rawArgs);
     }
-    const args = argsSchema.parse(rawArgs ?? {});
+    const args = (name === 'search' ? searchArgsSchema : argsSchema).parse(rawArgs ?? {});
     const dataDir = resolveDataDir(args.dataDir);
     switch (name) {
         case 'get_ontology':
@@ -400,6 +430,13 @@ export async function callBrainbaseTool(name, rawArgs = {}) {
         case 'ontology_impact':
             return getOntologyImpact(args.fromVersion);
     }
+    if (name === 'search') {
+        const organization = createOrganizationGraphConfig();
+        if (organization) {
+            return createOrganizationGraphClient(organization).search({ query: args.query, limit: args.limit,
+                project: args.project, asOf: args.as_of ?? args.asOf, seedIds: args.seedIds, steps: args.steps });
+        }
+    }
     const os = await loadPersonalOs(dataDir);
     switch (name) {
         case 'get_context':
@@ -410,7 +447,15 @@ export async function callBrainbaseTool(name, rawArgs = {}) {
             if (!args.query) {
                 throw new Error('search requires query');
             }
-            return { results: searchAll(os, args.query, args.limit, { project: args.project, asOf: args.as_of ?? args.asOf }) };
+            if (os.graph.version !== 2) {
+                if (args.seedIds || args.steps)
+                    throw new Error('graph_retrieval_migration_required');
+                return { results: searchAll(os, args.query, args.limit, { project: args.project, asOf: args.as_of ?? args.asOf }),
+                    status: 'migration_required', discovery: 'legacy_lexical', absenceConfirmed: false,
+                    sufficiency: 'insufficient', partialReasons: ['canonical_graph_v2_required'] };
+            }
+            return retrieveGraph(os, { query: args.query, limit: args.limit, project: args.project,
+                asOf: args.as_of ?? args.asOf, seedIds: args.seedIds, steps: args.steps }, args.seedIds ? undefined : configuredEmbeddingProvider());
         case 'search_personal_kg':
             if (!args.query) {
                 throw new Error('search_personal_kg requires query');

package/docs/management/judgment-dag-milestones.md

@@ -3,12 +3,42 @@ title: Brainbase Judgment DAG Milestones
 status: active
 date: 2026-08-20
 scope: OSS Brainbase
+governed_by_repository: Unson-LLC/brainbase-unson
+governed_by_path: docs/management/milestones/brainbase-program-master-roadmap.md
+governed_by_machine_path: docs/management/milestones/brainbase-program-master-roadmap.json
+governed_by_commit: 18544f58a2a0298d97eab45de2f05544bed48a43
+governed_by_markdown_sha256: 167afb6d3fc57198c9f5ffca06fbafea968a5435af04f44b55017199b6d859fe
+governed_by_json_sha256: f3e6e023060ef3976f367ed7efa62ac57f7091f517ea1ca1d13824d9e6ca429f
+program_packages:
+  - R0
+  - J0
+  - G0
+  - R1
+  - D0
+  - P0
+  - C0
 ---
 
 # Brainbase Judgment DAG Milestones
 
 This roadmap replaces any implicit assumption that OSS Brainbase stops at memory retrieval. The next milestones make the shared Judgment DAG core real without prematurely building a complete enterprise ontology.
 
+## Program governance
+
+この文書はOSS Judgment DAGのcomponent roadmapであり、cross-repositoryの依存順、開始条件、完了条件は`Unson-LLC/brainbase-unson`の`docs/management/milestones/brainbase-program-master-roadmap.md`に従う。受理した正本snapshotはcommit `18544f58a2a0298d97eab45de2f05544bed48a43`へ固定し、Markdownとmachine-readable JSONのpath・SHA-256は`contracts/judgment-dag/source-lock.json`を正本とする。対応するProgram work packageは R0 / J0 / G0 / R1 / D0 / P0 / C0 である。競合時は固定したProgram Master Roadmapを優先し、この文書のM0〜M6をProgram全体の順序や完了判定へ読み替えない。新しいProgram revisionへ追随する場合は、commitと両content hashを明示的に更新し、契約生成・検証・独立レビューを再実行する。
+
+| Component milestone | Program work package |
+|---|---|
+| M0 Architecture lock | R0 + J0 |
+| M1 Local DAG kernel | J0 |
+| M2 Human + Agent judgment runners | G0 |
+| M3 Replay and evaluation | R1 |
+| M4 Brainbase Deployment dogfood | D0 |
+| M5 Scope promotion | P0 |
+| M6 Organization-ready primitives | G0 + C0 |
+
+Program statusには `planned` / `contract_ready` / `implementing` / `verified` / `production_proven` / `done` の6語彙だけを使う。hard dependencyを満たさないmilestoneを`done`にしない。文書のmergeだけを実装完了または`done`と扱わず、未実施・未収集・staleな証跡をpassや0件へ丸めない。
+
 ## M0 — Architecture lock
 
 Goal: freeze semantic boundaries before implementation.
@@ -140,4 +170,4 @@ The roadmap is not complete merely because graph/node counts increase. Measure:
 4. **Outcome calibration** — do judgment versions improve against declared goals?
 5. **Promotion quality** — are reusable judgments correctly distinguished from case-specific decisions?
 
-The primary dogfood KPI is **expert escalation count per deployment**, not total stored knowledge.
+The primary dogfood KPI is **expert escalation count per deployment**, not total stored knowledge.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.4.1",
-  "description": "Local-first Brainbase MCP for preserving decision context and helping humans and AI work from the same judgment criteria.",
+  "version": "0.5.0",
+  "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",
   "repository": {
@@ -19,11 +19,21 @@
       "types": "./dist/judgment-dag.d.ts",
       "import": "./dist/judgment-dag.js"
     },
+    "./judgment-value-proof": {
+      "types": "./dist/judgment-value-proof.d.ts",
+      "import": "./dist/judgment-value-proof.js"
+    },
+    "./portable-graph": {
+      "types": "./dist/portable-graph.d.ts",
+      "import": "./dist/portable-graph.js"
+    },
     "./dist/*": "./dist/*",
     "./contracts/judgment-dag/schema.json": "./contracts/judgment-dag/schema.json",
     "./contracts/judgment-dag/fixture.json": "./contracts/judgment-dag/fixture.json",
     "./contracts/judgment-dag/source-lock.json": "./contracts/judgment-dag/source-lock.json",
     "./contracts/judgment-dag/digest.json": "./contracts/judgment-dag/digest.json",
+    "./contracts/judgment-value-proof/schema.json": "./contracts/judgment-value-proof/schema.json",
+    "./contracts/judgment-value-proof/fixture.json": "./contracts/judgment-value-proof/fixture.json",
     "./package.json": "./package.json"
   },
   "bin": {
@@ -51,10 +61,10 @@
     "test:e2e": "vitest run tests/e2e/brainbase-mcp-only-acceptance.spec.ts tests/e2e/story-brainbase-portable-ontology-kernel-acceptance.spec.ts",
     "docs:dev": "vitepress dev docs",
     "docs:sync": "node scripts/sync-public-message.mjs --write",
-    "docs:check": "node scripts/check-public-docs.mjs",
+    "docs:check": "node scripts/check-public-docs.mjs && node scripts/check-organization-teaser.mjs",
     "docs:build": "vitepress build docs",
-    "docs:smoke": "node scripts/check-built-docs.mjs",
-    "docs:verify-public": "node scripts/verify-public-site.mjs",
+    "docs:smoke": "node scripts/check-built-docs.mjs && node scripts/check-built-organization-teaser.mjs",
+    "docs:verify-public": "node scripts/verify-public-site.mjs && node scripts/verify-organization-teaser.mjs",
     "docs:promotion:plan": "node scripts/promote-public-message.mjs --plan",
     "docs:promotion:apply": "node scripts/promote-public-message.mjs --apply",
     "docs:preview": "vitepress preview docs",
@@ -88,5 +98,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "b6210adfb43cf4321148e06dc48e94f200b805a5"
+  "gitHead": "00ba08ebc953a3f8db66e9b624eceebd331c1e24"
 }