@unson/brainbase-mcp 0.23.1 → 0.23.3

package/dist/knowledge-continuation.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { KNOWLEDGE_LOOKUP_ALLOWED_FIELD_ROOTS, validateKnowledgeLookupFields, validateKnowledgeLookupFinish, } from './knowledge-lookup.js';
 const TERMINAL = new Set(['satisfied', 'unresolved', 'needs_user_input', 'cancelled']);
 const ACTION_KINDS = new Set(['search', 'read', 'follow_relation', 'finish']);
-const KNOWLEDGE_LOOKUP_FIELD_GUIDANCE = `required_fieldsは自然文ではなく公開field pathを指定してください（例: content, body, statement, markdown, summary, name, environments.production.endpoint）。許可root: ${[...KNOWLEDGE_LOOKUP_ALLOWED_FIELD_ROOTS].join(', ')}`;
+const KNOWLEDGE_LOOKUP_FIELD_GUIDANCE = `required_fieldsは自然文ではなく公開field pathを指定してください。Graph本文はcontentを使い、bodyはソース投影が明示的に公開する場合だけ指定してください（例: content, body, statement, markdown, summary, name, environments.production.endpoint）。許可root: ${[...KNOWLEDGE_LOOKUP_ALLOWED_FIELD_ROOTS].join(', ')}`;
 const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 const canonical = (value) => JSON.stringify(value, (_key, item) => record(item)
     ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)))

package/dist/knowledge-lookup.js

@@ -678,7 +678,7 @@ export const knowledgeLookupTools = [{
                     type: 'array',
                     minItems: 1,
                     maxItems: MAX_FIELDS,
-                    description: 'Public field paths only; use roots such as content, body, statement, markdown, summary, name, or environments.production.endpoint.',
+                    description: 'Public field paths only; for Graph text use content. Use body only when the source projection explicitly exposes a body field. Other roots include statement, markdown, summary, name, or environments.production.endpoint.',
                     items: { type: 'string', minLength: 1, maxLength: MAX_FIELD_LENGTH },
                 },
                 known_entity_id: { type: 'string', minLength: 1, maxLength: 1_000 },

package/dist/local-web-host.d.ts

@@ -1,5 +1,6 @@
 import { type IncomingMessage, type Server, type ServerResponse } from 'node:http';
 import { type ObjectiveDefinitionBuilder } from './foundation-http.js';
+import type { JudgmentHistoryEntrypoint } from './judgment-history.js';
 import { JudgmentValueProofJournalCache } from './judgment-value-proof-review.js';
 import { type MeetingMinutesLineageCorrectionHook } from './meeting-minutes-lineage-lifecycle.js';
 import type { MinutesLineageActor, MinutesLineageStore } from './meeting-minutes-lineage.js';
@@ -25,6 +26,7 @@ export declare const LOCAL_WEB_STATUS_PATH = "/api/local/status";
 export declare const LOCAL_WEB_WORLD_MODEL_PREFIX = "/api/world-model";
 export declare const LOCAL_WEB_GRAPH_PREFIX = "/api/graph";
 export declare const LOCAL_WEB_MEETING_MINUTES_PREFIX = "/api/meeting-minutes";
+export declare const LOCAL_WEB_JUDGMENT_HISTORY_PREFIX: "/api/judgment-history";
 /**
  * An Objective is a few KB of text and criteria.  64 KiB leaves room for long
  * Japanese text (about 20k characters) while keeping a loopback request that
@@ -43,6 +45,8 @@ export interface LocalGraphState {
 export interface LocalWebModuleContext {
     readonly dataDir: string;
     readonly journalRoot: string;
+    /** Explicit source label for this host's configured owner journal. */
+    readonly judgmentHistoryEntrypoint?: JudgmentHistoryEntrypoint;
     readonly token: string;
     readonly now: () => Date;
     /** The host's one listing cache for the judgment journal, shared by every screen that reads it. */
@@ -98,6 +102,8 @@ export interface LocalWebHostOptions {
     readonly dataDir?: string;
     /** Judgment journal root. Defaults to the journal inside the data directory. */
     readonly journalRoot?: string;
+    /** Source label for the owner journal; defaults to the Codex local host. */
+    readonly judgmentHistoryEntrypoint?: JudgmentHistoryEntrypoint;
     readonly token?: string;
     /** Directory containing the packaged `ui/` files. */
     readonly uiDir?: string;
@@ -153,6 +159,8 @@ export declare function isTrustedLocalWrite(request: IncomingMessage, token: str
 /** Reads the Graph format and owner without creating or migrating anything. */
 export declare function readLocalGraphState(dataDir: string): Promise<LocalGraphState>;
 export declare function createLocalStatusModule(context: LocalWebModuleContext): LocalWebModule;
+/** Common normal judgment history projection over the configured owner journal. */
+export declare function createJudgmentHistoryModule(context: LocalWebModuleContext): LocalWebModule;
 export declare function createValueProofModule(context: LocalWebModuleContext): LocalWebModule;
 /** Native meeting minutes use the host's authenticated local single-owner principal. */
 export declare function createMeetingMinutesModule(context: LocalWebModuleContext): LocalWebModule;

package/dist/local-web-host.js

@@ -8,6 +8,8 @@ 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 { createJudgmentHistoryHttpHandler, JUDGMENT_HISTORY_HTTP_PREFIX } from './judgment-history-http.js';
+import { createJudgmentHistoryReader, createLocalJudgmentHistoryFeedbackWriter, createLocalJudgmentHistorySource } from './judgment-history.js';
 import { defaultJudgmentJournalRoot, JudgmentValueProofJournalCache } from './judgment-value-proof-review.js';
 import { createMeetingMinutesHttpHandler } from './meeting-minutes-http.js';
 import { createMeetingMinutesLineageHttpHandler } from './meeting-minutes-lineage-http.js';
@@ -41,6 +43,7 @@ export const LOCAL_WEB_STATUS_PATH = '/api/local/status';
 export const LOCAL_WEB_WORLD_MODEL_PREFIX = '/api/world-model';
 export const LOCAL_WEB_GRAPH_PREFIX = '/api/graph';
 export const LOCAL_WEB_MEETING_MINUTES_PREFIX = '/api/meeting-minutes';
+export const LOCAL_WEB_JUDGMENT_HISTORY_PREFIX = JUDGMENT_HISTORY_HTTP_PREFIX;
 /**
  * An Objective is a few KB of text and criteria.  64 KiB leaves room for long
  * Japanese text (about 20k characters) while keeping a loopback request that
@@ -162,6 +165,37 @@ export function createLocalStatusModule(context) {
         }
     };
 }
+/** Common normal judgment history projection over the configured owner journal. */
+export function createJudgmentHistoryModule(context) {
+    const source = createLocalJudgmentHistorySource({
+        root: context.journalRoot,
+        entrypoint: context.judgmentHistoryEntrypoint ?? 'codex'
+    });
+    const reader = createJudgmentHistoryReader({
+        source,
+        now: context.now
+    });
+    const writeFeedback = createLocalJudgmentHistoryFeedbackWriter({
+        root: context.journalRoot,
+        reader,
+        now: context.now
+    });
+    return {
+        id: 'judgment-history',
+        uiFiles: [],
+        handle: createJudgmentHistoryHttpHandler({
+            reader,
+            basePath: LOCAL_WEB_JUDGMENT_HISTORY_PREFIX,
+            writeFeedback,
+            assertWriteAllowed(request) {
+                if (isTrustedLocalWrite(request, context.token))
+                    return;
+                throw rejectUntrustedWrite(request, context.token)
+                    ?? new LocalWebHttpError(403, 'web_token_required', 'A valid launch token is required');
+            }
+        })
+    };
+}
 export function createValueProofModule(context) {
     const handler = createValueProofReviewHttpHandler({
         journalRoot: context.journalRoot,
@@ -857,6 +891,7 @@ export function createGraphWebModule(context) {
 export function defaultLocalWebModules(context) {
     return [
         createLocalStatusModule(context),
+        createJudgmentHistoryModule(context),
         createValueProofModule(context),
         createMeetingMinutesModule(context),
         createObjectiveFoundationModule(context),
@@ -934,6 +969,7 @@ export function createLocalWebHost(options = {}) {
     const context = {
         dataDir,
         journalRoot,
+        judgmentHistoryEntrypoint: options.judgmentHistoryEntrypoint ?? 'codex',
         token,
         now,
         journalCache: new JudgmentValueProofJournalCache(),

package/dist/problem-selection.d.ts

@@ -10,7 +10,8 @@
  */
 import type { FoundationAcl, FoundationRevision, FoundationScope } from './ontology-foundation.js';
 import type { ProblemCandidateRecord, ProblemCandidateStore, ProblemCandidateStoreContext } from './problem-candidates.js';
-import { type JudgmentDAGCompositionDefinition, type JudgmentDAGCompositionRunRequest, type JudgmentDAGProblemSnapshotReference } from './judgment-dag-composition.js';
+import { type JudgmentDAGCompositionDefinition, type JudgmentDAGCompositionErrorCode, type JudgmentDAGCompositionStatus, type JudgmentDAGCompositionRunRecord, type JudgmentDAGCompositionRunRequest, type JudgmentDAGProblemSnapshotReference } from './judgment-dag-composition.js';
+import type { JudgmentDAGJSONValue } from './judgment-dag-runner.js';
 export declare const PROBLEM_SELECTION_CONTRACT_VERSION: "problem-selection.v1";
 export declare const PROBLEM_SELECTION_RECORD_VERSION: "problem-selection-record.v1";
 export declare const PROBLEM_SELECTION_DIRECTORY: "problem-selections";
@@ -98,6 +99,87 @@ export interface ProblemSelectionEvaluationResult {
     readonly unknowns?: readonly ProblemSelectionUnknown[];
     readonly objectiveConflicts?: readonly ProblemSelectionObjectiveConflict[];
 }
+/**
+ * The immutable identity that the Company OS producer binds to a run.
+ *
+ * This is an input from a trusted Host/Company Authority context, not an
+ * authentication assertion. OSS intentionally does not infer or authenticate
+ * a caller from these fields. The producer and Organization store must verify
+ * the binding and the current ACL before accepting an event.
+ */
+export interface JudgmentDAGCompositionRunHistoryBinding {
+    readonly organization_id: string;
+    readonly tenant_id: string;
+    readonly owner_person_id: string;
+    readonly project_code: string | null;
+    readonly turn_ref: string;
+}
+export type JudgmentDAGCompositionRunHistoryProducerName = 'company_os' | 'codex' | 'claude_code' | 'mana';
+export interface JudgmentDAGCompositionRunHistorySource {
+    readonly producer: JudgmentDAGCompositionRunHistoryProducerName;
+    readonly producer_revision: string;
+}
+/** References must be supplied by the trusted producer from actual reads. */
+export interface JudgmentDAGCompositionRunHistoryReferences {
+    readonly problem_snapshot: JudgmentDAGProblemSnapshotReference;
+    readonly foundation: readonly JudgmentDAGJSONValue[];
+    readonly evidence: readonly JudgmentDAGJSONValue[];
+}
+export type JudgmentDAGCompositionRunHistoryState = 'started' | JudgmentDAGCompositionStatus | 'unknown';
+export type JudgmentDAGCompositionRunHistoryFailureCode = JudgmentDAGCompositionErrorCode | 'unknown';
+export interface JudgmentDAGCompositionRunHistoryFailure {
+    readonly code: JudgmentDAGCompositionRunHistoryFailureCode;
+    /** This message is fixed; raw executor/store exceptions are never persisted. */
+    readonly message: string;
+}
+export interface JudgmentDAGCompositionRunHistoryLifecycle {
+    readonly lifecycle_event_id: string;
+    readonly state: JudgmentDAGCompositionRunHistoryState;
+    readonly recorded_at: string;
+    readonly failure: JudgmentDAGCompositionRunHistoryFailure | null;
+}
+/**
+ * Port event understood by a trusted Host adapter and the Organization native
+ * store. The adapter may map this event to its envelope/store API, but it
+ * must preserve the run body and binding fields exactly.
+ */
+export interface JudgmentDAGCompositionRunHistoryEvent {
+    readonly run_id: string;
+    readonly binding: JudgmentDAGCompositionRunHistoryBinding;
+    readonly source: JudgmentDAGCompositionRunHistorySource;
+    readonly semantic_scope: JudgmentDAGCompositionDefinition['scope'];
+    readonly lifecycle: JudgmentDAGCompositionRunHistoryLifecycle;
+    readonly composition_run: JudgmentDAGCompositionRunRecord | null;
+    readonly references: JudgmentDAGCompositionRunHistoryReferences;
+}
+/**
+ * Company OS native storage boundary. Implementations own trusted binding,
+ * current ACL, idempotency, and conflict checks. A caller that merely passes
+ * a body to this port is not thereby trusted.
+ *
+ * Retry contract: the caller supplies stable lifecycle_event_id and
+ * recorded_at values, including timestamps. A producer may retry its own
+ * transport with the identical event; this wrapper never retries the
+ * executor and never creates a new event identity or time.
+ */
+export interface JudgmentDAGCompositionRunHistoryProducer {
+    readonly append: (event: JudgmentDAGCompositionRunHistoryEvent) => void | Promise<void>;
+}
+/** Short alias for callers that name the boundary as a CompositionRun port. */
+export type JudgmentDAGCompositionRunProducer = JudgmentDAGCompositionRunHistoryProducer;
+export interface JudgmentDAGCompositionRunHistoryLifecycleInput {
+    readonly lifecycle_event_id: string;
+    readonly recorded_at: string;
+}
+export interface JudgmentDAGCompositionRunHistoryOptions {
+    readonly producer: JudgmentDAGCompositionRunHistoryProducer;
+    /** Trusted binding supplied by Host/Company Authority; OSS does not derive it. */
+    readonly binding: JudgmentDAGCompositionRunHistoryBinding;
+    readonly source: JudgmentDAGCompositionRunHistorySource;
+    readonly references: JudgmentDAGCompositionRunHistoryReferences;
+    readonly started: JudgmentDAGCompositionRunHistoryLifecycleInput;
+    readonly terminal: JudgmentDAGCompositionRunHistoryLifecycleInput;
+}
 export interface ProblemSelectionEvaluationRequest {
     readonly selectionId: string;
     readonly selectionProblem: JudgmentDAGProblemSnapshotReference;
@@ -224,6 +306,7 @@ export declare const selectProblem: typeof createProblemSelection;
 export declare function evaluateProblemSelectionWithComposition(input: {
     readonly compositionRequest: JudgmentDAGCompositionRunRequest;
     readonly resultInvocationId?: string;
+    readonly compositionRunHistory?: JudgmentDAGCompositionRunHistoryOptions;
 }): Promise<ProblemSelectionEvaluationResult>;
 export declare function computeProblemSelectionRecordId(record: ProblemSelectionRecord): ProblemSelectionRecordId;
 export declare function saveProblemSelectionRecord(request: SaveProblemSelectionRecordRequest): Promise<ProblemSelectionRecordReceipt>;

package/dist/problem-selection.js

@@ -11,7 +11,7 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { link, lstat, mkdir, open, readFile, unlink } from 'node:fs/promises';
 import path from 'node:path';
-import { createJudgmentDAGCompositionDefinition, executeJudgmentDAGComposition } from './judgment-dag-composition.js';
+import { createJudgmentDAGCompositionDefinition, JudgmentDAGCompositionError, executeJudgmentDAGComposition } from './judgment-dag-composition.js';
 export const PROBLEM_SELECTION_CONTRACT_VERSION = 'problem-selection.v1';
 export const PROBLEM_SELECTION_RECORD_VERSION = 'problem-selection-record.v1';
 export const PROBLEM_SELECTION_DIRECTORY = 'problem-selections';
@@ -695,6 +695,100 @@ export async function createProblemSelection(request) {
 export const runProblemSelection = createProblemSelection;
 /** Alias for callers that name the operation as a selection. */
 export const selectProblem = createProblemSelection;
+const SAFE_COMPOSITION_FAILURE_MESSAGE = 'DAG composition failed before a run record was returned';
+const SAFE_COMPOSITION_HISTORY_FAILURE_MESSAGE = 'DAG composition history could not be saved';
+const SAFE_COMPOSITION_RESULT_FAILURE_MESSAGE = 'selection composition result could not be read';
+function snapshotCompositionHistoryMetadata(request, options) {
+    // Producer adapters receive a frozen JSON-only snapshot. This keeps a
+    // producer from changing the binding, references, run id, or scope between
+    // the started event and the terminal event while it performs persistence.
+    // Only metadata is cloned here: the request also contains executable
+    // snapshot/DAG/contract/port adapters and is intentionally never cloned.
+    return deepFreeze({
+        run_id: request.run_id,
+        binding: cloneJson(options.binding, 'compositionRunHistory.binding'),
+        source: cloneJson(options.source, 'compositionRunHistory.source'),
+        semantic_scope: cloneJson(request.delegation.scope, 'compositionRunHistory.semantic_scope'),
+        references: cloneJson(options.references, 'compositionRunHistory.references'),
+        started: cloneJson(options.started, 'compositionRunHistory.started'),
+        terminal: cloneJson(options.terminal, 'compositionRunHistory.terminal')
+    });
+}
+function compositionHistoryReview(reason) {
+    return {
+        status: 'human_review_required',
+        reason,
+        unknowns: [{ status: 'unknown', reason }],
+        objectiveConflicts: []
+    };
+}
+function compositionHistorySaveFailure() {
+    const reason = `selection composition history unavailable: ${SAFE_COMPOSITION_HISTORY_FAILURE_MESSAGE}`;
+    return compositionHistoryReview(reason);
+}
+function compositionFailureCode(cause) {
+    return cause instanceof JudgmentDAGCompositionError ? cause.code : 'unknown';
+}
+function compositionHistoryEvent(metadata, lifecycle, state, compositionRun, failure) {
+    return deepFreeze({
+        run_id: metadata.run_id,
+        binding: metadata.binding,
+        source: metadata.source,
+        semantic_scope: metadata.semantic_scope,
+        lifecycle: {
+            lifecycle_event_id: lifecycle.lifecycle_event_id,
+            state,
+            recorded_at: lifecycle.recorded_at,
+            failure
+        },
+        composition_run: compositionRun,
+        references: metadata.references
+    });
+}
+async function appendCompositionHistoryEvent(options, event) {
+    try {
+        await options.producer.append(event);
+        return true;
+    }
+    catch {
+        // The persistence implementation may retry its own transport. The
+        // wrapper does not retry or expose the store's raw error.
+        return false;
+    }
+}
+function isCompositionRunStatus(value) {
+    return value === 'completed' || value === 'failed' || value === 'held';
+}
+function sameCompositionHistoryJson(left, right) {
+    try {
+        return canonicalJson(left) === canonicalJson(right);
+    }
+    catch {
+        return false;
+    }
+}
+function isCompositionRunBoundToHistoryMetadata(run, metadata) {
+    return (run.run_id === metadata.run_id &&
+        isCompositionRunStatus(run.status) &&
+        sameCompositionHistoryJson(run.delegation.scope, metadata.semantic_scope) &&
+        sameCompositionHistoryJson(run.problem_snapshot, metadata.references.problem_snapshot));
+}
+function compositionResultFromRun(run, resultInvocationId) {
+    if (run.status !== 'completed') {
+        const reason = `selection composition status is ${run.status}`;
+        return compositionHistoryReview(reason);
+    }
+    const child = resultInvocationId === undefined
+        ? run.children[run.children.length - 1]
+        : run.children.find((entry) => entry.invocation_id === resultInvocationId);
+    if (child === undefined)
+        return compositionHistoryReview('selection composition returned no designated result child');
+    if (child.result.status !== 'completed' || !isPlainRecord(child.result.conclusion)) {
+        const reason = child.result.reason ?? `selection child status is ${child.result.status}`;
+        return compositionHistoryReview(reason);
+    }
+    return child.result.conclusion;
+}
 /**
  * Adapter helper for a composition whose designated child returns the
  * selection contract in its conclusion. The meta Problem remains the exact
@@ -702,28 +796,60 @@ export const selectProblem = createProblemSelection;
  * requires a later Problem creation request.
  */
 export async function evaluateProblemSelectionWithComposition(input) {
+    const history = input.compositionRunHistory;
+    let historyMetadata;
+    if (history !== undefined) {
+        try {
+            historyMetadata = snapshotCompositionHistoryMetadata(input.compositionRequest, history);
+        }
+        catch {
+            return compositionHistoryReview(`selection composition unavailable: ${SAFE_COMPOSITION_FAILURE_MESSAGE}`);
+        }
+    }
+    if (history !== undefined) {
+        const startedEvent = compositionHistoryEvent(historyMetadata, historyMetadata.started, 'started', null, null);
+        if (!await appendCompositionHistoryEvent(history, startedEvent))
+            return compositionHistorySaveFailure();
+    }
     let run;
     try {
         run = await executeJudgmentDAGComposition(input.compositionRequest);
     }
     catch (cause) {
-        const reason = cause instanceof Error ? cause.message : 'DAG composition failed';
-        return { status: 'human_review_required', reason: `selection composition unavailable: ${reason}`, unknowns: [{ status: 'unknown', reason }], objectiveConflicts: [] };
+        const failureCode = compositionFailureCode(cause);
+        if (history !== undefined) {
+            const failureEvent = compositionHistoryEvent(historyMetadata, historyMetadata.terminal, failureCode === 'unknown' ? 'unknown' : 'failed', null, { code: failureCode, message: SAFE_COMPOSITION_FAILURE_MESSAGE });
+            if (!await appendCompositionHistoryEvent(history, failureEvent))
+                return compositionHistorySaveFailure();
+        }
+        return compositionHistoryReview(`selection composition unavailable: ${SAFE_COMPOSITION_FAILURE_MESSAGE}`);
     }
-    if (run.status !== 'completed') {
-        const reason = `selection composition status is ${run.status}`;
-        return { status: 'human_review_required', reason, unknowns: [{ status: 'unknown', reason }], objectiveConflicts: [] };
+    if (history !== undefined) {
+        let terminalEvent;
+        try {
+            if (!isCompositionRunBoundToHistoryMetadata(run, historyMetadata)) {
+                terminalEvent = compositionHistoryEvent(historyMetadata, historyMetadata.terminal, 'unknown', null, { code: 'unknown', message: SAFE_COMPOSITION_FAILURE_MESSAGE });
+            }
+            else {
+                terminalEvent = compositionHistoryEvent(historyMetadata, historyMetadata.terminal, run.status, cloneJson(run, 'compositionRunHistory.composition_run'), null);
+            }
+        }
+        catch {
+            terminalEvent = compositionHistoryEvent(historyMetadata, historyMetadata.terminal, 'unknown', null, { code: 'unknown', message: SAFE_COMPOSITION_FAILURE_MESSAGE });
+        }
+        if (!await appendCompositionHistoryEvent(history, terminalEvent))
+            return compositionHistorySaveFailure();
+        if (terminalEvent.composition_run === null)
+            return compositionHistoryReview(SAFE_COMPOSITION_RESULT_FAILURE_MESSAGE);
     }
-    const child = input.resultInvocationId === undefined
-        ? run.children[run.children.length - 1]
-        : run.children.find((entry) => entry.invocation_id === input.resultInvocationId);
-    if (child === undefined)
-        return { status: 'human_review_required', reason: 'selection composition returned no designated result child', unknowns: [{ status: 'unknown', reason: 'missing selection result child' }], objectiveConflicts: [] };
-    if (child.result.status !== 'completed' || !isPlainRecord(child.result.conclusion)) {
-        const reason = child.result.reason ?? `selection child status is ${child.result.status}`;
-        return { status: 'human_review_required', reason, unknowns: [{ status: 'unknown', reason }], objectiveConflicts: [] };
+    try {
+        return compositionResultFromRun(run, input.resultInvocationId);
+    }
+    catch {
+        // The terminal event was appended before this extraction. Keep the
+        // persisted run while requiring a human review of the derived selection.
+        return compositionHistoryReview(SAFE_COMPOSITION_RESULT_FAILURE_MESSAGE);
     }
-    return child.result.conclusion;
 }
 function selectionRecordPayload(record) {
     return record;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.23.1",
+  "version": "0.23.3",
   "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",
@@ -31,6 +31,14 @@
       "types": "./dist/judgment-frame.d.ts",
       "import": "./dist/judgment-frame.js"
     },
+    "./judgment-history": {
+      "types": "./dist/judgment-history.d.ts",
+      "import": "./dist/judgment-history.js"
+    },
+    "./judgment-history-http": {
+      "types": "./dist/judgment-history-http.d.ts",
+      "import": "./dist/judgment-history-http.js"
+    },
     "./judgment-value-proof": {
       "types": "./dist/judgment-value-proof.d.ts",
       "import": "./dist/judgment-value-proof.js"
@@ -115,6 +123,10 @@
       "types": "./dist/company-os-learning-adoption.d.ts",
       "import": "./dist/company-os-learning-adoption.js"
     },
+    "./company-os-judgment-history": {
+      "types": "./dist/company-os-judgment-history.d.ts",
+      "import": "./dist/company-os-judgment-history.js"
+    },
     "./meeting-minutes-lineage": {
       "types": "./dist/meeting-minutes-lineage.d.ts",
       "import": "./dist/meeting-minutes-lineage.js"
@@ -407,5 +419,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "da34b87b5890ae3bc4c89bffe6faa54a302e3276"
+  "gitHead": "51eca010f2f8df4d24b44bd705467bee1161719d"
 }

package/ui/judgment-history.css

@@ -26,6 +26,35 @@
   gap: 6px;
 }
 
+.bb-jh-normal-filters {
+  display: flex;
+  flex: 1 1 280px;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.bb-jh-filter {
+  display: grid;
+  min-width: 130px;
+  gap: 4px;
+  color: var(--bb-color-muted);
+  font-size: 11px;
+}
+
+.bb-jh-filter span {
+  line-height: 1.2;
+}
+
+.bb-jh-filter select {
+  min-height: 38px;
+  border: 1px solid var(--bb-color-border-strong);
+  border-radius: var(--bb-radius-sm);
+  padding: 7px 28px 7px 10px;
+  background: var(--bb-color-panel);
+  color: var(--bb-color-ink);
+  font: inherit;
+}
+
 .bb-jh-search {
   display: flex;
   flex: 1 1 230px;
@@ -167,17 +196,161 @@
   line-height: 1.5;
 }
 
+.bb-jh-reference-availability,
+.bb-jh-missing-fields {
+  color: var(--bb-color-warning-strong, var(--bb-color-muted)) !important;
+}
+
+.bb-jh-alternative-list {
+  display: grid;
+  gap: 10px;
+  margin: 0;
+  padding: 0 0 0 18px;
+}
+
+.bb-jh-alternative-list li {
+  display: grid;
+  gap: 2px;
+  line-height: 1.45;
+}
+
+.bb-jh-alternative-list li span {
+  color: var(--bb-color-muted);
+  font-size: 12px;
+}
+
+.bb-jh-pagination {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin: 14px 0 0;
+  color: var(--bb-color-muted);
+  font-size: 12px;
+}
+
+.bb-jh-pagination-count {
+  font-variant-numeric: tabular-nums;
+}
+
 .bb-jh .bb-ws-definition dd > span {
   display: block;
   line-height: 1.5;
 }
 
+.bb-jh-feedback-events,
+.bb-jh-feedback-composer {
+  display: grid;
+  gap: 10px;
+}
+
+.bb-jh-feedback-event {
+  display: grid;
+  gap: 5px;
+  padding: 10px 0;
+  border-bottom: 1px solid var(--bb-color-border);
+}
+
+.bb-jh-feedback-event:last-child {
+  border-bottom: 0;
+}
+
+.bb-jh-feedback-event strong {
+  color: var(--bb-color-ink);
+}
+
+.bb-jh-feedback-event code,
+.bb-jh-reference-export > code,
+.bb-jh-feedback-composer > code {
+  color: var(--bb-color-quiet);
+  font-family: var(--bb-font-mono);
+  font-size: 10px;
+  overflow-wrap: anywhere;
+}
+
+.bb-jh-feedback-event p,
+.bb-jh-reference-export p {
+  margin: 0;
+  color: var(--bb-color-muted);
+  font-size: 12px;
+  line-height: 1.5;
+  overflow-wrap: anywhere;
+}
+
+.bb-jh-reference-export {
+  display: grid;
+  gap: 7px;
+  margin-top: 7px;
+  padding: 9px;
+  border: 1px solid var(--bb-color-border);
+  border-radius: var(--bb-radius-sm);
+  background: var(--bb-color-panel-muted, var(--bb-color-panel));
+}
+
+.bb-jh-reference-export label,
+.bb-jh-feedback-composer label {
+  color: var(--bb-color-muted);
+  font-size: 11px;
+}
+
+.bb-jh-reference-export textarea,
+.bb-jh-feedback-composer textarea,
+.bb-jh-feedback-composer select {
+  width: 100%;
+  min-height: 36px;
+  border: 1px solid var(--bb-color-border-strong);
+  border-radius: var(--bb-radius-sm);
+  padding: 8px 10px;
+  background: var(--bb-color-panel);
+  color: var(--bb-color-ink);
+  font: inherit;
+  resize: vertical;
+}
+
+.bb-jh-reference-payload {
+  margin: 0;
+  padding: 8px;
+  border-radius: var(--bb-radius-sm);
+  background: var(--bb-color-code, var(--bb-color-panel));
+  color: var(--bb-color-quiet);
+  font-family: var(--bb-font-mono);
+  font-size: 10px;
+  line-height: 1.45;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+
+.bb-jh-copy-status,
+.bb-jh-feedback-status {
+  color: var(--bb-color-muted);
+  font-size: 11px;
+  line-height: 1.45;
+}
+
+.bb-jh-feedback-status.is-saved {
+  color: var(--bb-color-success-strong, var(--bb-color-accent-strong));
+}
+
+.bb-jh-feedback-status.is-unavailable,
+.bb-jh-feedback-status.is-unconfirmed,
+.bb-jh-feedback-status.is-error {
+  color: var(--bb-color-warning-strong, var(--bb-color-muted));
+}
+
 @media (max-width: 760px) {
   .bb-jh-controls {
     align-items: stretch;
     flex-direction: column;
   }
 
+  .bb-jh-normal-filters {
+    flex-direction: column;
+  }
+
+  .bb-jh-filter select {
+    width: 100%;
+  }
+
   .bb-jh-search {
     max-width: none;
   }