@unson/brainbase-mcp 0.27.0 → 0.28.0

package/dist/knowledge-resolution-service.d.ts

@@ -0,0 +1,42 @@
+export type KnowledgeAudience = 'personal' | 'team' | 'organization';
+export type KnowledgeContentType = 'canonical_fact' | 'team_document' | 'source_document' | 'personal_knowledge' | 'operational_state' | 'unknown';
+export type KnowledgeSourceClass = 'graph' | 'owning_repo' | 'team_drive' | 'personal_kg' | 'workspace_home';
+type ExcludableSourceClass = KnowledgeSourceClass | 'wiki';
+export interface KnowledgeResolutionInput {
+    intent?: unknown;
+    audience?: unknown;
+    content_type?: unknown;
+    project_code?: string | null;
+    [key: string]: unknown;
+}
+export interface KnowledgeResolutionReceipt {
+    resolution_id: string;
+    resolved_at: string;
+    project_code: string | null;
+    content_type: KnowledgeContentType;
+    searched_scope: string[];
+    absence_confirmed: false;
+    status: 'resolved' | 'unconfirmed';
+    source_class: KnowledgeSourceClass | null;
+    canonical_location: Record<string, unknown> | null;
+    retrieval_capability: string | null;
+    excluded_sources: Array<{
+        source_class: ExcludableSourceClass;
+        reason: string;
+    }>;
+    not_searched: KnowledgeSourceClass[];
+    next_route: KnowledgeSourceClass;
+    confidence: number;
+    rationale: string;
+}
+export interface KnowledgeResolutionServiceOptions {
+    now?: () => Date;
+    id?: () => string;
+}
+export declare class KnowledgeResolutionService {
+    readonly now: () => Date;
+    readonly id: () => string;
+    constructor({ now, id }?: KnowledgeResolutionServiceOptions);
+    resolve(rawInput?: KnowledgeResolutionInput): KnowledgeResolutionReceipt;
+}
+export {};

package/dist/knowledge-resolution-service.js

@@ -0,0 +1,116 @@
+/**
+ * Decides which canonical source a piece of knowledge should be searched in
+ * (Graph, owning repository, team Drive, personal KG, or the workspace) from
+ * its content type and audience, and returns a routing receipt. A receipt only
+ * says where to search; it never records a search or proves absence.
+ *
+ * Moved unchanged from brainbase-unson server/services/knowledge-resolution-service.js
+ * (story-knowledge-resolution-service-exit-v1).
+ */
+import { randomUUID } from 'node:crypto';
+const AUDIENCES = new Set(['personal', 'team', 'organization']);
+const CONTENT_TYPES = new Set(['canonical_fact', 'team_document', 'source_document', 'personal_knowledge', 'operational_state', 'unknown']);
+const ALLOWED_AUDIENCES = {
+    canonical_fact: new Set(['team', 'organization']),
+    team_document: new Set(['team', 'organization']),
+    source_document: new Set(['team', 'organization']),
+    personal_knowledge: new Set(['personal']),
+    operational_state: new Set(['personal', 'team', 'organization']),
+    unknown: AUDIENCES,
+};
+const ROUTES = {
+    canonical_fact: { source_class: 'graph', retrieval_capability: 'graph.search' },
+    team_document: { source_class: 'owning_repo', retrieval_capability: 'repository.read' },
+    source_document: { source_class: 'team_drive', retrieval_capability: 'drive.read' },
+    personal_knowledge: { source_class: 'personal_kg', retrieval_capability: 'personal_kg.search' },
+    operational_state: { source_class: 'workspace_home', retrieval_capability: 'workspace.inspect' },
+};
+function requiredString(value, name) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new TypeError(`${name} is required`);
+    return value.trim();
+}
+function routeOrder(input) {
+    if (input.audience === 'personal')
+        return ['personal_kg', 'owning_repo', 'graph', 'team_drive'];
+    if (input.project_code)
+        return ['owning_repo', 'graph', 'team_drive'];
+    return ['graph', 'owning_repo', 'team_drive'];
+}
+function excludedSources(selected, audience) {
+    const reasons = {
+        wiki: 'Wiki is a migration compatibility surface, not a canonical destination.',
+        graph: 'Graph stores canonical entities, terms, and decisions rather than document bodies.',
+        owning_repo: 'Repository stores reviewed team documents, not raw source assets.',
+        team_drive: 'Drive stores source files and large assets, not reviewed team knowledge.',
+        personal_kg: audience === 'personal'
+            ? 'Personal KG is only selected for personal cognitive knowledge.'
+            : 'Personal KG is owner-only and cannot be the source of team knowledge.',
+        workspace_home: 'Workspace home is for runtime state, not durable knowledge.',
+    };
+    return Object.entries(reasons)
+        .filter(([source]) => source !== selected)
+        .map(([source_class, reason]) => ({ source_class, reason }));
+}
+function canonicalLocation(route, input) {
+    if (route.source_class === 'owning_repo') {
+        return {
+            repository: input.project_code ? `project:${input.project_code}` : null,
+            path: 'docs/',
+        };
+    }
+    if (route.source_class === 'graph')
+        return { scope: input.project_code || 'organization', entity_types: ['person', 'organization', 'project', 'term', 'decision'] };
+    if (route.source_class === 'team_drive')
+        return { drive_scope: input.project_code || 'organization', file_id: null };
+    if (route.source_class === 'personal_kg')
+        return { owner_scope: 'authenticated_owner' };
+    return { workspace_scope: input.project_code || 'current_project' };
+}
+export class KnowledgeResolutionService {
+    now;
+    id;
+    constructor({ now = () => new Date(), id = () => `kr_${randomUUID()}` } = {}) {
+        this.now = now;
+        this.id = id;
+    }
+    resolve(rawInput = {}) {
+        const input = {
+            ...rawInput,
+            intent: requiredString(rawInput.intent, 'intent'),
+            audience: requiredString(rawInput.audience, 'audience'),
+            content_type: requiredString(rawInput.content_type, 'content_type'),
+        };
+        if (!AUDIENCES.has(input.audience))
+            throw new TypeError(`audience must be one of: ${[...AUDIENCES].join(', ')}`);
+        if (!CONTENT_TYPES.has(input.content_type))
+            throw new TypeError(`content_type must be one of: ${[...CONTENT_TYPES].join(', ')}`);
+        const validated = input;
+        if (!ALLOWED_AUDIENCES[validated.content_type].has(validated.audience)) {
+            throw new TypeError(`content_type=${validated.content_type} is not valid for audience=${validated.audience}`);
+        }
+        const base = {
+            resolution_id: this.id(), resolved_at: this.now().toISOString(),
+            project_code: validated.project_code || null, content_type: validated.content_type,
+            searched_scope: [], absence_confirmed: false,
+        };
+        const route = ROUTES[validated.content_type];
+        if (!route) {
+            const candidates = routeOrder(validated);
+            return {
+                ...base, status: 'unconfirmed', source_class: null, canonical_location: null,
+                retrieval_capability: null, excluded_sources: excludedSources(null, validated.audience),
+                not_searched: candidates, next_route: candidates[0], confidence: 0,
+                rationale: 'The structured content type is unknown; no source was searched and absence is not confirmed.',
+            };
+        }
+        return {
+            ...base, status: 'resolved', source_class: route.source_class,
+            canonical_location: canonicalLocation(route, validated),
+            retrieval_capability: route.retrieval_capability,
+            excluded_sources: excludedSources(route.source_class, validated.audience),
+            not_searched: [], next_route: route.source_class, confidence: 0.95,
+            rationale: `content_type=${validated.content_type} deterministically maps to ${route.source_class}.`,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.27.0",
+  "version": "0.28.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",
@@ -179,6 +179,10 @@
       "types": "./dist/decision-adapter.d.ts",
       "import": "./dist/decision-adapter.js"
     },
+    "./knowledge-resolution-service": {
+      "types": "./dist/knowledge-resolution-service.d.ts",
+      "import": "./dist/knowledge-resolution-service.js"
+    },
     "./knowledge-adapter": {
       "types": "./dist/knowledge-adapter.d.ts",
       "import": "./dist/knowledge-adapter.js"
@@ -435,5 +439,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "bb3b1bde373d9cc1c12cac01b1b52528d162db85"
+  "gitHead": "b8d86d3e394b94cd77bcfe71e8cb6c8703abce4b"
 }

package/ui/brainbase-tokens.css

@@ -1,10 +1,13 @@
 /*
- * Brainbase shared visual tokens (color, type, radius, spacing, rail).
- * Common UI parts and hosts read only these names so that the personal and
- * organization editions look the same. The values are the organization
- * edition's design (brainbase-organization apps/web/public/styles.css, final
- * :root layer and the outcome workspace rules), which is the visual source of
- * truth for every Brainbase Web surface.
+ * Brainbase shared UI-token contract (color, type, radius, spacing, rail).
+ * Common OSS UI parts and compatible hosts read these token names. The values
+ * below remain this repository's current token defaults; they are not the
+ * Brainbase brand palette and do not require every host to adopt one theme.
+ * For the organization Web app, the effective visual source is
+ * brainbase-organization/apps/web/public/styles.css (final :root layer and
+ * outcome workspace overrides). The brand palette is documented separately
+ * in brainbase-organization/docs/design/brainbase-brand-palette.md.
+ * This boundary clarification intentionally does not change any token value.
  */
 :root {
   --bb-color-ink: #202124;