@unson/brainbase-mcp 0.10.4 → 0.10.5

package/dist/foundation-graph-http.js

@@ -1,6 +1,8 @@
-import { FOUNDATION_HTTP_CONTRACT_VERSION, createFoundationHttpRouter } from './foundation-http.js';
+import { FOUNDATION_HTTP_CONTRACT_VERSION, createFoundationHttpRouter, createObjectiveFoundationRoute } from './foundation-http.js';
+import { checkObjectiveReadiness } from './company-os-objectives.js';
 import { createFoundationPublicProvider, createFoundationPublicRoute } from './foundation-public-provider.js';
 import { createGraphFoundationReaders } from './graph-foundation-reader.js';
+import { FoundationStoreError } from './foundation-store.js';
 /**
  * Readiness probe for the Graph history contract used by the public adapter.
  *
@@ -217,16 +219,36 @@ export function createFoundationGraphHttpHandler(options) {
                     }
                     const readers = createGraphFoundationReaders({
                         context,
+                        selectedProjectCode: scopeId,
                         query: async (text, values) => ({
                             rows: (await client.query(text, values ?? [])).rows
                         })
                     });
                     const provider = createFoundationPublicProvider(readers);
                     const route = createFoundationPublicRoute(provider);
+                    const objectiveRoute = createObjectiveFoundationRoute({
+                        objectives: {
+                            async createObjective() {
+                                throw new FoundationStoreError('unsupported_graph', 'Objective writes are not configured for the Graph read adapter');
+                            },
+                            async readObjective(id, objectiveContext, revision) {
+                                return revision === undefined
+                                    ? readers.store.readLatest('objective', id, objectiveContext)
+                                    : readers.store.read({ id, type: 'objective', revision }, objectiveContext);
+                            },
+                            async updateObjective() {
+                                throw new FoundationStoreError('unsupported_graph', 'Objective writes are not configured for the Graph read adapter');
+                            },
+                            async checkObjectiveReadiness(id, objectiveContext, revision) {
+                                return checkObjectiveReadiness(readers.store, id, objectiveContext, revision);
+                            },
+                            list: (type, objectiveContext) => readers.store.list(type, objectiveContext)
+                        }
+                    });
                     const handler = createFoundationHttpRouter({
                         resolveContext: () => context,
                         csrf: options.csrf,
-                        routes: [route],
+                        routes: [route, objectiveRoute],
                         bodyLimitBytes
                     });
                     return handler.handle(request);

package/dist/graph-foundation-reader.d.ts

@@ -13,6 +13,18 @@ export declare const GRAPH_FOUNDATION_READ_CONTRACT_VERSION: "graph-foundation-h
  * future providers fail closed when they do not prove current-row visibility.
  */
 export declare const GRAPH_FOUNDATION_READ_SQL = "\nSELECT\n  history.entity_id,\n  history.entity_type,\n  history.revision,\n  history.payload,\n  history.project_id,\n  history.role_min,\n  history.sensitivity,\n  history.lifecycle_status,\n  history.storage_digest,\n  history.captured_at,\n  (\n    history.storage_digest = 'sha256:' ||\n      encode(sha256(convert_to(history.payload::text, 'UTF8')), 'hex')\n  ) AS storage_digest_valid,\n  current_entity.id AS current_entity_id,\n  current_entity.entity_type AS current_entity_type,\n  current_entity.payload AS current_payload,\n  current_entity.project_id AS current_project_id,\n  current_entity.role_min AS current_role_min,\n  current_entity.sensitivity AS current_sensitivity,\n  current_entity.lifecycle_status AS current_lifecycle_status,\n  projects.code AS current_project_code,\n  true AS current_visible\nFROM public.graph_foundation_revisions AS history\nJOIN public.graph_entities AS current_entity\n  ON current_entity.id = history.entity_id\n AND current_entity.entity_type = history.entity_type\nJOIN public.projects AS projects\n  ON projects.id = current_entity.project_id\nWHERE history.entity_id = $1\n  AND history.entity_type = $2\n  AND history.revision = $3\n";
+/**
+ * Read the newest immutable revision for one Foundation entity.  The current
+ * Graph row remains part of the query so RLS and the adapter's current-row
+ * checks apply identically to latest and historical reads.
+ */
+export declare const GRAPH_FOUNDATION_LATEST_SQL = "\nSELECT\n  history.entity_id,\n  history.entity_type,\n  history.revision,\n  history.payload,\n  history.project_id,\n  history.role_min,\n  history.sensitivity,\n  history.lifecycle_status,\n  history.storage_digest,\n  history.captured_at,\n  (\n    history.storage_digest = 'sha256:' ||\n      encode(sha256(convert_to(history.payload::text, 'UTF8')), 'hex')\n  ) AS storage_digest_valid,\n  current_entity.id AS current_entity_id,\n  current_entity.entity_type AS current_entity_type,\n  current_entity.payload AS current_payload,\n  current_entity.project_id AS current_project_id,\n  current_entity.role_min AS current_role_min,\n  current_entity.sensitivity AS current_sensitivity,\n  current_entity.lifecycle_status AS current_lifecycle_status,\n  projects.code AS current_project_code,\n  true AS current_visible\nFROM public.graph_entities AS current_entity\nLEFT JOIN public.projects AS projects\n  ON projects.id = current_entity.project_id\nLEFT JOIN LATERAL (\n  SELECT history.*\n  FROM public.graph_foundation_revisions AS history\n  WHERE history.entity_id = current_entity.id\n    AND history.entity_type = current_entity.entity_type\n  ORDER BY history.revision::numeric DESC\n  LIMIT 1\n) AS history ON true\nWHERE current_entity.id = $1\n  AND current_entity.entity_type = $2\nORDER BY history.revision::numeric DESC NULLS LAST\nLIMIT 1\n";
+/**
+ * List the newest revision of each Foundation entity visible in the selected
+ * project.  The project filter is by canonical project code, which is the
+ * scope identifier selected by the organization BFF.
+ */
+export declare const GRAPH_FOUNDATION_LIST_SQL = "\nSELECT\n  history.entity_id,\n  history.entity_type,\n  history.revision,\n  history.payload,\n  history.project_id,\n  history.role_min,\n  history.sensitivity,\n  history.lifecycle_status,\n  history.storage_digest,\n  history.captured_at,\n  (\n    history.storage_digest = 'sha256:' ||\n      encode(sha256(convert_to(history.payload::text, 'UTF8')), 'hex')\n  ) AS storage_digest_valid,\n  current_entity.id AS current_entity_id,\n  current_entity.entity_type AS current_entity_type,\n  current_entity.payload AS current_payload,\n  current_entity.project_id AS current_project_id,\n  current_entity.role_min AS current_role_min,\n  current_entity.sensitivity AS current_sensitivity,\n  current_entity.lifecycle_status AS current_lifecycle_status,\n  projects.code AS current_project_code,\n  true AS current_visible\nFROM public.graph_entities AS current_entity\nLEFT JOIN public.projects AS projects\n  ON projects.id = current_entity.project_id\nLEFT JOIN LATERAL (\n  SELECT history.*\n  FROM public.graph_foundation_revisions AS history\n  WHERE history.entity_id = current_entity.id\n    AND history.entity_type = current_entity.entity_type\n  ORDER BY history.revision::numeric DESC\n  LIMIT 1\n) AS history ON true\nWHERE ($1::text IS NULL OR current_entity.entity_type = $1)\n  AND ($2::text IS NULL OR projects.code = $2 OR projects.id IS NULL)\n  AND current_entity.entity_type IN ('objective', 'variable', 'model', 'constraint')\nORDER BY current_entity.id, current_entity.entity_type\n";
 /** Flat row shape returned by GRAPH_FOUNDATION_READ_SQL. */
 export interface GraphFoundationHistoryRow {
     readonly entity_id?: unknown;
@@ -46,9 +58,11 @@ export interface GraphFoundationReaderOptions {
     readonly context: FoundationStoreContext;
     /** Query callback bound to the host's already-authenticated transaction. */
     readonly query: GraphFoundationQuery;
+    /** Canonical project code selected by the organization boundary. */
+    readonly selectedProjectCode?: string;
 }
 export interface GraphFoundationReaders {
-    readonly store: Pick<FoundationRevisionStore, 'read'>;
+    readonly store: Pick<FoundationRevisionStore, 'read' | 'readLatest' | 'list'>;
     readonly philosophyReader: PhilosophyRevisionReader;
 }
 /**

package/dist/graph-foundation-reader.js

@@ -50,6 +50,98 @@ WHERE history.entity_id = $1
   AND history.entity_type = $2
   AND history.revision = $3
 `;
+/**
+ * Read the newest immutable revision for one Foundation entity.  The current
+ * Graph row remains part of the query so RLS and the adapter's current-row
+ * checks apply identically to latest and historical reads.
+ */
+export const GRAPH_FOUNDATION_LATEST_SQL = `
+SELECT
+  history.entity_id,
+  history.entity_type,
+  history.revision,
+  history.payload,
+  history.project_id,
+  history.role_min,
+  history.sensitivity,
+  history.lifecycle_status,
+  history.storage_digest,
+  history.captured_at,
+  (
+    history.storage_digest = 'sha256:' ||
+      encode(sha256(convert_to(history.payload::text, 'UTF8')), 'hex')
+  ) AS storage_digest_valid,
+  current_entity.id AS current_entity_id,
+  current_entity.entity_type AS current_entity_type,
+  current_entity.payload AS current_payload,
+  current_entity.project_id AS current_project_id,
+  current_entity.role_min AS current_role_min,
+  current_entity.sensitivity AS current_sensitivity,
+  current_entity.lifecycle_status AS current_lifecycle_status,
+  projects.code AS current_project_code,
+  true AS current_visible
+FROM public.graph_entities AS current_entity
+LEFT JOIN public.projects AS projects
+  ON projects.id = current_entity.project_id
+LEFT JOIN LATERAL (
+  SELECT history.*
+  FROM public.graph_foundation_revisions AS history
+  WHERE history.entity_id = current_entity.id
+    AND history.entity_type = current_entity.entity_type
+  ORDER BY history.revision::numeric DESC
+  LIMIT 1
+) AS history ON true
+WHERE current_entity.id = $1
+  AND current_entity.entity_type = $2
+ORDER BY history.revision::numeric DESC NULLS LAST
+LIMIT 1
+`;
+/**
+ * List the newest revision of each Foundation entity visible in the selected
+ * project.  The project filter is by canonical project code, which is the
+ * scope identifier selected by the organization BFF.
+ */
+export const GRAPH_FOUNDATION_LIST_SQL = `
+SELECT
+  history.entity_id,
+  history.entity_type,
+  history.revision,
+  history.payload,
+  history.project_id,
+  history.role_min,
+  history.sensitivity,
+  history.lifecycle_status,
+  history.storage_digest,
+  history.captured_at,
+  (
+    history.storage_digest = 'sha256:' ||
+      encode(sha256(convert_to(history.payload::text, 'UTF8')), 'hex')
+  ) AS storage_digest_valid,
+  current_entity.id AS current_entity_id,
+  current_entity.entity_type AS current_entity_type,
+  current_entity.payload AS current_payload,
+  current_entity.project_id AS current_project_id,
+  current_entity.role_min AS current_role_min,
+  current_entity.sensitivity AS current_sensitivity,
+  current_entity.lifecycle_status AS current_lifecycle_status,
+  projects.code AS current_project_code,
+  true AS current_visible
+FROM public.graph_entities AS current_entity
+LEFT JOIN public.projects AS projects
+  ON projects.id = current_entity.project_id
+LEFT JOIN LATERAL (
+  SELECT history.*
+  FROM public.graph_foundation_revisions AS history
+  WHERE history.entity_id = current_entity.id
+    AND history.entity_type = current_entity.entity_type
+  ORDER BY history.revision::numeric DESC
+  LIMIT 1
+) AS history ON true
+WHERE ($1::text IS NULL OR current_entity.entity_type = $1)
+  AND ($2::text IS NULL OR projects.code = $2 OR projects.id IS NULL)
+  AND current_entity.entity_type IN ('objective', 'variable', 'model', 'constraint')
+ORDER BY current_entity.id, current_entity.entity_type
+`;
 const FOUNDATION_TYPES = ['objective', 'variable', 'model', 'constraint'];
 const REVISION_PATTERN = /^[1-9]\d*$/u;
 const DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/u;
@@ -65,6 +157,7 @@ export function createGraphFoundationReaders(options) {
     assertReaderOptions(options);
     const context = cloneContext(options.context);
     const query = options.query;
+    const selectedProjectCode = options.selectedProjectCode;
     const store = {
         async read(reference, suppliedContext) {
             assertTrustedPrincipal(context, suppliedContext);
@@ -75,20 +168,42 @@ export function createGraphFoundationReaders(options) {
             if (rows.length !== 1) {
                 throw corrupt('Graph foundation history returned multiple rows for one revision');
             }
+            return validateFoundationRecord(rows[0], reference, context, selectedProjectCode);
+        },
+        async readLatest(type, id, suppliedContext) {
+            assertTrustedPrincipal(context, suppliedContext);
+            assertFoundationType(type);
+            assertEntityId(id);
+            const rows = await executeLatestRead(query, id, type);
+            if (rows.length === 0)
+                return null;
+            if (rows.length !== 1) {
+                throw corrupt('Graph foundation latest query returned multiple rows');
+            }
             const row = rows[0];
-            const history = validateHistoryRow(row, reference.id, reference.type, reference.revision);
-            const current = validateCurrentRow(row, reference.id, reference.type);
-            authorizeCurrentFoundation(current, context);
-            // A history row remains readable only through the current Graph row,
-            // including its current project and current scope.  The old payload is
-            // returned unchanged after these current-row checks.
-            if (history.projectId !== current.projectId) {
-                throw scopeViolation('Historical foundation project differs from current Graph project');
+            const reference = rowReference(row);
+            if (reference.id !== id || reference.type !== type) {
+                throw corrupt('Graph foundation latest row identity does not match the request');
             }
-            return {
-                definition: cloneFoundationDefinition(history.definition),
-                digest: digestFoundationDefinition(history.definition)
-            };
+            return validateFoundationRecord(row, reference, context, selectedProjectCode, true);
+        },
+        async list(type, suppliedContext) {
+            assertTrustedPrincipal(context, suppliedContext);
+            if (type !== undefined)
+                assertFoundationType(type);
+            const rows = await executeList(query, type, selectedProjectCode);
+            const seen = new Set();
+            return rows.map((row) => {
+                const reference = rowReference(row);
+                if (type !== undefined && reference.type !== type) {
+                    throw corrupt('Graph foundation list returned an unexpected entity type');
+                }
+                const key = `${reference.type}:${reference.id}`;
+                if (seen.has(key))
+                    throw corrupt('Graph foundation list returned duplicate entity rows');
+                seen.add(key);
+                return validateFoundationRecord(row, reference, context, selectedProjectCode, true);
+            });
         }
     };
     const philosophyReader = {
@@ -254,6 +369,66 @@ async function executeRead(query, id, type, revision) {
     }
     throw corrupt('Graph foundation history query returned an invalid result');
 }
+async function executeLatestRead(query, id, type) {
+    let result;
+    try {
+        result = await query(GRAPH_FOUNDATION_LATEST_SQL, [id, type]);
+    }
+    catch {
+        throw corrupt('Graph foundation latest query failed');
+    }
+    if (Array.isArray(result))
+        return result;
+    if (!Array.isArray(result) && 'rows' in result && Array.isArray(result.rows)) {
+        return result.rows;
+    }
+    throw corrupt('Graph foundation latest query returned an invalid result');
+}
+async function executeList(query, type, selectedProjectCode) {
+    let result;
+    try {
+        result = await query(GRAPH_FOUNDATION_LIST_SQL, [type ?? null, selectedProjectCode ?? null]);
+    }
+    catch {
+        throw corrupt('Graph foundation list query failed');
+    }
+    if (Array.isArray(result))
+        return result;
+    if (!Array.isArray(result) && 'rows' in result && Array.isArray(result.rows)) {
+        return result.rows;
+    }
+    throw corrupt('Graph foundation list query returned an invalid result');
+}
+function validateFoundationRecord(row, reference, context, selectedProjectCode, requireCurrentRevision = false) {
+    const history = validateHistoryRow(row, reference.id, reference.type, reference.revision);
+    const current = validateCurrentRow(row, reference.id, reference.type);
+    if (requireCurrentRevision && current.projectCode === undefined) {
+        throw corrupt('Current Graph project code is missing');
+    }
+    authorizeCurrentFoundation(current, context, selectedProjectCode);
+    // Latest reads must prove that the current Graph payload points at the
+    // revision returned by the history query. Otherwise a missing newer history
+    // row could silently fall back to an older immutable revision.
+    if (requireCurrentRevision && current.foundation?.revision !== reference.revision) {
+        throw corrupt('Current Graph foundation revision does not match the latest history revision');
+    }
+    // A history row remains readable only through the current Graph row,
+    // including its current project and current scope. The old payload is
+    // returned unchanged after these current-row checks.
+    if (history.projectId !== current.projectId) {
+        throw scopeViolation('Historical foundation project differs from current Graph project');
+    }
+    return {
+        definition: cloneFoundationDefinition(history.definition),
+        digest: digestFoundationDefinition(history.definition)
+    };
+}
+function rowReference(row) {
+    const id = requireString(row.entity_id, 'Foundation history entity_id');
+    const type = parseFoundationType(row.entity_type);
+    const revision = requireRevision(row.revision, 'Foundation history revision');
+    return { id, type, revision };
+}
 function validateHistoryRow(row, id, type, revision) {
     assertRowIdentity(row, id, type, revision);
     assertStorageDigest(row);
@@ -301,21 +476,27 @@ function validateCurrentRow(row, id, type) {
         throw new FoundationStoreError('authorization_denied', 'The current Graph row is not active');
     }
     const projectId = requireString(row.current_project_id, 'Current Graph project_id');
+    const projectCode = typeof row.current_project_code === 'string' && row.current_project_code.length > 0
+        ? row.current_project_code
+        : undefined;
     const payload = requireObject(row.current_payload, 'Current Graph payload');
     if (type === 'philosophy') {
         const applicability = parseJudgmentApplicability(payload);
-        return { payload, projectId, philosophy: { applicability } };
+        return { payload, projectId, projectCode, philosophy: { applicability } };
     }
     const definition = requireObject(payload.foundation, 'Current Graph payload.foundation');
     const result = validateFoundationDefinition(definition, { use: 'draft' });
     if (!result.valid || definition.id !== id || definition.type !== type) {
         throw corrupt('Current Graph foundation definition is invalid');
     }
-    return { payload, projectId, foundation: definition };
+    return { payload, projectId, projectCode, foundation: definition };
 }
-function authorizeCurrentFoundation(current, context) {
+function authorizeCurrentFoundation(current, context, selectedProjectCode) {
     if (!current.foundation)
         throw corrupt('Current Graph foundation definition is missing');
+    if (selectedProjectCode !== undefined && current.projectCode !== selectedProjectCode) {
+        throw scopeViolation('The current Graph project is outside the selected project scope');
+    }
     const definition = current.foundation;
     if (!canRead(definition.acl, context.principal)) {
         throw new FoundationStoreError('authorization_denied', 'The current foundation ACL does not permit this principal');
@@ -334,6 +515,28 @@ function assertRowIdentity(row, id, type, revision) {
         throw corrupt('Foundation history identity does not match the requested revision');
     }
 }
+function parseFoundationType(value) {
+    if (typeof value === 'string' && FOUNDATION_TYPES.includes(value)) {
+        return value;
+    }
+    throw corrupt('Foundation history entity_type is invalid');
+}
+function requireRevision(value, label) {
+    if (typeof value !== 'string' || !REVISION_PATTERN.test(value)) {
+        throw corrupt(`${label} must be a positive revision`);
+    }
+    return value;
+}
+function assertEntityId(value) {
+    if (typeof value !== 'string' || value.trim().length === 0 || value.includes('\0')) {
+        throw new FoundationStoreError('invalid_input', 'A foundation entity id is required');
+    }
+}
+function assertFoundationType(value) {
+    if (!FOUNDATION_TYPES.includes(value)) {
+        throw new FoundationStoreError('invalid_input', 'A supported foundation type is required');
+    }
+}
 function assertFoundationReference(reference) {
     if (!isPlainRecord(reference) || typeof reference.id !== 'string' || reference.id.length === 0 ||
         !FOUNDATION_TYPES.includes(reference.type) ||
@@ -365,6 +568,10 @@ function assertReaderOptions(options) {
         if (!isValidFoundationScope(scope))
             throw new TypeError('A trusted Graph foundation scope is invalid');
     }
+    if (options.selectedProjectCode !== undefined
+        && (typeof options.selectedProjectCode !== 'string' || options.selectedProjectCode.trim().length === 0)) {
+        throw new TypeError('A selected Graph project code is invalid');
+    }
 }
 function assertTrustedPrincipal(trusted, supplied) {
     if (!supplied || supplied.principal !== trusted.principal) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.10.4",
+  "version": "0.10.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",
@@ -336,5 +336,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "84863f09b8274b738b16e15d2550ece19ac51124"
+  "gitHead": "8cfad04bef7bf934165d96b979e9e5d52dd837dc"
 }