@unson/brainbase-mcp 0.15.0 → 0.15.2

package/dist/local-web-host.js

@@ -8,7 +8,7 @@ import { foundationCatalogOrEmpty, foundationKey } from './foundation-catalog.js
 import { createFoundationHttpRouter, createObjectiveFoundationRoute, FOUNDATION_HTTP_PREFIX, FOUNDATION_OBJECTIVE_ROUTE_PREFIX } from './foundation-http.js';
 import { createFoundationRevisionStore, FoundationStoreError } from './foundation-store.js';
 import { createGraphWebHttpHandler } from './graph-web-http.js';
-import { defaultJudgmentJournalRoot } from './judgment-value-proof-review.js';
+import { defaultJudgmentJournalRoot, JudgmentValueProofJournalCache } from './judgment-value-proof-review.js';
 import { nodeRequestToFetch, writeFetchResponse } from './local-web-fetch-bridge.js';
 import { assertSameOrigin, isLoopbackHost, LOCAL_WEB_CONTENT_SECURITY_POLICY, LocalWebHttpError, readJsonObjectBody, requestUrl, tokenMatches, writeHttpError, writeJson } from './local-web-security.js';
 import { resolveDataDir } from './paths.js';
@@ -138,7 +138,9 @@ export function createLocalStatusModule(context) {
                 writeJson(response, 405, { error: { code: 'method_not_allowed', message: 'Use GET' } });
                 return true;
             }
-            const graph = await readLocalGraphState(context.dataDir);
+            const local = await readLocalGraphState(context.dataDir);
+            // Under C1 the Graph screens read the organization Graph, so they are not gated on the local file.
+            const graph = context.organizationGraph ? { ...local, status: 'ready', format: 'v2', message: undefined } : local;
             writeJson(response, 200, {
                 version: LOCAL_WEB_HOST_VERSION,
                 data_dir: context.dataDir,
@@ -149,8 +151,14 @@ export function createLocalStatusModule(context) {
                     ...(graph.message ? { message: graph.message } : {}),
                     commands: graphCommands(graph, context.dataDir)
                 },
-                // This host reads only the local data directory (C1 is not connected here).
-                organization_graph: { status: 'not_connected' }
+                organization_graph: context.organizationGraph
+                    ? {
+                        status: 'connected',
+                        server: context.organizationGraph.server,
+                        mode: 'read_only',
+                        ...(context.organizationGraph.webUrl ? { web_url: context.organizationGraph.webUrl } : {})
+                    }
+                    : { status: 'not_connected' }
             });
             return true;
         }
@@ -161,7 +169,8 @@ export function createValueProofModule(context) {
         journalRoot: context.journalRoot,
         dataDir: context.dataDir,
         token: context.token,
-        now: context.now
+        now: context.now,
+        journalCache: context.journalCache
     });
     return {
         id: 'value-proofs',
@@ -674,6 +683,7 @@ export function createGraphWebModule(context) {
         dataDir: context.dataDir,
         basePath: LOCAL_WEB_GRAPH_PREFIX,
         now: context.now,
+        ...(context.organizationGraph ? { readGraph: context.organizationGraph.read } : {}),
         assertWriteAllowed(request) {
             if (isTrustedLocalWrite(request, context.token))
                 return;
@@ -732,6 +742,8 @@ ${stylesheets.map((path) => `<link rel="stylesheet" href="${escapeAttribute(path
 }
 function bootstrapJs(extensions) {
     const imports = extensions.map((extension, index) => `import { screen as extensionScreen${index} } from '/ui/extensions/${extension.id}/${extension.screenEntry}';`).join('\n');
+    const leading = extensions.flatMap((extension, index) => (extension.navPosition === 'first' ? [`extensionScreen${index}`] : [])).join(', ');
+    const trailing = extensions.flatMap((extension, index) => (extension.navPosition === 'first' ? [] : [`extensionScreen${index}`])).join(', ');
     const screens = extensions.map((_, index) => `extensionScreen${index}`).join(', ');
     const ids = JSON.stringify(extensions.map((extension) => extension.id));
     return `import { createLocalWebShell, LOCAL_WEB_SCREENS } from '/ui/local-web-shell.js';
@@ -749,7 +761,7 @@ const shell = createLocalWebShell({
   root: document.getElementById('brainbase-local-web'),
   token: meta('brainbase-web-token'),
   initialScreen: screenFromHash(),
-  screens: [...LOCAL_WEB_SCREENS, ...extensionScreens]
+  screens: ${leading ? `[${leading}, ...LOCAL_WEB_SCREENS${trailing ? `, ${trailing}` : ''}]` : '[...LOCAL_WEB_SCREENS, ...extensionScreens]'}
 });
 addEventListener('hashchange', () => shell.show(screenFromHash()));
 `;
@@ -765,7 +777,14 @@ export function createLocalWebHost(options = {}) {
     const dataDir = resolveDataDir(options.dataDir);
     const journalRoot = options.journalRoot ?? defaultJudgmentJournalRoot(dataDir);
     const uiDir = options.uiDir ?? fileURLToPath(new URL('../ui/', import.meta.url));
-    const context = { dataDir, journalRoot, token, now: options.now ?? (() => new Date()) };
+    const context = {
+        dataDir,
+        journalRoot,
+        token,
+        now: options.now ?? (() => new Date()),
+        journalCache: new JudgmentValueProofJournalCache(),
+        ...(options.organizationGraph ? { organizationGraph: options.organizationGraph } : {})
+    };
     const modules = defaultLocalWebModules(context);
     const extensions = [...options.extensions ?? []];
     const extensionModules = [];

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

@@ -0,0 +1,74 @@
+import type { LocalWebOrganizationGraph } from './local-web-host.js';
+import type { CanonicalEntityKind, GraphFileV2 } from './types.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 declare const ORGANIZATION_GRAPH_WEB_VERSION: "organization-graph-web.v0";
+interface OrganizationRecord {
+    id: string;
+    entity_type?: string;
+    project_id?: string | null;
+    project_code?: string | null;
+    lifecycle_status?: string;
+    payload?: Record<string, unknown>;
+}
+interface OrganizationEdge {
+    id: string;
+    from_id: string;
+    to_id: string;
+    rel_type: string;
+    project_id?: string | null;
+    lifecycle_status?: string;
+    payload?: Record<string, unknown> | null;
+}
+export interface OrganizationGraphRecords {
+    readonly entities: Readonly<Record<CanonicalEntityKind | 'raci_assignment', readonly OrganizationRecord[]>>;
+    readonly memberOf: readonly OrganizationEdge[];
+    readonly assignedTo: readonly OrganizationEdge[];
+}
+export interface OrganizationGraphProjection {
+    readonly graph: GraphFileV2;
+    readonly excluded: {
+        readonly inactive: number;
+        readonly unnamed: number;
+        readonly danglingRelations: number;
+    };
+}
+/** Projects organization Graph records into a canonical Graph v2 (pure; tested). */
+export declare function projectOrganizationGraph(records: OrganizationGraphRecords, owner?: {
+    id: string;
+    name?: string;
+}): OrganizationGraphProjection;
+interface OrganizationAccess {
+    readonly server: string;
+    readonly token: string;
+}
+/** The owner's Brainbase server and token, read at request time (tokens rotate hourly). Never logged or returned. */
+export declare function readOrganizationAccess(home?: string): Promise<OrganizationAccess | {
+    readonly reason: string;
+}>;
+export interface OrganizationGraphSourceOptions {
+    readonly home?: string;
+    readonly fetch?: typeof fetch;
+    readonly now?: () => Date;
+    readonly cacheMs?: number;
+}
+/**
+ * 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 declare function createOrganizationGraphSource(options?: OrganizationGraphSourceOptions): Promise<LocalWebOrganizationGraph | {
+    readonly reason: string;
+}>;
+export {};

package/dist/organization-graph-web.js

@@ -0,0 +1,275 @@
+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;
+}
+/** 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})`);
+        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 };
+    }
+    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;
+        }
+    };
+}

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

@@ -1,15 +1,18 @@
 import { type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+import { JudgmentValueProofJournalCache } 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 {
     /** Judgment journal root. Defaults to `~/.brainbase/personal-os/judgment-journal`. */
     readonly journalRoot?: string;
-    /** Personal OS data directory that stores owner feedback. */
+    /** Personal OS data directory that stores owner feedback and answers. */
     readonly dataDir?: string;
     /** Required on mutating requests. */
     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>;
 export declare function createValueProofReviewHttpHandler(options: ValueProofReviewHttpOptions): ValueProofReviewHttpHandler;

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 { buildJudgmentValueProofReviewHome, readJudgmentValueProofFeedback, readJudgmentValueProofJournal, 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';
@@ -22,13 +22,21 @@ function publicHome(home) {
         return home;
     const strip = (items) => Object.fromEntries(Object.entries(items).map(([section, list]) => [
         section,
-        list.map(({ section: itemSection, proof, feedback_history }) => ({ section: itemSection, proof, feedback_history }))
+        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 {
         status: home.status,
         root: home.root,
         coverage: home.coverage,
         sections: strip(home.sections),
+        // The screen offers answering only when the host says it records answers (and never resumes work).
+        capabilities: { answer: 'record_only' },
         // Holds only decision IDs, counts and states; no local paths.
         delegation_map: home.delegation_map,
         rejected: home.rejected.map((entry) => ({ file: relative(home.root, entry.file), reason: entry.reason }))
@@ -40,22 +48,78 @@ 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 feedback = journal.status === 'available'
-            ? await readJudgmentValueProofFeedback({ dataDir: options.dataDir })
-            : [];
-        return buildJudgmentValueProofReviewHome(journal, feedback, { now: now() });
+        const journal = await readJournal();
+        if (journal.status !== 'available')
+            return buildJudgmentValueProofReviewHome(journal, [], { now: now() });
+        const [feedback, answers] = await Promise.all([
+            readJudgmentValueProofFeedback({ dataDir: options.dataDir }),
+            readJudgmentValueProofAnswers({ dataDir: options.dataDir })
+        ]);
+        return buildJudgmentValueProofReviewHome(journal, feedback, { now: now(), answers });
     }
-    async function recordFeedback(request) {
+    async function authorizedBody(request) {
         assertSameOrigin(request);
         if (!tokenMatches(options.token, request.headers[VALUE_PROOF_REVIEW_TOKEN_HEADER])) {
             throw new HttpError(403, 'review_token_required', 'A valid review token is required');
         }
-        const body = await readJsonObjectBody(request, MAX_BODY_BYTES);
+        return readJsonObjectBody(request, MAX_BODY_BYTES);
+    }
+    async function recordAnswer(request) {
+        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 readJournal();
+        if (journal.status === 'unavailable') {
+            throw new HttpError(503, 'judgment_journal_unavailable', journal.reason);
+        }
+        const entry = journal.entries.find((candidate) => candidate.proof.intent_id === intentId
+            && candidate.proof.decision_attempt_id === attemptId);
+        if (!entry)
+            throw new HttpError(404, 'value_proof_not_found', 'No saved value proof matches this decision');
+        // Classify the judgment as the home shows it, with the owner's evaluation applied.
+        const { proof } = applyJudgmentValueProofFeedback(entry.proof, await readJudgmentValueProofFeedback({ dataDir: options.dataDir }));
+        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,
+                proof,
+                kind: body.kind,
+                selected_option_id: typeof body.selected_option_id === 'string' ? body.selected_option_id : null,
+                confirmed: body.confirmed === true,
+                now: now()
+            });
+            return { statusCode: result.created ? 201 : 200, body: result };
+        }
+        catch (error) {
+            if (error instanceof JudgmentValueProofAnswerConflictError) {
+                return {
+                    statusCode: 409,
+                    body: {
+                        error: { code: 'answer_conflict', message: 'A different answer is already recorded for this judgment' },
+                        existing: error.existing
+                    }
+                };
+            }
+            if (error instanceof TypeError)
+                throw new HttpError(400, 'invalid_answer', error.message);
+            throw error;
+        }
+    }
+    async function recordFeedback(request) {
+        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);
         }
@@ -83,7 +147,7 @@ export function createValueProofReviewHttpHandler(options) {
     }
     return async (request, response) => {
         const path = requestUrl(request).pathname;
-        if (path !== `${basePath}/home` && path !== `${basePath}/feedback`)
+        if (path !== `${basePath}/home` && path !== `${basePath}/feedback` && path !== `${basePath}/answers`)
             return false;
         try {
             if (path === `${basePath}/home`) {
@@ -94,7 +158,7 @@ export function createValueProofReviewHttpHandler(options) {
             }
             if (request.method !== 'POST')
                 throw new HttpError(405, 'method_not_allowed', 'Use POST');
-            const result = await recordFeedback(request);
+            const result = path === `${basePath}/answers` ? await recordAnswer(request) : await recordFeedback(request);
             writeJson(response, result.statusCode, result.body);
         }
         catch (error) {