@unson/brainbase-mcp 0.37.0 → 0.39.0

package/dist/graph-corrections.d.ts

@@ -14,12 +14,16 @@ export declare const GRAPH_CORRECTION_ENTITY_FIELDS: readonly ["name", "aliases"
 export declare const GRAPH_CORRECTION_PROJECT_FIELDS: readonly ["goal", "status", "icon"];
 export declare const GRAPH_CORRECTION_EDGE_FIELDS: readonly ["role", "context", "validTo"];
 export declare const GRAPH_CORRECTION_NEW_EDGE_RELATIONS: readonly ["participates_in", "accountable_for", "member_of"];
+/** Kinds a correction may create (people and companies only). */
+export declare const GRAPH_CORRECTION_NEW_ENTITY_TYPES: readonly ["person", "org"];
+export declare const GRAPH_CORRECTION_NEW_ENTITY_FIELDS: readonly ["type", "name", "aliases", "summary", "validFrom"];
 /** MCP tools that read the same graph.json on every call and therefore see a saved correction next time. */
 export declare const GRAPH_CORRECTION_APPLIES_TO: readonly ["search", "get_context", "resolve_entity"];
 /** Decoded bytes, shared with the browser-side project-icon helper. */
 export declare const PROJECT_ICON_MAX_BYTES: number;
-export type GraphCorrectionKind = 'update_entity' | 'update_edge' | 'create_edge';
+export type GraphCorrectionKind = 'update_entity' | 'update_edge' | 'create_edge' | 'create_entity';
 export type GraphNewEdgeRelation = typeof GRAPH_CORRECTION_NEW_EDGE_RELATIONS[number];
+export type GraphNewEntityType = typeof GRAPH_CORRECTION_NEW_ENTITY_TYPES[number];
 export interface GraphEntityCorrectionChanges {
     name?: string;
     aliases?: string[];
@@ -47,6 +51,13 @@ export interface GraphEdgeCreation {
     context?: string;
     validFrom?: string;
 }
+export interface GraphEntityCreation {
+    type: GraphNewEntityType;
+    name: string;
+    aliases?: string[];
+    summary?: string;
+    validFrom?: string;
+}
 export type GraphCorrectionInput = {
     kind: 'update_entity';
     entityId: string;
@@ -63,6 +74,10 @@ export type GraphCorrectionInput = {
     kind: 'create_edge';
     reason: string;
     edge: GraphEdgeCreation;
+} | {
+    kind: 'create_entity';
+    reason: string;
+    entity: GraphEntityCreation;
 };
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;

package/dist/graph-corrections.js

@@ -21,6 +21,9 @@ export const GRAPH_CORRECTION_ENTITY_FIELDS = ['name', 'aliases', 'summary', 'va
 export const GRAPH_CORRECTION_PROJECT_FIELDS = ['goal', 'status', 'icon'];
 export const GRAPH_CORRECTION_EDGE_FIELDS = ['role', 'context', 'validTo'];
 export const GRAPH_CORRECTION_NEW_EDGE_RELATIONS = ['participates_in', 'accountable_for', 'member_of'];
+/** Kinds a correction may create (people and companies only). */
+export const GRAPH_CORRECTION_NEW_ENTITY_TYPES = ['person', 'org'];
+export const GRAPH_CORRECTION_NEW_ENTITY_FIELDS = ['type', 'name', 'aliases', 'summary', 'validFrom'];
 /** MCP tools that read the same graph.json on every call and therefore see a saved correction next time. */
 export const GRAPH_CORRECTION_APPLIES_TO = ['search', 'get_context', 'resolve_entity'];
 const MAX_REASON_LENGTH = 500;
@@ -83,7 +86,11 @@ export function parseGraphCorrectionInput(value) {
         assertOnlyKeys(value, ['kind', 'reason', 'edge'], '');
         return { kind, reason: requireReason(value.reason), edge: parseEdgeCreation(value.edge) };
     }
-    invalid('correction_kind_unsupported', 'kind must be update_entity, update_edge or create_edge');
+    if (kind === 'create_entity') {
+        assertOnlyKeys(value, ['kind', 'reason', 'entity'], '');
+        return { kind, reason: requireReason(value.reason), entity: parseEntityCreation(value.entity) };
+    }
+    invalid('correction_kind_unsupported', 'kind must be update_entity, update_edge, create_edge or create_entity');
 }
 /**
  * Applies one owner correction to the canonical Graph v2 in `dataDir`.
@@ -190,7 +197,7 @@ function isGraphCorrectionRecord(value) {
     const target = value.target;
     return typeof value.id === 'string'
         && typeof value.at === 'string'
-        && (value.kind === 'update_entity' || value.kind === 'update_edge' || value.kind === 'create_edge')
+        && (value.kind === 'update_entity' || value.kind === 'update_edge' || value.kind === 'create_edge' || value.kind === 'create_entity')
         && isRecord(target) && (target.recordType === 'entity' || target.recordType === 'edge') && typeof target.id === 'string'
         && typeof value.reason === 'string'
         && Array.isArray(value.changedFields) && value.changedFields.every((field) => typeof field === 'string')
@@ -204,8 +211,51 @@ function planCorrection(graph, relationships, correction, at) {
         return planEntityUpdate(graph, relationships, correction, at);
     if (correction.kind === 'update_edge')
         return planEdgeUpdate(graph, relationships, correction, at);
+    if (correction.kind === 'create_entity')
+        return planEntityCreation(graph, relationships, correction, at);
     return planEdgeCreation(graph, relationships, correction, at);
 }
+/**
+ * Creates a person or a company.  A record of the same kind whose name or
+ * alias already reads the same (ignoring spacing, case and full/half width) is
+ * returned as a conflict instead of creating a duplicate.  The new record
+ * keeps where it came from (`metadata.source`, `metadata.sourceId`).
+ */
+function planEntityCreation(graph, relationships, correction, at) {
+    const input = correction.entity;
+    const names = new Set([input.name, ...(input.aliases ?? [])].map(comparableName));
+    const existing = graph.entities.find((entity) => entity.type === input.type
+        && [entity.name, ...(entity.aliases ?? [])].some((label) => names.has(comparableName(label))));
+    if (existing) {
+        throw new GraphCorrectionError('conflict', 'entity_already_exists', 'A record with the same name already exists; open it (and clear validTo if it has ended) instead of creating another', { recordType: 'entity', record: existing, digest: graphRecordDigest(existing) });
+    }
+    const base = `${input.type}-${stableHash(input.name)}`;
+    const correctionId = graphCorrectionId(at, 'create_entity', base, null, correction.reason);
+    const id = graph.entities.some((entity) => entity.id === base) ? `${base}-${correctionId.slice(-8)}` : base;
+    if (graph.entities.some((entity) => entity.id === id)) {
+        invalid('entity_id_ambiguous', `Entity id ${id} is already used; repair graph.json with the CLI first`);
+    }
+    const entity = compact({
+        id,
+        type: input.type,
+        name: input.name,
+        aliases: input.aliases && input.aliases.length > 0 ? input.aliases : undefined,
+        summary: input.summary,
+        validFrom: input.validFrom,
+        metadata: { source: 'user_approved', sourceId: correctionId }
+    });
+    const nextGraph = validatedGraph({ ...graph, entities: [...graph.entities, entity] });
+    const diff = {};
+    for (const [key, value] of Object.entries(entity)) {
+        if (key === 'id')
+            continue;
+        diff[key] = { before: null, after: value };
+    }
+    return finalize('create_entity', 'entity', null, entity, diff, correction.reason, at, nextGraph, { relationships, changes: [] }, correctionId);
+}
+function comparableName(value) {
+    return value.normalize('NFKC').replace(/\s+/gu, '').toLowerCase();
+}
 function planEntityUpdate(graph, relationships, correction, at) {
     const matches = graph.entities.filter((entity) => entity.id === correction.entityId);
     if (matches.length === 0)
@@ -539,6 +589,35 @@ function parseEdgeCreation(value) {
         validFrom: validFrom ?? undefined
     });
 }
+function parseEntityCreation(value) {
+    if (!isRecord(value))
+        invalid('correction_invalid', 'entity must be an object');
+    const type = value.type;
+    if (typeof type !== 'string' || !GRAPH_CORRECTION_NEW_ENTITY_TYPES.includes(type)) {
+        invalid('correction_entity_type_not_allowed', `entity.type must be one of ${GRAPH_CORRECTION_NEW_ENTITY_TYPES.join(', ')}`);
+    }
+    const allowed = GRAPH_CORRECTION_NEW_ENTITY_FIELDS.filter((key) => key !== 'type');
+    for (const key of Object.keys(value)) {
+        if (key === 'type' || allowed.includes(key))
+            continue;
+        if (key === 'id')
+            invalid('correction_id_change_not_allowed', 'entity.id is assigned by Brainbase');
+        invalid('correction_field_not_allowed', `entity.${key} cannot be set when creating a record`);
+    }
+    const name = value.name === undefined ? null : optionalText(value.name, 'entity.name', MAX_NAME_LENGTH);
+    if (name === null)
+        invalid('correction_name_required', 'entity.name must be a non-empty string');
+    const aliases = value.aliases === undefined ? [] : parseAliases(value.aliases).filter((alias) => alias !== name);
+    const summary = value.summary === undefined ? null : optionalText(value.summary, 'entity.summary', MAX_TEXT_LENGTH);
+    const validFrom = value.validFrom === undefined ? null : optionalDateTime(value.validFrom, 'entity.validFrom');
+    return compact({
+        type: type,
+        name,
+        aliases: aliases.length > 0 ? aliases : undefined,
+        summary: summary ?? undefined,
+        validFrom: validFrom ?? undefined
+    });
+}
 function assertOnlyKeys(value, allowed, prefix) {
     for (const key of Object.keys(value)) {
         if (allowed.includes(key))

package/dist/graph-maintenance-engine.js

@@ -425,8 +425,20 @@ export function applyGraphOperations(snapshot, operations, { projectCode, humanG
                 && !externalIds.has(toEntity.id)
                 && toEntity.entity_type === 'app'
                 && toEntity.lifecycle_status === 'active';
-            if (!localFrom && !sameOrganizationToolAccountable)
+            // A person's membership of a company: both active, each either in this
+            // snapshot or a same-organization reference.  Cross-organization
+            // references are never a membership endpoint.
+            const membershipFrom = localFrom || externalFrom;
+            const sameOrganizationPersonMembership = operation.rel_type === 'member_of'
+                && membershipFrom?.entity_type === 'person'
+                && membershipFrom.lifecycle_status === 'active'
+                && (Boolean(localFrom) || (externalIds.has(membershipFrom.id) && membershipFrom.reference_scope === 'same_organization'))
+                && toEntity.entity_type === 'org'
+                && toEntity.lifecycle_status === 'active'
+                && (!externalIds.has(toEntity.id) || toEntity.reference_scope === 'same_organization');
+            if (!localFrom && !sameOrganizationToolAccountable && !sameOrganizationPersonMembership) {
                 throw new Error(`Unknown entity: ${operation.from_id}`);
+            }
             const fromEntity = (localFrom || externalFrom);
             // A project of this scope using a same-organization tool of another project.
             const sameOrganizationProjectUsesApp = operation.rel_type === 'uses_app'
@@ -455,7 +467,7 @@ export function applyGraphOperations(snapshot, operations, { projectCode, humanG
                 throw new Error('decision_id must match the Decision owner source');
             }
             if (fromEntity.project_code !== toEntity.project_code && !sameOrganizationAppOwner && !sameOrganizationDecisionOwner
-                && !sameOrganizationToolAccountable && !sameOrganizationProjectUsesApp) {
+                && !sameOrganizationToolAccountable && !sameOrganizationProjectUsesApp && !sameOrganizationPersonMembership) {
                 throw new Error('edge endpoint project scope mismatch');
             }
             if (!String(operation.rel_type || '').trim())
@@ -491,7 +503,12 @@ export function applyGraphOperations(snapshot, operations, { projectCode, humanG
                     id: operation.edge_id,
                     from_id: operation.from_id, to_id: operation.to_id, rel_type: operation.rel_type,
                     // The accountable person lives in another project; the edge belongs to the tool's project.
-                    project_code: sameOrganizationToolAccountable ? toEntity.project_code : fromEntity.project_code,
+                    // A membership belongs to the company's project when the company is
+                    // in this snapshot, else to the person's, else to the plan's.
+                    project_code: sameOrganizationToolAccountable ? toEntity.project_code
+                        : sameOrganizationPersonMembership
+                            ? (!externalIds.has(toEntity.id) ? toEntity.project_code : localFrom ? fromEntity.project_code : state.project_code)
+                            : fromEntity.project_code,
                     payload: operation.payload || {}, role_min: roleMin,
                     sensitivity, lifecycle_status: 'active', version: 1
                 });

package/dist/graph-revision-reader.js

@@ -13,6 +13,7 @@ const CORE_RELATIONS = [
     'participates_in',
     'accountable_for',
     'owned_by',
+    'related_to',
     'governs',
     'supersedes'
 ];

package/dist/graph-web-http.d.ts

@@ -16,7 +16,7 @@ export type GraphWebHttpHandler = (request: IncomingMessage, response: ServerRes
 /**
  * Node-style handler for the local Graph read and correction API:
  *
- * - `GET {base}/status`, `GET {base}/projects`, `GET {base}/projects/:id`
+ * - `GET {base}/status`, `GET {base}/projects`, `GET {base}/projects/:id`, `GET {base}/people-and-companies`
  * - `GET {base}/search?q=&type=&as_of=&limit=`, `GET {base}/entities/:id`, `GET {base}/ontology`
  * - `POST {base}/corrections`
  *

package/dist/graph-web-http.js

@@ -1,5 +1,5 @@
 import { applyGraphCorrection, GraphCorrectionError } from './graph-corrections.js';
-import { GraphWebError, listGraphProjects, readGraphEntity, readGraphOntology, readGraphProject, readGraphWebStatus, searchGraphEntities } from './graph-web.js';
+import { GraphWebError, listGraphProjects, readGraphEntity, readGraphOntology, readGraphPeopleAndCompanies, readGraphProject, readGraphWebStatus, searchGraphEntities } from './graph-web.js';
 export const GRAPH_WEB_HTTP_VERSION = 'graph-web-http.v1';
 const DEFAULT_BASE_PATH = '/api/graph';
 // A 256KiB decoded image becomes roughly 350KiB as base64 in JSON. Keep a
@@ -21,7 +21,7 @@ class HttpError extends Error {
 /**
  * Node-style handler for the local Graph read and correction API:
  *
- * - `GET {base}/status`, `GET {base}/projects`, `GET {base}/projects/:id`
+ * - `GET {base}/status`, `GET {base}/projects`, `GET {base}/projects/:id`, `GET {base}/people-and-companies`
  * - `GET {base}/search?q=&type=&as_of=&limit=`, `GET {base}/entities/:id`, `GET {base}/ontology`
  * - `POST {base}/corrections`
  *
@@ -74,6 +74,9 @@ export function createGraphWebHttpHandler(options) {
                 case 'project':
                     writeJson(response, 200, await readGraphProject(dataDir, route.id, readOptions));
                     break;
+                case 'people':
+                    writeJson(response, 200, await readGraphPeopleAndCompanies(dataDir, readOptions));
+                    break;
                 case 'search':
                     writeJson(response, 200, await searchGraphEntities(dataDir, {
                         q: queryValue(url, 'q'),
@@ -105,6 +108,8 @@ function matchRoute(pathname, basePath) {
         return { name: 'status' };
     if (rest === '/projects')
         return { name: 'projects' };
+    if (rest === '/people-and-companies')
+        return { name: 'people' };
     if (rest === '/search')
         return { name: 'search' };
     if (rest === '/ontology')

package/dist/graph-web.d.ts

@@ -320,6 +320,8 @@ export interface GraphOntologySummary<S extends GraphWebAnySource = GraphWebSour
         projectFields: readonly string[];
         edgeFields: readonly string[];
         newEdgeRelations: readonly string[];
+        /** Kinds a correction may create (`create_entity`). */
+        newEntityTypes: readonly string[];
     };
 }
 export type GraphWebErrorKind = 'invalid' | 'not_found' | 'unavailable';
@@ -335,6 +337,77 @@ export interface GraphWebReadOptions {
 }
 export declare function readGraphWebStatus(dataDir: string, options?: GraphWebReadOptions): Promise<GraphWebStatus | GraphWebUnavailable>;
 export declare function listGraphProjects(dataDir: string, options?: GraphWebReadOptions): Promise<GraphProjectList | GraphWebUnavailable>;
+export type GraphOwnCompanyReason = 'resolved' | 'owner_not_found' | 'owner_has_no_company' | 'owner_has_several_companies';
+export interface GraphPersonSummaryView extends GraphEntityView {
+    type: 'person';
+    /** The owner of this Graph (the person whose companies decide the own company). */
+    isOwner: boolean;
+    /** Active companies of the person (active member_of to an active org), by company name. */
+    companyIds: string[];
+    /** Distinct active projects with an active participates_in or accountable_for relation. */
+    projectCount: number;
+    accountableProjectCount: number;
+    /**
+     * The company text recorded on the person (`org`, or `organization` when
+     * `org` is absent), as written; null when none.  A note only: it never
+     * decides the companies, the own company or internal / external.
+     */
+    orgNote: string | null;
+}
+export type GraphCompanyKind = 'customer' | 'partner' | 'prospect';
+export type GraphCompanyKindSource = 'orgType' | 'lifecycle_stage' | 'related_to' | 'deals';
+export interface GraphCompanyDealView {
+    /** The deal name as recorded (`name` or `title`), or null when the record has none. */
+    name: string | null;
+    /** The deal stage as recorded (`stage` or `status`), or null. */
+    stage: string | null;
+}
+export interface GraphCompanySummaryView extends GraphEntityView {
+    type: 'org';
+    /** Active people with an active member_of to the company, by name. */
+    memberIds: string[];
+    /** Active projects with an active owned_by to the company, by name. */
+    projectIds: string[];
+    /** Active projects the company is involved in through an active related_to, by name, with the edge role. */
+    relatedProjects: Array<{
+        projectId: string;
+        role: string | null;
+    }>;
+    /** The recorded company attributes, as written; null when not recorded. */
+    orgType: string | null;
+    lifecycleStage: string | null;
+    /** Proposals in progress recorded on the company (`deals`). */
+    deals: GraphCompanyDealView[];
+    /**
+     * What kind of company this is for the owner, only from the records above
+     * (attributes, related_to roles and deals), with where each kind came from.
+     * Empty when nothing is recorded: the kind is never guessed.
+     */
+    kinds: Array<{
+        kind: GraphCompanyKind;
+        sources: GraphCompanyKindSource[];
+    }>;
+}
+export interface GraphPeopleAndCompanies<S extends GraphWebAnySource = GraphWebSource> {
+    status: 'ok';
+    source: S;
+    asOf: string;
+    /**
+     * The company the owner belongs to.  Null with the reason when the owner has
+     * no active company, several, or no record: the screen then does not tell
+     * internal from external people.  No internal / external mark is stored.
+     */
+    ownCompany: {
+        id: string | null;
+        reason: GraphOwnCompanyReason;
+        candidateIds: string[];
+    };
+    people: GraphPersonSummaryView[];
+    companies: GraphCompanySummaryView[];
+    /** True only when the readable Graph v2 holds no person and no company. */
+    absenceConfirmed: boolean;
+}
+export declare function readGraphPeopleAndCompanies(dataDir: string, options?: GraphWebReadOptions): Promise<GraphPeopleAndCompanies | GraphWebUnavailable>;
 export declare function readGraphProject(dataDir: string, projectId: string, options?: GraphWebReadOptions): Promise<GraphProjectDetail | GraphWebUnavailable>;
 export declare function searchGraphEntities(dataDir: string, input?: GraphEntitySearchInput): Promise<GraphEntitySearchResult | GraphWebUnavailable>;
 export declare function readGraphEntity(dataDir: string, entityId: string, options?: GraphWebReadOptions): Promise<GraphEntityDetail | GraphWebUnavailable>;

package/dist/graph-web.js

@@ -2,7 +2,7 @@ import { access, readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { isActiveAt } from './canonical-graph.js';
 import { assertFoundationCatalog, findFoundationRecord } from './foundation-catalog.js';
-import { GRAPH_CORRECTION_EDGE_FIELDS, GRAPH_CORRECTION_ENTITY_FIELDS, GRAPH_CORRECTION_NEW_EDGE_RELATIONS, GRAPH_CORRECTION_PROJECT_FIELDS, GRAPH_CORRECTIONS_FILE, graphRecordDigest, isProjectIconDataUrl, readGraphCorrectionHistory } from './graph-corrections.js';
+import { GRAPH_CORRECTION_EDGE_FIELDS, GRAPH_CORRECTION_ENTITY_FIELDS, GRAPH_CORRECTION_NEW_EDGE_RELATIONS, GRAPH_CORRECTION_NEW_ENTITY_TYPES, GRAPH_CORRECTION_PROJECT_FIELDS, GRAPH_CORRECTIONS_FILE, graphRecordDigest, isProjectIconDataUrl, readGraphCorrectionHistory } from './graph-corrections.js';
 import { ONTOLOGY_VERSION, portableOntology } from './ontology.js';
 import { canonicalRelationRegistry, getCanonicalRelation } from './relation-registry.js';
 import { loadPersonalOs } from './ssot.js';
@@ -93,6 +93,115 @@ function projectListOf(graph, source, asOf) {
     }).sort(byActiveThenName);
     return { status: 'ok', source, asOf, projects, absenceConfirmed: projects.length === 0 };
 }
+export async function readGraphPeopleAndCompanies(dataDir, options = {}) {
+    const loaded = await loadForRead(dataDir);
+    if ('status' in loaded)
+        return loaded;
+    return peopleAndCompaniesOf(loaded.graph, loaded.source, resolveAsOf(options));
+}
+function peopleAndCompaniesOf(graph, source, asOf) {
+    const entities = entityIndex(graph);
+    const name = (id) => entities.get(id)?.name ?? id;
+    const byName = (left, right) => name(left).localeCompare(name(right), 'ja') || left.localeCompare(right, 'en');
+    const live = graph.edges.filter((edge) => isActiveAt(edge, asOf)
+        && isEntityActive(entities.get(edge.fromId), asOf) && isEntityActive(entities.get(edge.toId), asOf));
+    const membership = live.filter((edge) => edge.relation === 'member_of' && entities.get(edge.toId)?.type === 'org');
+    const companiesOf = (personId) => [...new Set(membership.filter((edge) => edge.fromId === personId).map((edge) => edge.toId))].sort(byName);
+    const ownerId = graph.owner?.id ?? 'self';
+    const owner = entities.get(ownerId);
+    const ownCandidates = owner?.type === 'person' && isActiveAt(owner, asOf) ? companiesOf(ownerId) : [];
+    const ownCompany = owner?.type !== 'person' || !isActiveAt(owner, asOf)
+        ? { id: null, reason: 'owner_not_found', candidateIds: [] }
+        : ownCandidates.length === 1
+            ? { id: ownCandidates[0], reason: 'resolved', candidateIds: ownCandidates }
+            : { id: null, reason: ownCandidates.length === 0 ? 'owner_has_no_company' : 'owner_has_several_companies', candidateIds: ownCandidates };
+    const people = graph.entities.filter((entity) => entity.type === 'person').map((person) => {
+        const work = live.filter((edge) => edge.fromId === person.id && PARTICIPATION.has(edge.relation) && entities.get(edge.toId)?.type === 'project');
+        return {
+            ...entityView(person, asOf),
+            type: 'person',
+            isOwner: person.id === ownerId,
+            companyIds: companiesOf(person.id),
+            projectCount: new Set(work.map((edge) => edge.toId)).size,
+            accountableProjectCount: new Set(work.filter((edge) => edge.relation === 'accountable_for').map((edge) => edge.toId)).size,
+            orgNote: metadataString(person, 'org')?.trim() || metadataString(person, 'organization')?.trim() || null
+        };
+    }).sort((left, right) => Number(right.active) - Number(left.active) || Number(right.isOwner) - Number(left.isOwner) || byActiveThenName(left, right));
+    const companies = graph.entities.filter((entity) => entity.type === 'org').map((company) => {
+        const relatedProjects = live.filter((edge) => edge.relation === 'related_to' && edge.fromId === company.id
+            && entities.get(edge.toId)?.type === 'project')
+            .map((edge) => ({ projectId: edge.toId, role: edge.role?.trim() || null }))
+            .sort((left, right) => byName(left.projectId, right.projectId));
+        const orgType = metadataString(company, 'orgType')?.trim() || null;
+        const lifecycleStage = metadataString(company, 'lifecycle_stage')?.trim() || null;
+        const deals = companyDeals(company.metadata?.deals);
+        return {
+            ...entityView(company, asOf),
+            type: 'org',
+            memberIds: [...new Set(membership.filter((edge) => edge.toId === company.id).map((edge) => edge.fromId))]
+                .sort((left, right) => Number(left !== ownerId) - Number(right !== ownerId) || byName(left, right)),
+            projectIds: [...new Set(live.filter((edge) => edge.relation === 'owned_by' && edge.toId === company.id
+                    && entities.get(edge.fromId)?.type === 'project').map((edge) => edge.fromId))].sort(byName),
+            relatedProjects,
+            orgType,
+            lifecycleStage,
+            deals,
+            kinds: companyKinds({ orgType, lifecycleStage, roles: relatedProjects.map((item) => item.role), dealCount: deals.length })
+        };
+    }).sort((left, right) => Number(right.active) - Number(left.active)
+        || Number(right.id === ownCompany.id) - Number(left.id === ownCompany.id)
+        || Number(right.kinds.length > 0) - Number(left.kinds.length > 0)
+        || byActiveThenName(left, right));
+    return { status: 'ok', source, asOf, ownCompany, people, companies, absenceConfirmed: people.length === 0 && companies.length === 0 };
+}
+const COMPANY_KINDS = ['customer', 'partner', 'prospect'];
+const RELATION_KIND = Object.freeze({ customer: 'customer', partner: 'partner' });
+const STAGE_KIND = Object.freeze({ customer: 'customer', partner: 'partner', opportunity: 'prospect' });
+/**
+ * The kinds of a company, only from what is recorded: `orgType` and
+ * related_to roles of `customer` / `partner`, `lifecycle_stage` of
+ * `customer` / `partner` / `opportunity`, and any recorded deal (prospect).
+ * Other values give no kind; nothing is guessed from names.
+ */
+function companyKinds(input) {
+    const sources = new Map();
+    const add = (kind, source) => {
+        if (!kind)
+            return;
+        sources.set(kind, (sources.get(kind) ?? new Set()).add(source));
+    };
+    const lookup = (table, value) => {
+        const key = value?.toLowerCase();
+        return key && Object.hasOwn(table, key) ? table[key] : undefined;
+    };
+    add(lookup(RELATION_KIND, input.orgType), 'orgType');
+    add(lookup(STAGE_KIND, input.lifecycleStage), 'lifecycle_stage');
+    for (const role of input.roles)
+        add(lookup(RELATION_KIND, role), 'related_to');
+    if (input.dealCount > 0)
+        add('prospect', 'deals');
+    return COMPANY_KINDS.filter((kind) => sources.has(kind)).map((kind) => ({ kind, sources: [...sources.get(kind)] }));
+}
+function companyDeals(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((deal) => {
+        if (typeof deal === 'string')
+            return deal.trim() ? [{ name: deal.trim(), stage: null }] : [];
+        if (!deal || typeof deal !== 'object' || Array.isArray(deal))
+            return [];
+        const record = deal;
+        const text = (...keys) => {
+            for (const key of keys) {
+                const item = record[key];
+                if (typeof item === 'string' && item.trim())
+                    return item.trim();
+            }
+            return null;
+        };
+        return [{ name: text('name', 'title'), stage: text('stage', 'status') }];
+    });
+}
 export async function readGraphProject(dataDir, projectId, options = {}) {
     const loaded = await loadForRead(dataDir);
     if ('status' in loaded)
@@ -236,7 +345,8 @@ function ontologyOf(graph, source, asOf) {
             entityFields: GRAPH_CORRECTION_ENTITY_FIELDS,
             projectFields: GRAPH_CORRECTION_PROJECT_FIELDS,
             edgeFields: GRAPH_CORRECTION_EDGE_FIELDS,
-            newEdgeRelations: GRAPH_CORRECTION_NEW_EDGE_RELATIONS
+            newEdgeRelations: GRAPH_CORRECTION_NEW_EDGE_RELATIONS,
+            newEntityTypes: GRAPH_CORRECTION_NEW_ENTITY_TYPES
         }
     };
 }

package/dist/local-web-host.js

@@ -882,7 +882,9 @@ export function createGraphWebModule(context) {
             'project-graph-entry.js',
             'project-graph-vendor.js',
             'graph-registry-view.js',
-            'graph-registry-view.css'
+            'graph-registry-view.css',
+            'people-and-companies-view.js',
+            'people-and-companies-view.css'
         ],
         handle: handler
     };

package/dist/relation-registry.js

@@ -31,6 +31,14 @@ const definitions = {
         scopeTraversal: 'project_direct',
         traversalDirection: 'reverse'
     },
+    related_to: {
+        id: 'related_to',
+        from: 'org',
+        to: 'project',
+        meaning: 'An organization is involved in a project it does not own, such as a customer or a partner; the edge role names how.',
+        scopeTraversal: 'project_direct',
+        traversalDirection: 'forward'
+    },
     governs: {
         id: 'governs',
         from: 'decision',

package/dist/server.d.ts

@@ -73,7 +73,7 @@ export declare const toolDefinitions: readonly [{
                     readonly required: readonly ["relation", "direction"];
                     readonly properties: {
                         readonly relation: {
-                            readonly enum: readonly ["member_of", "participates_in", "accountable_for", "owned_by", "governs", "supersedes"];
+                            readonly enum: readonly ["member_of", "participates_in", "accountable_for", "owned_by", "related_to", "governs", "supersedes"];
                         };
                         readonly direction: {
                             readonly enum: readonly ["incoming", "outgoing"];

package/dist/server.js

@@ -30,7 +30,7 @@ const argsSchema = z.object({
     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']),
+        relation: z.enum(['member_of', 'participates_in', 'accountable_for', 'owned_by', 'related_to', 'governs', 'supersedes']),
         direction: z.enum(['incoming', 'outgoing']),
         targetType: z.enum(['person', 'org', 'project', 'decision']).optional()
     }).strict()).min(1).max(3).optional(),
@@ -188,7 +188,7 @@ export const toolDefinitions = [
                 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'] },
+                            relation: { enum: ['member_of', 'participates_in', 'accountable_for', 'owned_by', 'related_to', 'governs', 'supersedes'] },
                             direction: { enum: ['incoming', 'outgoing'] },
                             targetType: { enum: ['person', 'org', 'project', 'decision'] }
                         }

package/dist/templates.js

@@ -85,7 +85,7 @@ export const schemaTemplates = {
                         id: { type: 'string', minLength: 1 },
                         fromId: { type: 'string', minLength: 1 },
                         relation: {
-                            enum: ['member_of', 'participates_in', 'accountable_for', 'owned_by', 'governs', 'supersedes']
+                            enum: ['member_of', 'participates_in', 'accountable_for', 'owned_by', 'related_to', 'governs', 'supersedes']
                         },
                         toId: { type: 'string', minLength: 1 },
                         role: { type: 'string' },

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 import type { FoundationDefinition, FoundationRelationReference, FoundationRevision } from './ontology-foundation.js';
 export type EntityKind = 'person' | 'org' | 'project' | 'relationship' | 'decision';
 export type CanonicalEntityKind = 'person' | 'org' | 'project' | 'decision';
-export type CoreRelation = 'member_of' | 'participates_in' | 'accountable_for' | 'owned_by' | 'governs' | 'supersedes';
+export type CoreRelation = 'member_of' | 'participates_in' | 'accountable_for' | 'owned_by' | 'related_to' | 'governs' | 'supersedes';
 export interface GraphEntity {
     id: string;
     type: Exclude<EntityKind, 'decision'>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.37.0",
+  "version": "0.39.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",
@@ -326,6 +326,8 @@
     "./ui/objective-editor-http-port": "./ui/objective-editor-http-port.js",
     "./ui/world-model-view": "./ui/world-model-view.js",
     "./ui/world-model-view.css": "./ui/world-model-view.css",
+    "./ui/people-and-companies-view": "./ui/people-and-companies-view.js",
+    "./ui/people-and-companies-view.css": "./ui/people-and-companies-view.css",
     "./ui/local-web-shell": "./ui/local-web-shell.js",
     "./ui/local-web-shell.css": "./ui/local-web-shell.css",
     "./ui/workspace-kit": "./ui/workspace-kit.js",
@@ -479,5 +481,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "55c2d213cafd20800d51c9669f4d7c8d727f7968"
+  "gitHead": "f6631b4f6a088162dbd4a3d1fb974de3e599dc85"
 }