@unson/brainbase-mcp 0.15.1 → 0.15.3

package/dist/organization-graph-web.js

@@ -0,0 +1,309 @@
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { GraphWebError, openInMemoryGraph } from './graph-web.js';
+import { canonicalEdgeId } from './canonical-graph.js';
+import { canonicalGraphOntologyRelease } from './templates.js';
+/**
+ * Ledger C1 (adopted 2026-09-24): while the owner validates the Web, the host
+ * reads the owner's organization Graph read only. The records are projected
+ * into an in-memory Graph v2 so the existing Graph screens read them through
+ * the same views as a local Graph. Nothing is written locally or remotely.
+ *
+ * Relations come only from what the organization Graph states:
+ *   - `member_of` person → project       → `participates_in` (role = role_code)
+ *   - RACI `assigned_to` raci → person, with the RACI's project:
+ *       accountable / A / lane decider / decision:*  → `accountable_for`
+ *       any other role                                → `participates_in`
+ * Retired or superseded records are counted, not drawn.
+ */
+export const ORGANIZATION_GRAPH_WEB_VERSION = 'organization-graph-web.v0';
+const ENTITY_TYPES = ['project', 'person', 'org', 'decision'];
+const FETCH_TIMEOUT_MS = 15_000;
+const CACHE_MS = 60_000;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function text(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function nameOf(type, payload) {
+    return type === 'decision'
+        ? text(payload.title) ?? text(payload.name) ?? text(payload.decision)?.slice(0, 80) ?? null
+        : text(payload.display_name) ?? text(payload.name);
+}
+function isAccountableRole(payload) {
+    const role = text(payload.role_code) ?? text(payload.role) ?? '';
+    const lane = text(payload.lane) ?? '';
+    return role === 'accountable' || role === 'A' || lane === 'decider' || role.startsWith('decision:');
+}
+/** The record that is the project of its scope: its code, or else its id, is the scope's code. */
+function isCatalogProject(record, payload) {
+    const scope = text(record.project_code);
+    return scope !== null && (text(payload.code) ?? record.id) === scope;
+}
+/**
+ * The organization's words for field values: active glossary terms that carry
+ * `payload.vocabulary = { field, value }`.  The name is the term's label, else
+ * its term, else the value itself (pure; tested).
+ */
+export function projectVocabularyTerms(records) {
+    const terms = [];
+    for (const record of records) {
+        if (!isRecord(record) || typeof record.id !== 'string' || !isRecord(record.payload))
+            continue;
+        if (record.lifecycle_status && record.lifecycle_status !== 'active')
+            continue;
+        const vocabulary = record.payload.vocabulary;
+        const field = isRecord(vocabulary) ? text(vocabulary.field) : null;
+        const value = isRecord(vocabulary) ? text(vocabulary.value) : null;
+        if (!field || !value)
+            continue;
+        terms.push({
+            id: record.id,
+            field,
+            value,
+            label: text(record.payload.label) ?? text(record.payload.term) ?? value,
+            definition: text(record.payload.definition)
+        });
+    }
+    return terms.sort((a, b) => a.id.localeCompare(b.id));
+}
+/** A project's code, parent and repositories as the organization Graph states them. */
+function projectPlacement(record, payload, catalogByCode) {
+    const scope = text(record.project_code);
+    const isCatalog = isCatalogProject(record, payload);
+    const code = text(payload.code) ?? (isCatalog ? scope : null);
+    const repositories = Array.isArray(payload.repository_roots)
+        ? payload.repository_roots.filter(isRecord).map((root) => text(root.repository)).filter((name) => name !== null)
+        : [];
+    const parentId = scope ? catalogByCode.get(scope) : undefined;
+    return {
+        ...(code ? { code } : {}),
+        ...(!isCatalog && scope ? { parent_project_code: scope } : {}),
+        ...(!isCatalog && parentId && parentId !== record.id ? { parent_project_id: parentId } : {}),
+        ...(repositories.length ? { repositories } : {})
+    };
+}
+/** Projects organization Graph records into a canonical Graph v2 (pure; tested). */
+export function projectOrganizationGraph(records, owner) {
+    const entities = [];
+    const ids = new Map();
+    let inactive = 0;
+    let unnamed = 0;
+    // The organization's catalog project for each project code (its own code or id equals its scope);
+    // other projects in that scope hang under it (the world draws them as its districts).
+    const catalogByCode = new Map();
+    for (const record of records.entities.project ?? []) {
+        if (!isRecord(record) || typeof record.id !== 'string' || (record.lifecycle_status && record.lifecycle_status !== 'active'))
+            continue;
+        const scope = text(record.project_code);
+        if (scope && isCatalogProject(record, isRecord(record.payload) ? record.payload : {}) && !catalogByCode.has(scope))
+            catalogByCode.set(scope, record.id);
+    }
+    for (const type of ENTITY_TYPES) {
+        for (const record of records.entities[type] ?? []) {
+            if (!isRecord(record) || typeof record.id !== 'string' || ids.has(record.id))
+                continue;
+            if (record.lifecycle_status && record.lifecycle_status !== 'active') {
+                inactive += 1;
+                continue;
+            }
+            const payload = isRecord(record.payload) ? record.payload : {};
+            const name = nameOf(type, payload);
+            if (!name) {
+                unnamed += 1;
+                continue;
+            }
+            const aliases = Array.isArray(payload.aliases) ? payload.aliases.filter((alias) => typeof alias === 'string' && alias.trim() !== '' && alias !== name) : [];
+            const summary = text(payload.purpose) ?? text(payload.summary) ?? text(payload.description);
+            const status = text(payload.operational_status) ?? text(payload.status);
+            entities.push({
+                id: record.id,
+                type,
+                name,
+                ...(aliases.length ? { aliases: [...new Set(aliases)] } : {}),
+                ...(summary ? { summary } : {}),
+                metadata: {
+                    source: 'organization_graph',
+                    ...(record.project_code ? { project_code: record.project_code } : {}),
+                    ...(type === 'project' && summary ? { goal: summary } : {}),
+                    ...(type === 'project' && status ? { status } : {}),
+                    ...(type === 'project' && text(payload.kind) ? { kind: text(payload.kind) } : {}),
+                    ...(type === 'project' ? projectPlacement(record, payload, catalogByCode) : {})
+                }
+            });
+            ids.set(record.id, type);
+        }
+    }
+    // One canonical relation per person, relation and project (the edge id is derived from them);
+    // the organization's role names for that pair are kept together.
+    const byKey = new Map();
+    let danglingRelations = 0;
+    const addEdge = (sourceId, fromId, relation, toId, role) => {
+        if (ids.get(fromId) !== 'person' || ids.get(toId) !== 'project') {
+            danglingRelations += 1;
+            return;
+        }
+        const key = `${fromId}|${relation}|${toId}`;
+        const existing = byKey.get(key);
+        if (existing) {
+            if (role && !existing.roles.includes(role))
+                existing.roles.push(role);
+            return;
+        }
+        byKey.set(key, {
+            edge: { id: canonicalEdgeId({ fromId, relation, toId }), fromId, relation, toId, provenance: { sourceKind: 'import', sourceId } },
+            roles: role ? [role] : []
+        });
+    };
+    for (const edge of records.memberOf) {
+        if (edge.lifecycle_status && edge.lifecycle_status !== 'active')
+            continue;
+        addEdge(edge.id, edge.from_id, 'participates_in', edge.to_id, text(edge.payload?.role_code));
+    }
+    const raci = new Map((records.entities.raci_assignment ?? []).filter((record) => !record.lifecycle_status || record.lifecycle_status === 'active').map((record) => [record.id, record]));
+    for (const edge of records.assignedTo) {
+        if (edge.lifecycle_status && edge.lifecycle_status !== 'active')
+            continue;
+        const assignment = raci.get(edge.from_id);
+        const projectId = assignment?.project_id ?? edge.project_id ?? null;
+        if (!assignment || !projectId) {
+            danglingRelations += 1;
+            continue;
+        }
+        const payload = isRecord(assignment.payload) ? assignment.payload : {};
+        const role = text(payload.role_code) ?? text(payload.role) ?? text(edge.payload?.role_code);
+        addEdge(edge.id, edge.to_id, isAccountableRole(payload) ? 'accountable_for' : 'participates_in', projectId, role);
+    }
+    const edges = [...byKey.values()].map(({ edge, roles }) => (roles.length ? { ...edge, role: roles.join('、') } : edge));
+    const ownerEntity = owner && ids.get(owner.id) === 'person' ? owner : undefined;
+    return {
+        graph: {
+            version: 2,
+            ontology: { ...canonicalGraphOntologyRelease.binding },
+            owner: ownerEntity ? { id: ownerEntity.id, ...(ownerEntity.name ? { name: ownerEntity.name } : {}) } : {},
+            entities,
+            edges
+        },
+        excluded: { inactive, unnamed, danglingRelations }
+    };
+}
+/** The owner's Brainbase server and token, read at request time (tokens rotate hourly). Never logged or returned. */
+export async function readOrganizationAccess(home = homedir()) {
+    try {
+        const config = JSON.parse(await readFile(join(home, '.brainbase', 'config.json'), 'utf8'));
+        const tokens = JSON.parse(await readFile(join(home, '.brainbase', 'tokens.json'), 'utf8'));
+        const server = isRecord(config) ? text(config.server_url) : null;
+        const token = isRecord(tokens) ? text(tokens.access_token) : null;
+        if (!server || !/^https:\/\/[^/?#@]+$/u.test(server))
+            return { reason: 'server_url_missing_or_invalid' };
+        if (!token)
+            return { reason: 'access_token_missing' };
+        return { server, token };
+    }
+    catch {
+        return { reason: 'brainbase_auth_files_unreadable' };
+    }
+}
+async function getRecords(request, access, path) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const response = await request(`${access.server}/api/info/graph/${path}`, {
+            method: 'GET',
+            headers: { Authorization: `Bearer ${access.token}`, Accept: 'application/json' },
+            redirect: 'error',
+            signal: controller.signal
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new GraphWebError('unavailable', 'organization_graph_auth_failed', `The organization Graph refused the owner's token (HTTP ${response.status}); sign in again`);
+        }
+        if (!response.ok)
+            throw new GraphWebError('unavailable', 'organization_graph_unavailable', `The organization Graph answered HTTP ${response.status} for ${path.split('?')[0]}`);
+        const body = await response.json();
+        if (!isRecord(body) || !Array.isArray(body.records))
+            throw new GraphWebError('unavailable', 'organization_graph_unavailable', 'The organization Graph response has no records');
+        return body.records;
+    }
+    catch (error) {
+        if (error instanceof GraphWebError)
+            throw error;
+        const reason = error instanceof Error && error.name === 'AbortError' ? 'timed out' : 'request failed';
+        throw new GraphWebError('unavailable', 'organization_graph_unavailable', `The organization Graph ${reason}`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * The organization Graph for the local host (C1). Reads are cached briefly and
+ * shared while in flight; a failure is reported as `unavailable`, never as an
+ * empty Graph.
+ */
+export async function createOrganizationGraphSource(options = {}) {
+    const home = options.home ?? homedir();
+    const initial = await readOrganizationAccess(home);
+    if ('reason' in initial)
+        return initial;
+    const request = options.fetch ?? fetch;
+    const now = options.now ?? (() => new Date());
+    const cacheMs = options.cacheMs ?? CACHE_MS;
+    let cached = null;
+    let inFlight = null;
+    async function load() {
+        const access = await readOrganizationAccess(home);
+        if ('reason' in access)
+            throw new GraphWebError('unavailable', 'organization_graph_not_connected', `The organization Graph cannot be read (${access.reason})`);
+        // The organization's words are read alongside; failing to read them never fails the Graph.
+        const termsRead = getRecords(request, access, 'entities?type=glossary_term&limit=500')
+            .then((records) => projectVocabularyTerms(records))
+            .catch(() => null);
+        const [project, person, org, decision, raci, memberOf, assignedTo] = await Promise.all([
+            getRecords(request, access, 'entities?type=project&limit=500'),
+            getRecords(request, access, 'entities?type=person&limit=500'),
+            getRecords(request, access, 'entities?type=org&limit=500'),
+            getRecords(request, access, 'entities?type=decision&limit=500'),
+            getRecords(request, access, 'entities?type=raci_assignment&limit=500'),
+            getRecords(request, access, 'edges?type=member_of'),
+            getRecords(request, access, 'edges?type=assigned_to')
+        ]);
+        const projection = projectOrganizationGraph({
+            entities: {
+                project: project,
+                person: person,
+                org: org,
+                decision: decision,
+                raci_assignment: raci
+            },
+            memberOf: memberOf,
+            assignedTo: assignedTo
+        });
+        const source = { dataDir: null, graphFormat: 2, authority: 'organization_graph', server: access.server, readAt: now().toISOString() };
+        return { reader: openInMemoryGraph(projection.graph, source), graph: projection.graph, terms: await termsRead };
+    }
+    async function current() {
+        const at = now().getTime();
+        if (cached && at - cached.at < cacheMs)
+            return cached.loaded;
+        inFlight ??= load().then((loaded) => {
+            cached = { at: now().getTime(), loaded };
+            return loaded;
+        }).finally(() => {
+            inFlight = null;
+        });
+        return inFlight;
+    }
+    return {
+        server: initial.server,
+        async read() {
+            return (await current()).reader;
+        },
+        async readGraphFile() {
+            return (await current()).graph;
+        },
+        async readVocabularyTerms() {
+            return (await current()).terms;
+        }
+    };
+}

package/dist/value-proof-review-http.d.ts

@@ -1,4 +1,5 @@
 import { type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+import { JudgmentValueProofJournalCache, type JudgmentValueProofReviewHome } from './judgment-value-proof-review.js';
 export declare const VALUE_PROOF_REVIEW_HTTP_VERSION: "value-proof-review-http.v1";
 export declare const VALUE_PROOF_REVIEW_TOKEN_HEADER = "x-brainbase-review-token";
 export interface ValueProofReviewHttpOptions {
@@ -10,8 +11,12 @@ export interface ValueProofReviewHttpOptions {
     readonly token: string;
     readonly basePath?: string;
     readonly now?: () => Date;
+    /** One cache per journal; a host passes the one it shares with other readers of the same journal. */
+    readonly journalCache?: JudgmentValueProofJournalCache;
 }
 export type ValueProofReviewHttpHandler = (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
+/** The home as the browser receives it: no local paths beyond the journal root. */
+export declare function publicHome(home: JudgmentValueProofReviewHome): unknown;
 export declare function createValueProofReviewHttpHandler(options: ValueProofReviewHttpOptions): ValueProofReviewHttpHandler;
 export interface ValueProofReviewHostOptions extends Omit<ValueProofReviewHttpOptions, 'token'> {
     readonly token?: string;

package/dist/value-proof-review-http.js

@@ -3,7 +3,7 @@ import { readFile } from 'node:fs/promises';
 import { createServer } from 'node:http';
 import { join, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { applyJudgmentValueProofFeedback, buildJudgmentValueProofReviewHome, classifyJudgmentValueProof, JudgmentValueProofAnswerConflictError, readJudgmentValueProofAnswers, readJudgmentValueProofFeedback, readJudgmentValueProofJournal, recordJudgmentValueProofAnswer, recordJudgmentValueProofFeedback } from './judgment-value-proof-review.js';
+import { applyJudgmentValueProofFeedback, buildJudgmentValueProofReviewHome, classifyJudgmentValueProof, JudgmentValueProofAnswerConflictError, JudgmentValueProofJournalCache, readJudgmentValueProofAnswers, readJudgmentValueProofFeedback, readJudgmentValueProofJournal, recordJudgmentValueProofAnswer, recordJudgmentValueProofFeedback } from './judgment-value-proof-review.js';
 import { assertSameOrigin, isLoopbackHost, LOCAL_WEB_CONTENT_SECURITY_POLICY, LocalWebHttpError as HttpError, readJsonObjectBody, requestUrl, tokenMatches, writeHttpError as writeError, writeJson } from './local-web-security.js';
 export const VALUE_PROOF_REVIEW_HTTP_VERSION = 'value-proof-review-http.v1';
 export const VALUE_PROOF_REVIEW_TOKEN_HEADER = 'x-brainbase-review-token';
@@ -17,13 +17,18 @@ const UI_FILES = Object.freeze({
     '/ui/value-proof-review.js': { file: 'value-proof-review.js', type: 'text/javascript; charset=utf-8' },
     '/ui/value-proof-review.css': { file: 'value-proof-review.css', type: 'text/css; charset=utf-8' }
 });
-function publicHome(home) {
+/** The home as the browser receives it: no local paths beyond the journal root. */
+export function publicHome(home) {
     if (home.status === 'unavailable')
         return home;
     const strip = (items) => Object.fromEntries(Object.entries(items).map(([section, list]) => [
         section,
-        list.map(({ section: itemSection, proof, feedback_history, answer }) => ({
-            section: itemSection, proof, feedback_history, answer: answer ?? null
+        list.map(({ section: itemSection, proof, feedback_history, answer, conversation_moved_on_at }) => ({
+            section: itemSection,
+            proof,
+            feedback_history,
+            answer: answer ?? null,
+            conversation_moved_on_at: conversation_moved_on_at ?? null
         }))
     ]));
     return {
@@ -44,8 +49,11 @@ export function createValueProofReviewHttpHandler(options) {
     }
     const basePath = (options.basePath ?? DEFAULT_BASE_PATH).replace(/\/+$/u, '');
     const now = options.now ?? (() => new Date());
+    // A large journal has thousands of conversation folders; only the ones that changed are listed again.
+    const journalCache = options.journalCache ?? new JudgmentValueProofJournalCache();
+    const readJournal = () => readJudgmentValueProofJournal({ root: options.journalRoot, cache: journalCache });
     async function readHome() {
-        const journal = await readJudgmentValueProofJournal({ root: options.journalRoot });
+        const journal = await readJournal();
         if (journal.status !== 'available')
             return buildJudgmentValueProofReviewHome(journal, [], { now: now() });
         const [feedback, answers] = await Promise.all([
@@ -65,7 +73,7 @@ export function createValueProofReviewHttpHandler(options) {
         const body = await authorizedBody(request);
         const intentId = typeof body.intent_id === 'string' ? body.intent_id : '';
         const attemptId = typeof body.decision_attempt_id === 'string' ? body.decision_attempt_id : '';
-        const journal = await readJudgmentValueProofJournal({ root: options.journalRoot });
+        const journal = await readJournal();
         if (journal.status === 'unavailable') {
             throw new HttpError(503, 'judgment_journal_unavailable', journal.reason);
         }
@@ -78,6 +86,10 @@ export function createValueProofReviewHttpHandler(options) {
         if (classifyJudgmentValueProof(proof) !== 'needs_human' || !proof.human_decision) {
             throw new HttpError(422, 'not_answerable', 'This judgment is not waiting for the owner');
         }
+        if (entry.conversation_moved_on_at) {
+            // The owner answered in that conversation or moved on; answering here could replay a settled question.
+            throw new HttpError(422, 'conversation_moved_on', 'The conversation moved on after this question; continue it there');
+        }
         try {
             const result = await recordJudgmentValueProofAnswer({
                 dataDir: options.dataDir,
@@ -108,7 +120,7 @@ export function createValueProofReviewHttpHandler(options) {
         const body = await authorizedBody(request);
         const intentId = typeof body.intent_id === 'string' ? body.intent_id : '';
         const attemptId = typeof body.decision_attempt_id === 'string' ? body.decision_attempt_id : '';
-        const journal = await readJudgmentValueProofJournal({ root: options.journalRoot });
+        const journal = await readJournal();
         if (journal.status === 'unavailable') {
             throw new HttpError(503, 'judgment_journal_unavailable', journal.reason);
         }

package/dist/world-extension.d.ts

@@ -0,0 +1,183 @@
+import { JudgmentValueProofJournalCache } from './judgment-value-proof-review.js';
+import { type GraphVocabularyTerm, type LocalWebExtension, type LocalWebModuleContext } from './local-web-host.js';
+import type { GraphFileV2 } from './types.js';
+/**
+ * World view (ledger P17, adopted 2026-10-04): the home's upper layer.
+ *
+ * The world is a read-only projection.  Businesses come from the same Graph
+ * the other screens read (the organization Graph under C1, else the local
+ * Graph); judgments come from the existing value-proof home on the browser
+ * side.  Nothing here writes, and a failure to read is reported as a state,
+ * never as zero businesses.
+ */
+export declare const WORLD_EXTENSION_ID = "world";
+export declare const WORLD_EXTENSION_VERSION: "world-extension.v1";
+declare const LIFECYCLE_PHASES: readonly ["active", "maintenance", "finished", "concept"];
+/** How a status looks in the world: lit, muted, an empty lot, or a scaffold. */
+export type WorldLifecyclePhase = (typeof LIFECYCLE_PHASES)[number];
+declare const BUILDING_FORMS: readonly ["tower", "hall", "dome", "office"];
+export type WorldBuildingForm = (typeof BUILDING_FORMS)[number];
+/**
+ * The words of the owner's Graph, given by the host (`--world-vocabulary`):
+ * the project kinds in display order with their label and building, and the
+ * statuses with their label and lifecycle phase.  None of it is required: a
+ * kind the vocabulary does not name is drawn under its own value, and a status
+ * it does not name keeps its value and the active look.
+ */
+export interface WorldVocabularyConfig {
+    readonly kinds?: Readonly<Record<string, {
+        readonly label?: string;
+        readonly form?: WorldBuildingForm;
+        readonly color?: string;
+    }>>;
+    readonly statuses?: Readonly<Record<string, {
+        readonly label?: string;
+        readonly phase?: WorldLifecyclePhase;
+    }>>;
+}
+export interface WorldVocabulary {
+    readonly kinds: readonly {
+        readonly key: string | null;
+        readonly label: string;
+        /** Where the label came from: the organization's term, the host's vocabulary file, or the value itself. */
+        readonly label_source: 'graph' | 'config' | 'value';
+        readonly definition: string | null;
+        readonly form: WorldBuildingForm;
+        readonly color: string;
+        readonly configured: boolean;
+    }[];
+    /** Whether the organization's terms were read: `unavailable` when they could not be, `none` without an organization Graph. */
+    readonly terms: 'read' | 'unavailable' | 'none';
+    readonly statuses: readonly {
+        readonly key: string;
+        readonly label: string;
+        readonly phase: WorldLifecyclePhase;
+    }[];
+}
+export interface WorldEngagement {
+    readonly id: string;
+    /** The project's own code in its Graph (`metadata.code`), or null when it has none. */
+    readonly code: string | null;
+    readonly name: string;
+    readonly summary: string | null;
+    readonly status: string | null;
+}
+export interface WorldBusiness {
+    readonly id: string;
+    /** The project's code in its Graph (`metadata.code`), else its id; judgments are placed by it. */
+    readonly code: string;
+    readonly name: string;
+    /** `metadata.kind`, or null when the Graph does not classify the project. */
+    readonly kind: string | null;
+    readonly purpose: string | null;
+    readonly status: string | null;
+    /** Repository names the Graph registers for this project (`metadata.repositories`). */
+    readonly repositories: readonly string[];
+    readonly engagements: readonly WorldEngagement[];
+}
+export interface WorldBusinessProjection {
+    readonly businesses: readonly WorldBusiness[];
+    /** Projects that name a parent the Graph does not hold (kept visible as a count, never dropped silently). */
+    readonly unplaced: readonly WorldEngagement[];
+    readonly excluded: {
+        readonly inactive: number;
+    };
+}
+export type WorldSource = {
+    readonly authority: 'organization_graph';
+    readonly server: string;
+} | {
+    readonly authority: 'local';
+    readonly dataDir: string;
+};
+export type WorldBusinessesResponse = ({
+    readonly status: 'ok';
+    readonly version: typeof WORLD_EXTENSION_VERSION;
+    readonly source: WorldSource;
+    readonly as_of: string;
+    readonly vocabulary: WorldVocabulary;
+} & WorldBusinessProjection) | {
+    readonly status: 'not_initialized' | 'migration_required' | 'unavailable';
+    readonly version: typeof WORLD_EXTENSION_VERSION;
+    readonly reason: string;
+};
+/**
+ * The projects of a Graph v2 → cities (top-level projects) and their districts
+ * (projects whose `metadata.parent_project_id` names another project).  A
+ * project whose declared parent (`metadata.parent_project_code`) is not in the
+ * Graph is counted as unplaced.  Projects past `validTo` are counted, not drawn.
+ * Nothing here knows any organization's words: kinds and statuses are the
+ * Graph's own values.
+ */
+export declare function projectWorldFromGraph(graph: Pick<GraphFileV2, 'entities'>, now?: Date): WorldBusinessProjection;
+/**
+ * The vocabulary the world draws with: the host's kinds in their order, then
+ * kinds the Graph uses that the host did not name (under their own value),
+ * then unclassified projects; statuses are the common lifecycle words with the
+ * host's on top.
+ */
+export declare function resolveWorldVocabulary(config: WorldVocabularyConfig | undefined, businesses: readonly WorldBusiness[], terms?: readonly GraphVocabularyTerm[] | null | undefined): WorldVocabulary;
+/** Reads and checks a vocabulary file; an invalid file is an error, never silently ignored. */
+export declare function readWorldVocabulary(path: string): Promise<WorldVocabularyConfig>;
+/**
+ * The businesses from the same Graph the other screens read: the organization
+ * Graph when the host reads it (C1), else the local Graph.  A Graph that cannot
+ * be read is a state with its reason, never zero businesses.
+ */
+export declare function readWorldBusinesses(context: Pick<LocalWebModuleContext, 'dataDir' | 'organizationGraph'>, options?: {
+    readonly vocabulary?: WorldVocabularyConfig;
+    readonly now?: () => Date;
+}): Promise<WorldBusinessesResponse>;
+/**
+ * The world of an organization from the project and glossary-term records its Graph API returns, for an
+ * organization web that hosts the same world screen (P16).  Pure: the caller reads the records with the
+ * member's own grants, so the world shows only what that member may read.
+ */
+export declare function projectOrganizationWorld(records: {
+    readonly projects: readonly unknown[];
+    readonly glossaryTerms?: readonly unknown[];
+}, options: {
+    readonly server: string;
+    readonly vocabulary?: WorldVocabularyConfig;
+    readonly now?: Date;
+}): WorldBusinessesResponse;
+export interface WorldJudgmentPlace {
+    readonly decision_attempt_id: string;
+    /** Repository the judgment Host recorded for the turn (`turn-input.json` project_code); null when unrecorded. */
+    readonly workspace: string | null;
+}
+/**
+ * Reads, for every saved value proof in the judgment journal, the repository
+ * the Host recorded for that turn. The journal is listed through the host's
+ * shared listing cache (the same one as the 今日 list), so only folders that
+ * changed are listed again; turn inputs are never rewritten by the Host, so
+ * each is read once. A journal that cannot be read is `unavailable`, never
+ * an empty list.
+ */
+export declare function readJudgmentPlaces(journalRoot: string, options?: {
+    readonly cache?: JudgmentValueProofJournalCache;
+    readonly workspaces?: Map<string, string | null>;
+}): Promise<{
+    readonly status: 'available' | 'unavailable';
+    readonly places: readonly WorldJudgmentPlace[];
+    readonly reason?: string;
+}>;
+/**
+ * The judgments of one organization, for a world drawn from that organization's Graph.  A judgment
+ * belongs to the organization only when the repository it was worked in is one of the organization's
+ * businesses (a registered repository or the business code, the same rule as the world's placement).
+ * Every other judgment (another company's work, or one whose repository was not recorded) is withheld:
+ * only their count leaves the host, never their questions or repositories.
+ */
+export declare function readOrganizationJudgments(context: Pick<LocalWebModuleContext, 'journalRoot' | 'journalCache' | 'dataDir' | 'now'>, businesses: readonly Pick<WorldBusiness, 'code' | 'repositories'>[], workspaces?: Map<string, string | null>): Promise<{
+    readonly status: 'available' | 'unavailable';
+    readonly scope: 'organization';
+    readonly withheld: number;
+    readonly places: readonly WorldJudgmentPlace[];
+    readonly home: unknown;
+    readonly reason?: string;
+}>;
+export declare function createWorldExtension(options?: {
+    readonly vocabulary?: WorldVocabularyConfig;
+}): LocalWebExtension;
+export {};