@unson/brainbase-mcp 0.37.0 → 0.38.0

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

@@ -335,6 +335,44 @@ 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;
+}
+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[];
+}
+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

@@ -93,6 +93,51 @@ 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
+        };
+    }).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)
+        || Number(right.id === ownCompany.id) - Number(left.id === ownCompany.id)
+        || byActiveThenName(left, right));
+    return { status: 'ok', source, asOf, ownCompany, people, companies, absenceConfirmed: people.length === 0 && companies.length === 0 };
+}
 export async function readGraphProject(dataDir, projectId, options = {}) {
     const loaded = await loadForRead(dataDir);
     if ('status' in loaded)

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.37.0",
+  "version": "0.38.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": "dfc88ee2c7c48aa99ae8f4157addbac69e92c7af"
 }

package/ui/local-web-shell.css

@@ -70,6 +70,19 @@ body {
   gap: 2px;
 }
 
+.bb-shell-nav-group {
+  display: grid;
+  gap: 2px;
+}
+
+.bb-shell-nav-group-head {
+  margin: 14px 10px 4px;
+  color: var(--bb-color-rail-muted);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: .04em;
+}
+
 .bb-shell-nav-link {
   min-height: 38px;
   display: flex;

package/ui/local-web-shell.js

@@ -17,6 +17,7 @@
 
 import { createGraphProjectsView } from './graph-projects-view.js';
 import { createGraphRegistryView } from './graph-registry-view.js';
+import { createPeopleAndCompaniesView } from './people-and-companies-view.js';
 import { createObjectiveEditorController } from './objective-editor.js';
 import { createObjectiveEditorHttpPort } from './objective-editor-http-port.js';
 import { createJudgmentHistoryUI } from './judgment-history.js';
@@ -42,18 +43,52 @@ const UNREADABLE_LABELS = Object.freeze({
 
 // Stroke icons from the organization edition's sprite (apps/web/public/index.html).
 const NAV_ICON_PATHS = Object.freeze({
-  'value-proofs': ['M5 20V10m7 10V4m7 16v-7'],
+  'value-proofs': ['M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8', 'M3 3v5h5', 'M12 7v5l4 2'],
   objectives: ['M12 4 3 20h18z', 'M12 9v5m0 3h.01'],
   projects: ['M3 6.5h7l2 2h9v10H3z', 'M3 6.5v-2h7l2 2'],
   graph: ['M10 13a5 5 0 0 0 7.5.5l2-2a5 5 0 0 0-7-7l-1.2 1.2', 'M14 11a5 5 0 0 0-7.5-.5l-2 2a5 5 0 0 0 7 7l1.2-1.2'],
   minutes: ['M6 3.5h9l3 3V20.5H6z', 'M15 3.5v4h3', 'M9 12h6m-6 3h6'],
+  // Two people (the organization edition's 人と会社 uses the same shape).
+  people: ['M9 11a3.5 3.5 0 1 0 0-7 3.5 3.5 0 0 0 0 7z', 'M2.5 20a6.5 6.5 0 0 1 13 0', 'M16 4.5a3.5 3.5 0 0 1 0 6.5', 'M18 14a6.5 6.5 0 0 1 3.5 6'],
   // World view (extension id `world`, ledger P17).
   world: ['M12 3a9 9 0 1 0 0 18 9 9 0 0 0 0-18z', 'M3 12h18', 'M12 3c2.5 2.6 3.8 5.6 3.8 9s-1.3 6.4-3.8 9c-2.5-2.6-3.8-5.6-3.8-9S9.5 5.6 12 3z'],
 });
+// Screens without their own icon (for example a private product's extension).
+const DEFAULT_NAV_ICON_PATHS = Object.freeze(['M5 20V10m7 10V4m7 16v-7']);
 const SVG_NS = 'http://www.w3.org/2000/svg';
 
+// The menu's areas (brainbase-project ledger D10): the same order and headings
+// as the organization edition. 目的と現状 is the only item of its area, so it
+// has no heading. Inside an area, `order` lists the screens first in that order.
+const NAV_AREAS = Object.freeze([
+  Object.freeze({ id: 'purpose', label: null, order: ['objectives'] }),
+  Object.freeze({ id: 'work', label: '仕事', order: ['projects', 'minutes'] }),
+  Object.freeze({ id: 'outcomes', label: '成果', order: ['value-proofs'] }),
+  Object.freeze({ id: 'information', label: '情報と関係', order: ['graph', 'people'] }),
+  Object.freeze({ id: 'settings', label: '設定', order: [] }),
+]);
+
+// Menu order only: the screens' own order (and so the first screen) stays as given.
+// Screens without an area keep their place — those before the first area-bound
+// screen come first (a leading extension such as the world), the rest come last.
+function navLayout(screens) {
+  const firstInArea = screens.findIndex((screen) => NAV_AREAS.some((area) => area.id === screen.area));
+  if (firstInArea === -1) return { leading: [...screens], areas: [], trailing: [] };
+  const leading = screens.slice(0, firstInArea);
+  const trailing = screens.slice(firstInArea).filter((screen) => !NAV_AREAS.some((area) => area.id === screen.area));
+  const areas = NAV_AREAS.map((area) => {
+    const members = screens.filter((screen) => screen.area === area.id);
+    const rank = (screen) => {
+      const index = area.order.indexOf(screen.id);
+      return index === -1 ? area.order.length + members.indexOf(screen) : index;
+    };
+    return { area, screens: [...members].sort((a, b) => rank(a) - rank(b)) };
+  }).filter((entry) => entry.screens.length > 0);
+  return { leading, areas, trailing };
+}
+
 function makeIcon(doc, id) {
-  const paths = NAV_ICON_PATHS[id] ?? NAV_ICON_PATHS['value-proofs'];
+  const paths = NAV_ICON_PATHS[id] ?? DEFAULT_NAV_ICON_PATHS;
   const create = (tag) => (typeof doc.createElementNS === 'function' ? doc.createElementNS(SVG_NS, tag) : doc.createElement(tag));
   const svg = create('svg');
   svg.setAttribute('class', 'bb-shell-icon');
@@ -252,11 +287,12 @@ function mountGraphScreen(screenId, createView) {
 }
 
 export const LOCAL_WEB_SCREENS = Object.freeze([
-  Object.freeze({ id: 'value-proofs', label: '判断の履歴', usesGraph: false, rail: true, source: '判断の記録', mount: mountToday }),
-  Object.freeze({ id: 'minutes', label: '議事録', usesGraph: false, rail: true, source: '正本の議事録', mount: mountMeetingMinutes }),
-  Object.freeze({ id: 'objectives', label: '目的と現状', usesGraph: true, rail: true, source: '手元のGraph', mount: mountObjectives }),
-  Object.freeze({ id: 'projects', label: 'プロジェクトと関係者', usesGraph: true, rail: true, source: '手元のGraph', mount: mountGraphScreen('projects', createGraphProjectsView) }),
-  Object.freeze({ id: 'graph', label: '情報と関係', usesGraph: true, rail: true, source: '手元のGraph', mount: mountGraphScreen('graph', createGraphRegistryView) }),
+  Object.freeze({ id: 'value-proofs', label: '判断の履歴', area: 'outcomes', usesGraph: false, rail: true, source: '判断の記録', mount: mountToday }),
+  Object.freeze({ id: 'minutes', label: '議事録', area: 'work', usesGraph: false, rail: true, source: '正本の議事録', mount: mountMeetingMinutes }),
+  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) }),
 ]);
 
 function renderGraphGate(doc, slot, status, onRecheck, label) {
@@ -373,7 +409,7 @@ export function createLocalWebShell({
   };
   menuButton.addEventListener('click', () => setMenuOpen(!sidebar.className.includes('is-open')));
   backdrop.addEventListener('click', () => setMenuOpen(false));
-  for (const screen of screens) {
+  const navLink = (screen) => {
     const link = makeElement(doc, 'a', { className: 'bb-shell-nav-link', text: screen.label, attrs: { href: `#${screen.id}` } });
     // The label stays the link's own text; the icon goes in front where the DOM allows it.
     if (typeof link.prepend === 'function') link.prepend(makeIcon(doc, screen.id));
@@ -382,8 +418,22 @@ export function createLocalWebShell({
       controller.show(screen.id);
     });
     links.set(screen.id, link);
-    nav.append(link);
+    return link;
+  };
+  const layout = navLayout(screens);
+  for (const screen of layout.leading) nav.append(navLink(screen));
+  for (const { area, screens: members } of layout.areas) {
+    if (!area.label) {
+      for (const screen of members) nav.append(navLink(screen));
+      continue;
+    }
+    const headId = `bb-shell-nav-area-${area.id}`;
+    const group = makeElement(doc, 'div', { className: 'bb-shell-nav-group', attrs: { role: 'group', 'aria-labelledby': headId } });
+    group.append(makeElement(doc, 'div', { className: 'bb-shell-nav-group-head', text: area.label, attrs: { id: headId } }));
+    for (const screen of members) group.append(navLink(screen));
+    nav.append(group);
   }
+  for (const screen of layout.trailing) nav.append(navLink(screen));
   const source = makeElement(doc, 'section', { className: 'bb-shell-source', attrs: { 'aria-label': '出典' } });
   sidebar.append(brand, nav, source);
   const workspace = makeElement(doc, 'div', { className: 'bb-shell-workspace' });

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

@@ -0,0 +1,93 @@
+/*
+ * 「人と会社」. 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.
+ * Uses only the shared tokens in brainbase-tokens.css.
+ */
+.bb-pc-people,
+.bb-pc-companies {
+  margin-bottom: 30px;
+}
+
+.bb-graph .bb-pc-group-title {
+  margin: 22px 0 10px;
+  color: var(--bb-color-ink);
+  font-size: 13px;
+}
+
+.bb-graph .bb-pc-company-title {
+  margin: 14px 0 8px;
+  color: var(--bb-color-muted);
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.bb-graph .bb-pc-empty,
+.bb-graph .bb-pc-ended,
+.bb-graph-rail .bb-pc-empty {
+  margin: 0 0 10px;
+  color: var(--bb-color-muted);
+  font-size: 12px;
+}
+
+.bb-pc-people-ledger .bb-ws-ledger-row {
+  grid-template-columns: minmax(0, 1.3fr) minmax(0, 1.2fr) minmax(0, 1fr) minmax(0, 1fr);
+}
+
+.bb-pc-company-ledger .bb-ws-ledger-row {
+  grid-template-columns: minmax(0, 1.4fr) 96px 96px minmax(0, 1fr);
+}
+
+.bb-pc-relation-list {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.bb-pc-relation {
+  display: grid;
+  gap: 4px;
+  padding: 8px 0;
+  border-bottom: 1px solid var(--bb-color-border);
+}
+
+.bb-pc-relation.is-ended {
+  opacity: .62;
+}
+
+.bb-pc-relation-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.bb-pc-relation-meta {
+  color: var(--bb-color-muted);
+  font-size: 12px;
+}
+
+.bb-graph-rail .bb-pc-fix {
+  display: grid;
+  gap: 6px;
+  margin: 16px 0 0;
+  color: var(--bb-color-muted);
+  font-size: 12px;
+}
+
+@media (max-width: 760px) {
+  .bb-pc-people-ledger .bb-ws-ledger-row {
+    grid-template-columns: minmax(0, 1fr) minmax(0, 1fr) 84px;
+  }
+
+  .bb-pc-people-ledger .bb-ws-ledger-row > :nth-child(4) {
+    display: none;
+  }
+
+  .bb-pc-company-ledger .bb-ws-ledger-row {
+    grid-template-columns: minmax(0, 1fr) 64px 64px;
+  }
+
+  .bb-pc-company-ledger .bb-ws-ledger-row > :nth-child(4) {
+    display: none;
+  }
+}

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

@@ -0,0 +1,370 @@
+/*
+ * 「人と会社」: who the people in the Graph are, which company each belongs
+ * to, and whether they are internal, external or not yet known.
+ *
+ * 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.
+ *
+ * Internal and external are not stored anywhere.  They come from the
+ * company memberships (`member_of`) and the own company the host answers.
+ * When the own company is not known, every person is shown as not yet known
+ * instead of being guessed.  Ended records stay out of the ledgers and are
+ * only counted.
+ *
+ * The host injects the fetcher, base path, right rail and page context; this
+ * module keeps no global state.
+ */
+
+import {
+  badge,
+  createGraphClient,
+  createGraphLayout,
+  getDocument,
+  graphHostEmptyNotice,
+  graphPageContext,
+  graphStateNotice,
+  isEdgeView,
+  isEntityView,
+  isRecord,
+  makeElement,
+  provenanceSummary,
+  relationLabel,
+  textOrNull,
+  validityLabel,
+} from './graph-view-shared.js';
+import {
+  workspaceDefinition,
+  workspaceDetailEmpty,
+  workspaceHostNotice,
+  workspaceLedger,
+  workspaceNotice,
+  workspacePageHeader,
+  workspaceRailBlock,
+  workspaceRailHead,
+  workspaceSectionTitle,
+} from './workspace-kit.js';
+
+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(['会社', '所属する人', 'プロジェクト', '有効期間']);
+
+const INVALID = Object.freeze({ state: 'invalid', reason: '応答の形式が不正です' });
+
+const OWN_COMPANY_REASONS = Object.freeze({
+  owner_has_no_company: 'あなた（本人）の所属する会社がGraphにありません。',
+  owner_has_several_companies: 'あなた（本人）が複数の会社に所属しているため、自社を1つに決められません。',
+  owner_not_found: 'Graphに、あなた（本人）の記録がありません。',
+});
+
+function isIdList(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+
+/** The read is `ok` only when every person and company is well formed. */
+export function normalizePeopleAndCompanies(result) {
+  if (result?.state !== 'ok') return result ?? INVALID;
+  const payload = result.payload;
+  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;
+  if (payload.people.length === 0 && payload.companies.length === 0 && payload.absenceConfirmed !== true) return { state: 'unknown' };
+  return { state: 'ok', payload };
+}
+
+/**
+ * Splits the active people into internal, external by company and not yet
+ * known.  Without an own company every active person is not yet known.
+ */
+export function groupPeople(payload) {
+  const ownId = payload.ownCompany?.id ?? null;
+  const companies = new Map(payload.companies.map((company) => [company.id, company]));
+  const active = payload.people.filter((person) => person.active);
+  const groups = { ownCompanyId: ownId, internal: [], external: [], unknown: [] };
+  if (!ownId) {
+    groups.unknown = active;
+    return groups;
+  }
+  const byCompany = new Map();
+  for (const person of active) {
+    if (person.companyIds.includes(ownId)) {
+      groups.internal.push(person);
+      continue;
+    }
+    const companyId = person.companyIds.find((id) => companies.has(id));
+    if (!companyId) {
+      groups.unknown.push(person);
+      continue;
+    }
+    if (!byCompany.has(companyId)) byCompany.set(companyId, []);
+    byCompany.get(companyId).push(person);
+  }
+  groups.external = [...byCompany.entries()]
+    .map(([companyId, people]) => ({ company: companies.get(companyId), people }))
+    .sort((left, right) => left.company.name.localeCompare(right.company.name, 'ja') || left.company.id.localeCompare(right.company.id, 'en'));
+  return groups;
+}
+
+/** Whether a person is internal, external or not yet known, in plain Japanese. */
+export function personStanding(person, ownCompanyId) {
+  if (!ownCompanyId) return '所属未確認（自社が未設定）';
+  if (person.companyIds.includes(ownCompanyId)) return '社内';
+  return person.companyIds.length > 0 ? '社外' : '所属未確認';
+}
+
+export function createPeopleAndCompaniesView({
+  root,
+  rail,
+  page,
+  document: explicitDocument,
+  fetcher,
+  basePath = '/api/graph',
+  autoLoad = true,
+  initialEntityId,
+  now = () => new Date(),
+  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 context = graphPageContext(page);
+  const layout = createGraphLayout(doc, {
+    root,
+    rail,
+    label: '人と会社',
+    className: 'bb-pc',
+    contractVersion: PEOPLE_AND_COMPANIES_VIEW_CONTRACT_VERSION,
+  });
+  const state = { list: { state: 'loading' }, detail: null };
+
+  const nameOf = (id) => {
+    if (state.list.state !== 'ok') return id;
+    const { people, companies } = state.list.payload;
+    return (people.find((item) => item.id === id) ?? companies.find((item) => item.id === id))?.name ?? id;
+  };
+  const asOf = () => (state.list.state === 'ok' ? state.list.payload.asOf : now().toISOString());
+
+  // -------------------------------------------------------------------------
+  // Workspace
+
+  function personRows(people) {
+    const ownId = state.list.payload.ownCompany.id;
+    return people.map((person) => ({
+      key: person.id,
+      selected: person.id === state.detail?.id,
+      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.accountableProjectCount > 0
+          ? `${person.projectCount}件（うち責任 ${person.accountableProjectCount}件）`
+          : `${person.projectCount}件`,
+        validityLabel(person, asOf()),
+      ],
+      label: `${person.name}、${personStanding(person, ownId)}`,
+    }));
+  }
+
+  function peopleLedger(label, people, empty) {
+    return workspaceLedger(doc, {
+      className: 'bb-pc-people-ledger',
+      ariaLabel: label,
+      columns: PEOPLE_LEDGER_COLUMNS,
+      empty,
+      rows: personRows(people),
+    });
+  }
+
+  function peopleSection(payload) {
+    const section = makeElement(doc, 'section', { className: 'bb-pc-people', attrs: { 'aria-label': '人' } });
+    section.append(workspaceSectionTitle(doc, { title: '人', lead: '社内か社外かは、所属（会社への所属の関係）と自社から決めています。印は別に持っていません。' }));
+    const groups = groupPeople(payload);
+    if (!groups.ownCompanyId) {
+      const reason = OWN_COMPANY_REASONS[payload.ownCompany.reason] ?? '自社を決められません。';
+      section.append(workspaceNotice(doc, {
+        label: '自社が未設定',
+        tone: 'warning',
+        text: `${reason}推測で社内・社外を分けず、全員を所属未確認に置いています。あなたの記録に会社への所属を加えると、社内と社外に分かれます。`,
+      }));
+    }
+    if (groups.ownCompanyId) {
+      section.append(makeElement(doc, 'h3', { className: 'bb-pc-group-title', text: `社内（${nameOf(groups.ownCompanyId)}）` }));
+      section.append(peopleLedger('社内の人', groups.internal, '自社に所属する人の記録はありません。'));
+      section.append(makeElement(doc, 'h3', { className: 'bb-pc-group-title', text: '社外' }));
+      if (groups.external.length === 0) section.append(makeElement(doc, 'p', { className: 'bb-pc-empty', text: 'ほかの会社に所属する人の記録はありません。' }));
+      for (const group of groups.external) {
+        section.append(makeElement(doc, 'h4', { className: 'bb-pc-company-title', text: group.company.name }));
+        section.append(peopleLedger(`${group.company.name}の人`, group.people));
+      }
+    }
+    section.append(makeElement(doc, 'h3', { className: 'bb-pc-group-title', text: '所属未確認' }));
+    section.append(peopleLedger('所属未確認の人', groups.unknown, '所属が分からない人はいません。'));
+    return section;
+  }
+
+  function companySection(payload) {
+    const section = makeElement(doc, 'section', { className: 'bb-pc-companies', attrs: { 'aria-label': '会社' } });
+    section.append(workspaceSectionTitle(doc, { title: '会社', lead: '自社を先頭に、Graphに登録された会社を並べています。' }));
+    const active = payload.companies.filter((company) => company.active);
+    section.append(workspaceLedger(doc, {
+      className: 'bb-pc-company-ledger',
+      ariaLabel: '会社の一覧',
+      columns: COMPANY_LEDGER_COLUMNS,
+      empty: '会社の記録はありません。',
+      rows: active.map((company) => ({
+        key: company.id,
+        selected: company.id === state.detail?.id,
+        onSelect: (id) => void controller.openEntity(id),
+        cells: [
+          { primary: company.id === payload.ownCompany.id ? `${company.name}（自社）` : company.name, secondary: company.id },
+          `${company.memberIds.length}人`,
+          `${company.projectIds.length}件`,
+          validityLabel(company, payload.asOf),
+        ],
+      })),
+    }));
+    return section;
+  }
+
+  function endedNote(payload) {
+    const people = payload.people.filter((person) => !person.active).length;
+    const companies = payload.companies.filter((company) => !company.active).length;
+    if (people === 0 && companies === 0) return null;
+    return makeElement(doc, 'p', {
+      className: 'bb-pc-ended',
+      text: `終わった記録（人 ${people}件、会社 ${companies}件）は一覧に出していません。「情報と関係」で見られます。`,
+    });
+  }
+
+  function workspace() {
+    const children = [workspacePageHeader(doc, {
+      crumbs: context.crumbs,
+      title: '人と会社',
+      lead: 'Graphに登録された人が、どの会社の人か、社内か社外か所属が分からないかを確かめます。',
+      source: context.source,
+    })];
+    const hostNotice = sourceNotice ? workspaceHostNotice(doc, sourceNotice) : null;
+    if (hostNotice) children.push(hostNotice);
+    const notice = graphStateNotice(doc, state.list, { onRetry: () => void controller.load() });
+    if (notice) return [...children, notice];
+    const payload = state.list.payload;
+    if (payload.absenceConfirmed) {
+      return [...children, graphHostEmptyNotice(doc, emptyNotice)
+        ?? workspaceNotice(doc, { label: '未登録', tone: 'info', role: 'status', text: 'Graphに人と会社の記録はまだありません。' })];
+    }
+    return [...children, peopleSection(payload), companySection(payload), endedNote(payload)];
+  }
+
+  // -------------------------------------------------------------------------
+  // Rail
+
+  function edgeList(edges, empty) {
+    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) {
+      const item = makeElement(doc, 'li', { className: `bb-pc-relation${edge.active ? '' : ' is-ended'}` });
+      const head = makeElement(doc, 'div', { className: 'bb-pc-relation-head' });
+      head.append(makeElement(doc, 'strong', { text: edge.counterpart.name }), badge(doc, relationLabel(edge.relation), 'muted'));
+      const source = provenanceSummary(edge.provenance);
+      item.append(
+        head,
+        makeElement(doc, 'span', { className: 'bb-pc-relation-meta', text: [
+          validityLabel(edge, asOf()),
+          textOrNull(edge.role) ? `役割: ${edge.role}` : null,
+          `出典: ${source.kind}${source.reference ? `（${source.reference}）` : ''}`,
+        ].filter(Boolean).join('　') }),
+      );
+      list.append(item);
+    }
+    return list;
+  }
+
+  function railContent() {
+    const detail = state.detail;
+    if (!detail) {
+      return [workspaceDetailEmpty(doc, { mark: '人', title: '人か会社を選んでください', text: '所属と関わるプロジェクトを、有効期間と出典つきで確かめられます。' })];
+    }
+    const notice = graphStateNotice(doc, detail, { onRetry: () => void controller.openEntity(detail.id) });
+    if (notice) return [notice];
+    const { entity, outgoing, incoming } = detail.payload;
+    const listed = state.list.state === 'ok'
+      ? state.list.payload.people.find((person) => person.id === entity.id)
+      : null;
+    const ownId = state.list.state === 'ok' ? state.list.payload.ownCompany.id : null;
+    const blocks = [workspaceRailHead(doc, {
+      kicker: entity.type === 'org' ? '会社' : '人',
+      title: entity.name,
+      sub: entity.id,
+      lead: textOrNull(entity.summary) ?? undefined,
+    })];
+    blocks.push(workspaceDefinition(doc, [
+      ...(entity.type === 'person' && listed ? [['区分', personStanding(listed, ownId)]] : []),
+      ...(entity.type === 'org' && entity.id === ownId ? [['区分', '自社']] : []),
+      ['有効期間', 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'), 'この会社のプロジェクトの記録はありません。') }));
+    } 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 === 'participates_in' || edge.relation === 'accountable_for'), '関わるプロジェクトの記録はありません。'),
+      }));
+    }
+    const fix = makeElement(doc, 'p', { className: 'bb-pc-fix' });
+    fix.append(
+      makeElement(doc, 'span', { text: '間違いは「情報と関係」で、この記録を開いて直します。' }),
+      makeElement(doc, 'a', { text: '情報と関係で開く', attrs: { href: correctionHref(entity.id) } }),
+    );
+    blocks.push(fix);
+    return blocks;
+  }
+
+  // -------------------------------------------------------------------------
+  // Controller
+
+  const controller = Object.freeze({
+    get state() {
+      return state;
+    },
+    render() {
+      layout.render(workspace(), railContent());
+    },
+    async load() {
+      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) {
+      state.detail = { id, state: 'loading' };
+      controller.render();
+      const result = await client.read(`/entities/${encodeURIComponent(id)}`);
+      if (state.detail?.id !== id) return;
+      state.detail = { id, ...normalizeEntityDetail(result) };
+      controller.render();
+    },
+  });
+
+  if (autoLoad) void controller.load();
+  else controller.render();
+  return controller;
+}
+
+function normalizeEntityDetail(result) {
+  if (result?.state !== 'ok') return result ?? INVALID;
+  const payload = result.payload;
+  if (!isEntityView(payload.entity)) return INVALID;
+  for (const key of ['outgoing', 'incoming']) {
+    if (!Array.isArray(payload[key]) || !payload[key].every(isEdgeView)) return INVALID;
+  }
+  return { state: 'ok', payload };
+}