@unson/brainbase-mcp 0.38.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.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';
@@ -345,6 +347,20 @@ export interface GraphPersonSummaryView extends GraphEntityView {
     /** 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';
@@ -352,6 +368,25 @@ export interface GraphCompanySummaryView extends GraphEntityView {
     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';

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';
@@ -123,21 +123,85 @@ function peopleAndCompaniesOf(graph, source, asOf) {
             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
+            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) => ({
-        ...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)
-    })).sort((left, right) => Number(right.active) - Number(left.active)
+    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)
@@ -281,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/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.38.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",
@@ -481,5 +481,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "dfc88ee2c7c48aa99ae8f4157addbac69e92c7af"
+  "gitHead": "f6631b4f6a088162dbd4a3d1fb974de3e599dc85"
 }

package/ui/graph-view-shared.js

@@ -56,6 +56,7 @@ export const GRAPH_RELATION_LABELS = Object.freeze({
   participates_in: Object.freeze({ label: '参加', meaning: '人物がプロジェクトに参加している', outgoing: 'に参加', incoming: 'が参加' }),
   accountable_for: Object.freeze({ label: '責任', meaning: '人物がプロジェクトの成果や判断に責任を持つ', outgoing: 'に責任を持つ', incoming: 'が責任を持つ' }),
   owned_by: Object.freeze({ label: '所有', meaning: 'プロジェクトを組織が所有している', outgoing: 'が所有', incoming: 'を所有' }),
+  related_to: Object.freeze({ label: '関わる', meaning: '会社が顧客・協業先などとしてプロジェクトに関わっている', outgoing: 'に関わる', incoming: 'が関わる' }),
   governs: Object.freeze({ label: '方針', meaning: '判断や原則がプロジェクトの進め方を決める', outgoing: 'の進め方を決める', incoming: 'が進め方を決める' }),
   supersedes: Object.freeze({ label: '置き換え', meaning: '判断が以前の判断を置き換える', outgoing: 'を置き換える', incoming: 'に置き換えられた' }),
 });
@@ -101,6 +102,7 @@ const CORRECTION_KIND_LABELS = Object.freeze({
   update_entity: '記録を直した',
   update_edge: '関係を直した',
   create_edge: '関係を加えた',
+  create_entity: '記録を加えた',
 });
 
 /** Inputs of the correction form. `date` inputs hold a local day (YYYY-MM-DD). */
@@ -127,6 +129,9 @@ export const GRAPH_CORRECTION_ERROR_MESSAGES = Object.freeze({
   correction_relation_change_not_allowed: '関係の種類は変えられません。今の関係を終えてから、新しい関係を加えてください。',
   correction_endpoint_change_not_allowed: '関係の相手は変えられません。今の関係を終えてから、新しい関係を加えてください。',
   correction_endpoint_type_invalid: 'この組み合わせの関係は加えられません。',
+  correction_entity_type_not_allowed: 'ここで作れるのは人と会社だけです。',
+  correction_name_required: '名前を書いてください。',
+  entity_already_exists: '同じ名前の記録がすでにあります。今の記録を開いて確かめてください。',
   correction_field_not_allowed: 'この項目は、ここでは直せません。',
   correction_changes_required: '変更がありません。直したい項目を書き換えてください。',
   correction_scope_not_allowed: 'この画面では、この記録や関係は直せません。',
@@ -442,6 +447,7 @@ export function readOnlyGraphClient(client) {
  *   `GRAPH_CORRECTION_FIELDS` such as `name` or `goal` (default: every field).
  * - `edges: false`: relations cannot be corrected or ended.
  * - `createEdges: false`: relations cannot be added.
+ * - `createEntities: false`: people and companies cannot be created.
  */
 export function graphCorrectionScope(scope) {
   const given = isRecord(scope) ? scope : {};
@@ -451,6 +457,7 @@ export function graphCorrectionScope(scope) {
   return Object.freeze({
     edges: given.edges !== false,
     createEdges: given.createEdges !== false,
+    createEntities: given.createEntities !== false,
     /** Whether a record of this kind may be corrected. */
     entity: (type) => types === null || types.has(type),
     /** The given record fields that may be corrected, in their order. */
@@ -466,6 +473,7 @@ export function graphEntityCorrectionFields(type) {
 /** Whether a built correction request stays inside the scope (`recordType` is the corrected entity's kind). */
 function withinCorrectionScope(scope, body, recordType) {
   if (body.kind === 'create_edge') return scope.createEdges;
+  if (body.kind === 'create_entity') return scope.createEntities && scope.entity(body.entity?.type);
   if (body.kind === 'update_edge') return scope.edges;
   const changed = Object.keys(body.changes ?? {});
   return scope.entity(recordType) && scope.fields(changed).length === changed.length;
@@ -820,6 +828,24 @@ export function buildCorrectionRequest(form) {
     return { ok: true, body: { kind: 'create_edge', reason, edge } };
   }
 
+  if (form.kind === 'create_entity') {
+    const type = String(form.draft.type ?? '');
+    if (!form.entityTypes.includes(type)) return { ok: false, message: '作る記録の種類を選んでください。' };
+    const name = String(form.draft.name ?? '').trim();
+    if (!name) return { ok: false, message: GRAPH_CORRECTION_ERROR_MESSAGES.correction_name_required };
+    const entity = { type, name };
+    const aliases = splitAliases(form.draft.aliases ?? '').filter((alias) => alias !== name);
+    const summary = String(form.draft.summary ?? '').trim();
+    if (aliases.length > 0) entity.aliases = aliases;
+    if (summary) entity.summary = summary;
+    if (form.draft.validFrom) {
+      const validFrom = dayToRfc3339(form.draft.validFrom);
+      if (!validFrom) return { ok: false, message: '開始日の形式が正しくありません。' };
+      entity.validFrom = validFrom;
+    }
+    return { ok: true, body: { kind: 'create_entity', reason, entity } };
+  }
+
   const changes = {};
   for (const field of form.fields) {
     if (field === 'icon') {
@@ -860,11 +886,17 @@ export function buildCorrectionRequest(form) {
 
 function readBackFields(form, payload) {
   if (form.kind === 'create_edge') return ['role', 'context', 'validFrom', 'validTo'];
+  if (form.kind === 'create_entity') return ['name', 'aliases', 'summary', 'validFrom'];
   const changed = Array.isArray(payload?.correction?.changedFields) ? payload.correction.changedFields : [];
   const fields = changed.map((field) => field.replace(/^metadata\./u, '')).filter((field) => GRAPH_CORRECTION_FIELDS[field]);
   return fields.length > 0 ? fields : form.fields;
 }
 
+/** What a new record is, as rows shown before its values. */
+function createdEntityRows(form, record) {
+  return [['種類', form.typeNames[record?.type] ?? typeLabel(record?.type)]];
+}
+
 /** What a new relation connects, as rows shown before its values. */
 function createdRows(form, record) {
   const counterpartId = record?.fromId === form.anchor.id ? record?.toId : record?.fromId;
@@ -1015,6 +1047,22 @@ function renderCreateFields(doc, form, callbacks) {
   return group;
 }
 
+function renderCreateEntityFields(doc, form, callbacks) {
+  const group = makeElement(doc, 'div', { className: 'bb-graph-fields' });
+  if (form.entityTypes.length > 1) {
+    group.append(selectControl(doc, {
+      id: `${form.formId}-type`,
+      name: 'type',
+      label: '種類',
+      value: form.draft.type,
+      options: form.entityTypes.map((type) => ({ value: type, label: form.typeNames[type] ?? typeLabel(type) })),
+      onChange: (value) => callbacks.onInput('type', value),
+    }));
+  }
+  for (const field of form.fields) group.append(fieldControl(doc, form, field, callbacks));
+  return group;
+}
+
 /**
  * The correction panel.  `form` is the state held by `createGraphCorrection`;
  * callbacks are the controller's handlers.
@@ -1035,7 +1083,9 @@ export function renderCorrectionPanel(doc, form, callbacks) {
     const readBack = makeElement(doc, 'div', { className: 'bb-graph-readback', attrs: { 'aria-label': '読み直した内容' } });
     readBack.append(
       makeElement(doc, 'strong', { text: '読み直した内容' }),
-      renderValues(doc, payload.record, readBackFields(form, payload), form.kind === 'create_edge' ? createdRows(form, payload.record) : []),
+      renderValues(doc, payload.record, readBackFields(form, payload), form.kind === 'create_edge'
+        ? createdRows(form, payload.record)
+        : form.kind === 'create_entity' ? createdEntityRows(form, payload.record) : []),
     );
     panel.append(readBack, notice(doc, 'accent', mcpNote(payload)));
     panel.append(recordDetails(doc, [['記録ID', payload.record?.id], ['保存した内容のdigest', payload.digest], ['訂正ID', payload.correction?.id]]));
@@ -1045,12 +1095,17 @@ export function renderCorrectionPanel(doc, form, callbacks) {
 
   if (form.phase === 'conflict') {
     const exists = form.conflictCode === 'edge_already_exists';
-    panel.append(notice(doc, 'warning', exists
-      ? 'この関わりはすでに登録されているため、加えませんでした。今の内容を下に示します。終わった関わりをもう一度始めるときは、その関わりの終了日を消してください。入力は残しています。'
-      : 'ほかの保存で内容が変わっていたため、保存しませんでした。今の内容を下に示します。入力は残しています。今の内容を確かめてから、もう一度保存してください。', 'alert'));
+    const entityExists = form.conflictCode === 'entity_already_exists';
+    panel.append(notice(doc, 'warning', entityExists
+      ? '同じ名前の記録がすでにあるため、作りませんでした。今の記録を下に示します。同じ人や会社なら、今の記録を使ってください（終わっている記録は、終了日を消すと戻せます）。入力は残しています。'
+      : exists
+        ? 'この関わりはすでに登録されているため、加えませんでした。今の内容を下に示します。終わった関わりをもう一度始めるときは、その関わりの終了日を消してください。入力は残しています。'
+        : 'ほかの保存で内容が変わっていたため、保存しませんでした。今の内容を下に示します。入力は残しています。今の内容を確かめてから、もう一度保存してください。', 'alert'));
     const current = makeElement(doc, 'div', { className: 'bb-graph-current', attrs: { 'aria-label': '今の内容' } });
-    const fields = exists ? ['role', 'context', 'validFrom', 'validTo'] : form.fields;
-    current.append(makeElement(doc, 'strong', { text: '今の内容' }), renderValues(doc, form.current.record, fields));
+    const fields = exists ? ['role', 'context', 'validFrom', 'validTo'] : entityExists ? ['name', 'aliases', 'summary', 'validFrom', 'validTo'] : form.fields;
+    current.append(makeElement(doc, 'strong', { text: '今の内容' }), renderValues(doc, form.current.record, fields, entityExists
+      ? [['種類', form.typeNames[form.current.record?.type] ?? typeLabel(form.current.record?.type)]]
+      : []));
     current.append(recordDetails(doc, [['記録ID', form.current.record?.id], ['今の内容のdigest', form.current.digest]]));
     panel.append(current);
   } else if (form.message) {
@@ -1065,6 +1120,8 @@ export function renderCorrectionPanel(doc, form, callbacks) {
   });
   if (form.kind === 'create_edge') {
     formElement.append(renderCreateFields(doc, form, callbacks));
+  } else if (form.kind === 'create_entity') {
+    formElement.append(renderCreateEntityFields(doc, form, callbacks));
   } else {
     const group = makeElement(doc, 'div', { className: 'bb-graph-fields' });
     for (const field of form.fields) group.append(fieldControl(doc, form, field, callbacks));
@@ -1298,6 +1355,29 @@ export function createGraphCorrection({ client, rerender, onSaved, onConflict, n
       void searchCandidates('');
       return form;
     },
+    /**
+     * Create a person or a company.  `types` lists the kinds offered (only
+     * `person` and `org` are created; others are dropped), `typeNames` their
+     * labels.  Null outside the scope.
+     */
+    openCreateEntity({ types = ['person', 'org'], type, typeNames = {}, title = '記録を加える', subject } = {}) {
+      const entityTypes = allowed.createEntities
+        ? types.filter((candidate) => (candidate === 'person' || candidate === 'org') && allowed.entity(candidate))
+        : [];
+      if (entityTypes.length === 0) return null;
+      const fields = ['name', 'aliases', 'summary', 'validFrom'];
+      form = baseForm('create_entity', {
+        title,
+        subject: subject ?? null,
+        entityTypes,
+        typeNames,
+        fields,
+        original: Object.fromEntries(fields.map((field) => [field, ''])),
+        draft: { type: entityTypes.includes(type) ? type : entityTypes[0], name: '', aliases: '', summary: '', validFrom: '' },
+      });
+      redraw();
+      return form;
+    },
     close() {
       iconReadGeneration += 1;
       form = null;
@@ -1353,7 +1433,7 @@ export function createGraphCorrection({ client, rerender, onSaved, onConflict, n
         // The owner now sees the current record; the next save is based on it
         // and still sends only the fields the owner changed.  Untouched fields
         // show the current values so the form never suggests reverting them.
-        if (target.kind !== 'create_edge' && typeof result.current.digest === 'string') {
+        if (target.kind !== 'create_edge' && target.kind !== 'create_entity' && typeof result.current.digest === 'string') {
           target.expectedDigest = result.current.digest;
           const currentValues = graphRecordValues(result.current.record);
           for (const field of target.fields) {

package/ui/local-web-shell.js

@@ -270,7 +270,7 @@ function mountObjectives(container, context) {
   return { editor, worldModel };
 }
 
-function mountGraphScreen(screenId, createView) {
+function mountGraphScreen(screenId, createView, extra = {}) {
   return (container, context) => {
     const viewRoot = makeElement(context.document, 'div');
     makePage(container, context).append(viewRoot);
@@ -282,6 +282,7 @@ function mountGraphScreen(screenId, createView) {
       fetcher: context.fetcher,
       token: context.token,
       initialEntityId: context.initialEntityId,
+      ...extra,
     });
   };
 }
@@ -292,7 +293,7 @@ export const LOCAL_WEB_SCREENS = Object.freeze([
   Object.freeze({ id: 'objectives', label: '目的と現状', area: 'purpose', usesGraph: true, rail: true, source: '手元のGraph', mount: mountObjectives }),
   Object.freeze({ id: 'projects', label: 'プロジェクトと関係者', area: 'work', usesGraph: true, rail: true, source: '手元のGraph', mount: mountGraphScreen('projects', createGraphProjectsView) }),
   Object.freeze({ id: 'graph', label: '情報と関係', area: 'information', usesGraph: true, rail: true, source: '手元のGraph', mount: mountGraphScreen('graph', createGraphRegistryView) }),
-  Object.freeze({ id: 'people', label: '人と会社', area: 'information', usesGraph: true, rail: true, source: '手元のGraph', mount: mountGraphScreen('people', createPeopleAndCompaniesView) }),
+  Object.freeze({ id: 'people', label: '人と会社', area: 'information', usesGraph: true, rail: true, source: '手元のGraph', mount: mountGraphScreen('people', createPeopleAndCompaniesView, { canCorrect: true }) }),
 ]);
 
 function renderGraphGate(doc, slot, status, onRecheck, label) {

package/ui/people-and-companies-view.css

@@ -1,7 +1,8 @@
 /*
  * 「人と会社」. Load after workspace-kit.css and graph-view-shared.css.
- * Column templates of the people and company ledgers, the group titles and
- * the relations in the right rail, with a 760px variant.
+ * Column templates of the people and company ledgers, the group titles,
+ * the write buttons, the recorded company note and the relations in the
+ * right rail, with a 760px variant.
  * Uses only the shared tokens in brainbase-tokens.css.
  */
 .bb-pc-people,
@@ -35,7 +36,7 @@
 }
 
 .bb-pc-company-ledger .bb-ws-ledger-row {
-  grid-template-columns: minmax(0, 1.4fr) 96px 96px minmax(0, 1fr);
+  grid-template-columns: minmax(0, 1.4fr) minmax(0, .8fr) 84px minmax(0, 1fr) minmax(0, 1fr);
 }
 
 .bb-pc-relation-list {
@@ -74,6 +75,32 @@
   font-size: 12px;
 }
 
+.bb-pc-actions,
+.bb-pc-relation-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.bb-pc-actions {
+  margin: 0 0 12px;
+}
+
+.bb-pc-company-cell {
+  display: grid;
+  gap: 2px;
+}
+
+/* A note recorded as text on the person, never a membership: muted and dashed. */
+.bb-pc-org-note {
+  justify-self: start;
+  padding: 1px 6px;
+  border: 1px dashed var(--bb-color-border);
+  border-radius: 4px;
+  color: var(--bb-color-muted);
+  font-size: 11px;
+}
+
 @media (max-width: 760px) {
   .bb-pc-people-ledger .bb-ws-ledger-row {
     grid-template-columns: minmax(0, 1fr) minmax(0, 1fr) 84px;
@@ -84,10 +111,11 @@
   }
 
   .bb-pc-company-ledger .bb-ws-ledger-row {
-    grid-template-columns: minmax(0, 1fr) 64px 64px;
+    grid-template-columns: minmax(0, 1fr) minmax(0, .7fr) 64px;
   }
 
-  .bb-pc-company-ledger .bb-ws-ledger-row > :nth-child(4) {
+  .bb-pc-company-ledger .bb-ws-ledger-row > :nth-child(4),
+  .bb-pc-company-ledger .bb-ws-ledger-row > :nth-child(5) {
     display: none;
   }
 }

package/ui/people-and-companies-view.js

@@ -4,8 +4,23 @@
  *
  * Reads `GET {base}/people-and-companies` for the ledgers and
  * `GET {base}/entities/:id` for the selected record in the right rail (see
- * `graph-view-shared.js`).  Read only: there is no correction here; the rail
- * points to 「情報と関係」, where the same record is corrected.
+ * `graph-view-shared.js`).  Read only unless the host says it can write
+ * (`canCorrect: true`): then it creates people and companies
+ * (`create_entity`), adds a company membership (`create_edge` of
+ * `member_of`) and ends one with an end date (`update_edge`), all through
+ * `POST {base}/corrections`.  Nothing is deleted.  After a save the ledgers
+ * and the rail are read again from the host.  Other corrections stay in
+ * 「情報と関係」, which the rail links to.
+ *
+ * The company text recorded on a person (`orgNote`) is shown only for
+ * people whose company is not yet known, and only as a note: it never
+ * decides a membership, the own company or internal / external.
+ *
+ * A company's kind (顧客・協業先・提案中) is what the host derives from the
+ * company attributes (`orgType`, `lifecycle_stage`), the roles of its
+ * `related_to` relations and its recorded deals; a company without such a
+ * record shows no kind.  Its projects are split into its own (`owned_by`)
+ * and the ones it is involved in (`related_to`, with the role).
  *
  * Internal and external are not stored anywhere.  They come from the
  * company memberships (`member_of`) and the own company the host answers.
@@ -19,7 +34,9 @@
 
 import {
   badge,
+  button,
   createGraphClient,
+  createGraphCorrection,
   createGraphLayout,
   getDocument,
   graphHostEmptyNotice,
@@ -30,6 +47,8 @@ import {
   isRecord,
   makeElement,
   provenanceSummary,
+  readOnlyGraphClient,
+  graphCorrectionScope,
   relationLabel,
   textOrNull,
   validityLabel,
@@ -48,7 +67,18 @@ import {
 
 export const PEOPLE_AND_COMPANIES_VIEW_CONTRACT_VERSION = 'brainbase.people-and-companies-view.v1';
 export const PEOPLE_LEDGER_COLUMNS = Object.freeze(['名前', '会社', '関わるプロジェクト', '有効期間']);
-export const COMPANY_LEDGER_COLUMNS = Object.freeze(['会社', '所属する人', 'プロジェクト', '有効期間']);
+export const COMPANY_LEDGER_COLUMNS = Object.freeze(['会社', '種類', '所属する人', 'プロジェクト', '有効期間']);
+
+/** Plain labels of the company kinds the host derives, and of where each came from. */
+export const COMPANY_KIND_LABELS = Object.freeze({ customer: '顧客', partner: '協業先', prospect: '提案中' });
+const COMPANY_KIND_SOURCE_LABELS = Object.freeze({
+  orgType: '会社の属性',
+  lifecycle_stage: '会社の段階',
+  related_to: 'プロジェクトとの関係の役割',
+  deals: '提案中の案件の記録',
+});
+/** Plain labels of the recorded related_to roles; another role shows as recorded. */
+const RELATED_ROLE_LABELS = Object.freeze({ customer: '顧客', partner: '協業先' });
 
 const INVALID = Object.freeze({ state: 'invalid', reason: '応答の形式が不正です' });
 
@@ -62,6 +92,31 @@ function isIdList(value) {
   return Array.isArray(value) && value.every((item) => typeof item === 'string');
 }
 
+const isTextOrNull = (value) => value === null || typeof value === 'string';
+
+function isCompanySummary(company) {
+  return isEntityView(company) && isIdList(company.memberIds) && isIdList(company.projectIds)
+    && Array.isArray(company.relatedProjects) && company.relatedProjects.every((item) => isRecord(item) && typeof item.projectId === 'string' && isTextOrNull(item.role))
+    && isTextOrNull(company.orgType) && isTextOrNull(company.lifecycleStage)
+    && Array.isArray(company.deals) && company.deals.every((deal) => isRecord(deal) && isTextOrNull(deal.name) && isTextOrNull(deal.stage))
+    && Array.isArray(company.kinds) && company.kinds.every((item) => isRecord(item) && typeof item.kind === 'string' && isIdList(item.sources));
+}
+
+/** The company's kinds in plain Japanese (e.g. 顧客・協業先), or '' when none is recorded. */
+export function companyKindLabel(company) {
+  return (company?.kinds ?? []).map((item) => ownKey(COMPANY_KIND_LABELS, item.kind) ?? item.kind).join('・');
+}
+
+/** A related_to role in plain Japanese; an unknown role shows as recorded. */
+export function relatedRoleLabel(role) {
+  const text = textOrNull(role);
+  return text ? ownKey(RELATED_ROLE_LABELS, text.toLowerCase()) ?? text : null;
+}
+
+function ownKey(table, key) {
+  return typeof key === 'string' && Object.hasOwn(table, key) ? table[key] : undefined;
+}
+
 /** The read is `ok` only when every person and company is well formed. */
 export function normalizePeopleAndCompanies(result) {
   if (result?.state !== 'ok') return result ?? INVALID;
@@ -69,9 +124,9 @@ export function normalizePeopleAndCompanies(result) {
   const own = payload.ownCompany;
   if (!isRecord(own) || !(own.id === null || typeof own.id === 'string') || typeof own.reason !== 'string' || !isIdList(own.candidateIds)) return INVALID;
   if (!Array.isArray(payload.people) || !payload.people.every((person) => isEntityView(person)
-    && isIdList(person.companyIds) && Number.isInteger(person.projectCount) && Number.isInteger(person.accountableProjectCount))) return INVALID;
-  if (!Array.isArray(payload.companies) || !payload.companies.every((company) => isEntityView(company)
-    && isIdList(company.memberIds) && isIdList(company.projectIds))) return INVALID;
+    && isIdList(person.companyIds) && Number.isInteger(person.projectCount) && Number.isInteger(person.accountableProjectCount)
+    && (person.orgNote === undefined || isTextOrNull(person.orgNote)))) return INVALID;
+  if (!Array.isArray(payload.companies) || !payload.companies.every(isCompanySummary)) return INVALID;
   if (payload.people.length === 0 && payload.companies.length === 0 && payload.absenceConfirmed !== true) return { state: 'unknown' };
   return { state: 'ok', payload };
 }
@@ -116,6 +171,27 @@ export function personStanding(person, ownCompanyId) {
   return person.companyIds.length > 0 ? '社外' : '所属未確認';
 }
 
+/** The company text recorded on a person whose company is not yet known, or null. */
+export function personOrgNote(person, ownCompanyId) {
+  const note = textOrNull(person?.orgNote);
+  if (!note) return null;
+  const standing = personStanding(person, ownCompanyId);
+  return standing === '社内' || standing === '社外' ? null : note;
+}
+
+/**
+ * @param {object} options
+ * @param {boolean} [options.canCorrect=false] Whether the host lets this viewer write.  Only then
+ *   人を加える, 会社を加える, 所属を付ける, 所属する人を加える and 所属を終える are drawn; otherwise the
+ *   client refuses every correction before sending it.  The host decides it (for example from the
+ *   viewer's role); this part holds no role name.
+ * @param {{ entityTypes?: string[], edges?: boolean, createEdges?: boolean, createEntities?: boolean }} [options.correctionScope]
+ *   With writes allowed, only these (see `graphCorrectionScope`): `createEntities: false` withholds
+ *   人を加える・会社を加える, `createEdges: false` withholds 所属を付ける・所属する人を加える, `edges: false`
+ *   withholds 所属を終える, and `entityTypes` limits the kinds that may be created.
+ * @param {string} [options.token] Launch token sent with a correction.
+ * @param {string} [options.tokenHeader] Header name for the token.
+ */
 export function createPeopleAndCompaniesView({
   root,
   rail,
@@ -123,16 +199,29 @@ export function createPeopleAndCompaniesView({
   document: explicitDocument,
   fetcher,
   basePath = '/api/graph',
+  token,
+  tokenHeader,
   autoLoad = true,
   initialEntityId,
   now = () => new Date(),
+  canCorrect = false,
+  correctionScope,
   sourceNotice,
   emptyNotice,
   correctionHref = (id) => `#graph?entity_id=${encodeURIComponent(id)}`,
 } = {}) {
   if (!root) throw new TypeError('root is required');
   const doc = getDocument(explicitDocument);
-  const client = createGraphClient({ fetcher, basePath });
+  const graphClient = createGraphClient({ fetcher, basePath, token, ...(tokenHeader ? { tokenHeader } : {}) });
+  const writable = canCorrect === true;
+  const client = writable ? graphClient : readOnlyGraphClient(graphClient);
+  const scope = graphCorrectionScope(correctionScope);
+  const can = Object.freeze({
+    createPerson: writable && scope.createEntities && scope.entity('person'),
+    createCompany: writable && scope.createEntities && scope.entity('org'),
+    addMembership: writable && scope.createEdges,
+    endMembership: writable && scope.edges,
+  });
   const context = graphPageContext(page);
   const layout = createGraphLayout(doc, {
     root,
@@ -142,6 +231,21 @@ export function createPeopleAndCompaniesView({
     contractVersion: PEOPLE_AND_COMPANIES_VIEW_CONTRACT_VERSION,
   });
   const state = { list: { state: 'loading' }, detail: null };
+  const correction = createGraphCorrection({
+    client,
+    now,
+    scope: correctionScope,
+    rerender: () => controller.render(),
+    onSaved: async (payload, form) => {
+      // Read the saved state back from the host, never from the form.
+      const id = form.kind === 'create_entity' ? payload.record?.id : state.detail?.id;
+      await controller.load({ keepDetail: true });
+      if (id) await controller.openEntity(id, { keepCorrection: true });
+    },
+    onConflict: async () => {
+      if (state.detail) await controller.openEntity(state.detail.id, { keepCorrection: true });
+    },
+  });
 
   const nameOf = (id) => {
     if (state.list.state !== 'ok') return id;
@@ -161,7 +265,7 @@ export function createPeopleAndCompaniesView({
       onSelect: (id) => void controller.openEntity(id),
       cells: [
         { primary: person.isOwner ? `${person.name}（あなた）` : person.name, secondary: person.id },
-        person.companyIds.length > 0 ? person.companyIds.map(nameOf).join('、') : '所属の記録なし',
+        person.companyIds.length > 0 ? person.companyIds.map(nameOf).join('、') : companyCell(person, ownId),
         person.accountableProjectCount > 0
           ? `${person.projectCount}件（うち責任 ${person.accountableProjectCount}件）`
           : `${person.projectCount}件`,
@@ -171,6 +275,36 @@ export function createPeopleAndCompaniesView({
     }));
   }
 
+  function orgNoteText(note) {
+    return `記録上のメモ: ${note}（所属ではありません）`;
+  }
+
+  function companyCell(person, ownId) {
+    const note = personOrgNote(person, ownId);
+    if (!note) return '所属の記録なし';
+    const cell = makeElement(doc, 'span', { className: 'bb-pc-company-cell' });
+    cell.append(
+      makeElement(doc, 'span', { text: '所属の記録なし' }),
+      makeElement(doc, 'small', { className: 'bb-pc-org-note', text: orgNoteText(note) }),
+    );
+    return cell;
+  }
+
+  function sectionActions(label, onClick) {
+    const actions = makeElement(doc, 'div', { className: 'bb-pc-actions' });
+    actions.append(button(doc, label, onClick));
+    return actions;
+  }
+
+  function openCreateEntity(type) {
+    correction.openCreateEntity({
+      types: [type],
+      typeNames: { person: '人', org: '会社' },
+      title: type === 'org' ? '会社を加える' : '人を加える',
+      subject: type === 'org' ? 'Graphに会社の記録を作ります。' : 'Graphに人の記録を作ります。',
+    });
+  }
+
   function peopleLedger(label, people, empty) {
     return workspaceLedger(doc, {
       className: 'bb-pc-people-ledger',
@@ -184,6 +318,7 @@ export function createPeopleAndCompaniesView({
   function peopleSection(payload) {
     const section = makeElement(doc, 'section', { className: 'bb-pc-people', attrs: { 'aria-label': '人' } });
     section.append(workspaceSectionTitle(doc, { title: '人', lead: '社内か社外かは、所属（会社への所属の関係）と自社から決めています。印は別に持っていません。' }));
+    if (can.createPerson) section.append(sectionActions('人を加える', () => openCreateEntity('person')));
     const groups = groupPeople(payload);
     if (!groups.ownCompanyId) {
       const reason = OWN_COMPANY_REASONS[payload.ownCompany.reason] ?? '自社を決められません。';
@@ -210,7 +345,11 @@ export function createPeopleAndCompaniesView({
 
   function companySection(payload) {
     const section = makeElement(doc, 'section', { className: 'bb-pc-companies', attrs: { 'aria-label': '会社' } });
-    section.append(workspaceSectionTitle(doc, { title: '会社', lead: '自社を先頭に、Graphに登録された会社を並べています。' }));
+    section.append(workspaceSectionTitle(doc, {
+      title: '会社',
+      lead: '自社を先頭に、顧客・協業先など関わる会社を並べています。種類は、会社の属性、プロジェクトとの関係の役割、提案中の案件の記録から出しています。記録が無い会社には種類を出しません。',
+    }));
+    if (can.createCompany) section.append(sectionActions('会社を加える', () => openCreateEntity('org')));
     const active = payload.companies.filter((company) => company.active);
     section.append(workspaceLedger(doc, {
       className: 'bb-pc-company-ledger',
@@ -223,8 +362,11 @@ export function createPeopleAndCompaniesView({
         onSelect: (id) => void controller.openEntity(id),
         cells: [
           { primary: company.id === payload.ownCompany.id ? `${company.name}（自社）` : company.name, secondary: company.id },
+          companyKindLabel(company),
           `${company.memberIds.length}人`,
-          `${company.projectIds.length}件`,
+          company.relatedProjects.length > 0
+            ? `${company.projectIds.length}件（関わる ${company.relatedProjects.length}件）`
+            : `${company.projectIds.length}件`,
           validityLabel(company, payload.asOf),
         ],
       })),
@@ -264,7 +406,7 @@ export function createPeopleAndCompaniesView({
   // -------------------------------------------------------------------------
   // Rail
 
-  function edgeList(edges, empty) {
+  function edgeList(edges, empty, { roleLabel = textOrNull, actions } = {}) {
     if (edges.length === 0) return makeElement(doc, 'p', { className: 'bb-pc-empty', text: empty });
     const list = makeElement(doc, 'ul', { className: 'bb-pc-relation-list' });
     for (const edge of edges) {
@@ -276,16 +418,68 @@ export function createPeopleAndCompaniesView({
         head,
         makeElement(doc, 'span', { className: 'bb-pc-relation-meta', text: [
           validityLabel(edge, asOf()),
-          textOrNull(edge.role) ? `役割: ${edge.role}` : null,
+          roleLabel(edge.role) ? `役割: ${roleLabel(edge.role)}` : null,
           `出典: ${source.kind}${source.reference ? `（${source.reference}）` : ''}`,
         ].filter(Boolean).join('　') }),
       );
+      const controls = actions?.(edge) ?? [];
+      if (controls.length > 0) {
+        const row = makeElement(doc, 'div', { className: 'bb-pc-relation-actions' });
+        row.append(...controls);
+        item.append(row);
+      }
+      list.append(item);
+    }
+    return list;
+  }
+
+  function dealList(deals) {
+    const list = makeElement(doc, 'ul', { className: 'bb-pc-relation-list' });
+    for (const deal of deals) {
+      const item = makeElement(doc, 'li', { className: 'bb-pc-relation' });
+      item.append(makeElement(doc, 'strong', { text: deal.name ?? '名前の記録が無い案件' }));
+      if (deal.stage) item.append(makeElement(doc, 'span', { className: 'bb-pc-relation-meta', text: `段階: ${deal.stage}` }));
       list.append(item);
     }
     return list;
   }
 
+  function membershipActions(edge, entity) {
+    if (!can.endMembership || !edge.active) return [];
+    const person = entity.type === 'org' ? edge.counterpart.name : entity.name;
+    const company = entity.type === 'org' ? entity.name : edge.counterpart.name;
+    return [button(doc, '所属を終える', () => correction.openEdge(edge, {
+      mode: 'end',
+      title: '所属を終える',
+      subject: `${person}の「${company}」への所属に終了日を入れます。記録は消さずに残ります。`,
+    }))];
+  }
+
+  function addMembershipButton(entity) {
+    if (!can.addMembership) return null;
+    const label = entity.type === 'org' ? '所属する人を加える' : '所属を付ける';
+    return sectionActions(label, () => correction.openCreate(
+      { id: entity.id, type: entity.type, name: entity.name },
+      {
+        relations: ['member_of'],
+        relationNames: { member_of: '所属' },
+        relationLabel: '関わり方',
+        title: label,
+        subject: entity.type === 'org' ? `「${entity.name}」に所属する人を選びます。` : `${entity.name}が所属する会社を選びます。`,
+      },
+    ));
+  }
+
   function railContent() {
+    const panel = correction.render(doc);
+    const blocks = railBlocks();
+    if (!panel) return blocks;
+    // A new record's form shows first; a membership form right after the record's head.
+    if (correction.form?.kind === 'create_entity' || !state.detail || state.detail.state !== 'ok') return [panel, ...blocks];
+    return [blocks[0], panel, ...blocks.slice(1)];
+  }
+
+  function railBlocks() {
     const detail = state.detail;
     if (!detail) {
       return [workspaceDetailEmpty(doc, { mark: '人', title: '人か会社を選んでください', text: '所属と関わるプロジェクトを、有効期間と出典つきで確かめられます。' })];
@@ -297,6 +491,9 @@ export function createPeopleAndCompaniesView({
       ? state.list.payload.people.find((person) => person.id === entity.id)
       : null;
     const ownId = state.list.state === 'ok' ? state.list.payload.ownCompany.id : null;
+    const company = state.list.state === 'ok' && entity.type === 'org'
+      ? state.list.payload.companies.find((item) => item.id === entity.id)
+      : null;
     const blocks = [workspaceRailHead(doc, {
       kicker: entity.type === 'org' ? '会社' : '人',
       title: entity.name,
@@ -305,14 +502,33 @@ export function createPeopleAndCompaniesView({
     })];
     blocks.push(workspaceDefinition(doc, [
       ...(entity.type === 'person' && listed ? [['区分', personStanding(listed, ownId)]] : []),
+      ...(entity.type === 'person' && listed && personOrgNote(listed, ownId)
+        ? [['記録上のメモ', `${personOrgNote(listed, ownId)}（人物の記録に文字で残っている会社名です。所属の記録ではありません）`]]
+        : []),
       ...(entity.type === 'org' && entity.id === ownId ? [['区分', '自社']] : []),
+      ...(company && company.kinds.length > 0 ? [['種類', company.kinds.map((item) => {
+        const sources = item.sources.map((source) => ownKey(COMPANY_KIND_SOURCE_LABELS, source) ?? source).join('・');
+        return `${ownKey(COMPANY_KIND_LABELS, item.kind) ?? item.kind}（${sources}から）`;
+      }).join('、')]] : []),
+      ...(company?.lifecycleStage ? [['記録上の段階', company.lifecycleStage]] : []),
       ['有効期間', validityLabel(entity, asOf())],
     ]));
     if (entity.type === 'org') {
-      blocks.push(workspaceRailBlock(doc, { title: '所属する人', content: edgeList(incoming.filter((edge) => edge.relation === 'member_of'), '所属する人の記録はありません。') }));
-      blocks.push(workspaceRailBlock(doc, { title: 'プロジェクト', content: edgeList(incoming.filter((edge) => edge.relation === 'owned_by'), 'この会社のプロジェクトの記録はありません。') }));
+      blocks.push(workspaceRailBlock(doc, { title: '所属する人', content: [
+        edgeList(incoming.filter((edge) => edge.relation === 'member_of'), '所属する人の記録はありません。', { actions: (edge) => membershipActions(edge, entity) }),
+        addMembershipButton(entity),
+      ] }));
+      blocks.push(workspaceRailBlock(doc, { title: 'この会社のプロジェクト', content: edgeList(incoming.filter((edge) => edge.relation === 'owned_by'), 'この会社のプロジェクトの記録はありません。') }));
+      blocks.push(workspaceRailBlock(doc, {
+        title: '顧客・協業先として関わるプロジェクト',
+        content: edgeList(outgoing.filter((edge) => edge.relation === 'related_to'), '顧客・協業先として関わるプロジェクトの記録はありません。', { roleLabel: relatedRoleLabel }),
+      }));
+      if (company && company.deals.length > 0) blocks.push(workspaceRailBlock(doc, { title: '提案中の案件', content: dealList(company.deals) }));
     } else {
-      blocks.push(workspaceRailBlock(doc, { title: '所属', content: edgeList(outgoing.filter((edge) => edge.relation === 'member_of'), '会社への所属の記録はありません。') }));
+      blocks.push(workspaceRailBlock(doc, { title: '所属', content: [
+        edgeList(outgoing.filter((edge) => edge.relation === 'member_of'), '会社への所属の記録はありません。', { actions: (edge) => membershipActions(edge, entity) }),
+        addMembershipButton(entity),
+      ] }));
       blocks.push(workspaceRailBlock(doc, {
         title: '関わるプロジェクト',
         content: edgeList(outgoing.filter((edge) => edge.relation === 'participates_in' || edge.relation === 'accountable_for'), '関わるプロジェクトの記録はありません。'),
@@ -320,7 +536,9 @@ export function createPeopleAndCompaniesView({
     }
     const fix = makeElement(doc, 'p', { className: 'bb-pc-fix' });
     fix.append(
-      makeElement(doc, 'span', { text: '間違いは「情報と関係」で、この記録を開いて直します。' }),
+      makeElement(doc, 'span', { text: writable
+        ? '名前・別名・要約などの間違いは「情報と関係」で、この記録を開いて直します。'
+        : '間違いは「情報と関係」で、この記録を開いて直します。' }),
       makeElement(doc, 'a', { text: '情報と関係で開く', attrs: { href: correctionHref(entity.id) } }),
     );
     blocks.push(fix);
@@ -334,17 +552,25 @@ export function createPeopleAndCompaniesView({
     get state() {
       return state;
     },
+    get correction() {
+      return correction;
+    },
     render() {
       layout.render(workspace(), railContent());
     },
-    async load() {
-      state.list = { state: 'loading' };
-      controller.render();
+    /** Reads the ledgers.  `keepDetail` keeps the open record (and the shown ledgers) while reading. */
+    async load({ keepDetail = false } = {}) {
+      if (!keepDetail || state.list.state !== 'ok') {
+        state.list = { state: 'loading' };
+        controller.render();
+      }
       state.list = normalizePeopleAndCompanies(await client.read('/people-and-companies'));
       controller.render();
       if (initialEntityId && !state.detail) await controller.openEntity(initialEntityId);
     },
-    async openEntity(id) {
+    /** Opens a record in the rail.  Choosing another record closes an open form unless `keepCorrection`. */
+    async openEntity(id, { keepCorrection = false } = {}) {
+      if (!keepCorrection && correction.form && state.detail?.id !== id) correction.close();
       state.detail = { id, state: 'loading' };
       controller.render();
       const result = await client.read(`/entities/${encodeURIComponent(id)}`);