@unson/brainbase-mcp 0.6.0 → 0.8.0

package/dist/judgment-value-proof.js

@@ -17,6 +17,25 @@ function outcomeStatusLabel(status) {
         return '結果未確認';
     return '成果確認の対象外';
 }
+const BASIS_LAYER_LABELS = {
+    philosophy: '大切にすること',
+    objective: '目的',
+    world_model: '現状と見通し',
+    method: '判断方法',
+    constraint: '守る条件',
+    other: 'その他'
+};
+function basisLabel(entry) {
+    return entry.layer ? `[${BASIS_LAYER_LABELS[entry.layer]}] ${entry.application}` : entry.application;
+}
+function inheritanceLine(inheritance) {
+    if (!inheritance || inheritance.sources.length === 0)
+        return null;
+    const sources = inheritance.sources.map((source) => source.label.trim()).join(' / ');
+    const same = inheritance.same_conditions.length > 0 ? `。今回も同じ: ${inheritance.same_conditions.join('、')}` : '';
+    const rechecked = inheritance.rechecked_conditions.length > 0 ? `。今回だけ確認: ${inheritance.rechecked_conditions.join('、')}` : '';
+    return `引き継ぎ: ${sources}${same}${rechecked}`;
+}
 function evidenceLabel(evidence) {
     const label = evidence.label?.trim() || evidence.kind;
     return `${label} (${evidence.status === 'verified' ? '確認済み' : '未確認'})`;
@@ -57,6 +76,29 @@ export function validateJudgmentValueProof(proof) {
             throw new TypeError('outcome_verified requires verified evidence');
         }
     }
+    const layers = ['philosophy', 'objective', 'world_model', 'method', 'constraint', 'other'];
+    for (const entry of proof.decision.basis) {
+        if (entry.layer !== undefined && !layers.includes(entry.layer)) {
+            throw new TypeError(`unsupported decision.basis[].layer: ${String(entry.layer)}`);
+        }
+    }
+    const kind = proof.decision.judgment_kind;
+    if (kind !== undefined && kind !== null) {
+        if (!/^[a-z0-9_]{1,64}$/u.test(kind.key ?? '')) {
+            throw new TypeError('decision.judgment_kind.key must be 1-64 lowercase letters, digits or underscores');
+        }
+        requiredText(kind.label, 'decision.judgment_kind.label');
+    }
+    const inheritance = proof.decision.inheritance;
+    if (inheritance !== undefined && inheritance !== null) {
+        for (const source of inheritance.sources) {
+            requiredText(source.ref, 'decision.inheritance.sources[].ref');
+            requiredText(source.label, 'decision.inheritance.sources[].label');
+        }
+        if (inheritance.sources.length > 0 && proof.decision.prior_learning_reused === false) {
+            throw new TypeError('decision.inheritance.sources contradicts prior_learning_reused=false');
+        }
+    }
     if (proof.feedback.status !== 'none' && proof.feedback.status !== 'pending'
         && !proof.feedback.evidence_ref) {
         throw new TypeError('recorded feedback requires evidence_ref');
@@ -80,17 +122,18 @@ export function placeJudgmentValueProof(proof) {
     }
     const behaviorChanged = proof.interruption.resolution === 'continued_without_human';
     const completed = proof.execution.status === 'completed';
+    const weeklyDigest = proof.interruption.resolution === 'not_applicable'
+        && proof.feedback.status === 'none'
+        && proof.state !== 'blocked'
+        && proof.outcome.status === 'not_applicable'
+        ? 'exclude'
+        : 'include';
     return {
         agent_progress: behaviorChanged && proof.execution.status === 'executing' ? 'show' : 'silent',
         agent_completion: behaviorChanged && completed ? 'show' : 'silent',
         companion_attention: companionAttention,
-        web_surface: 'none',
-        weekly_digest: proof.interruption.resolution === 'not_applicable'
-            && proof.feedback.status === 'none'
-            && proof.state !== 'blocked'
-            && proof.outcome.status === 'not_applicable'
-            ? 'exclude'
-            : 'include'
+        web_surface: weeklyDigest === 'include' ? 'review' : 'none',
+        weekly_digest: weeklyDigest
     };
 }
 export function renderJudgmentValueProofProgress(proof) {
@@ -111,8 +154,9 @@ export function renderJudgmentValueProofCompletion(proof) {
     const decision = requiredText(proof.decision.summary ?? '', 'decision.summary');
     const impact = optionalText(proof.decision.work_impact) ?? '確認による中断を避けて作業を継続';
     const basis = proof.decision.basis.length > 0
-        ? proof.decision.basis.map((entry) => entry.application).join(' / ')
+        ? proof.decision.basis.map(basisLabel).join(' / ')
         : '適用根拠は未確認';
+    const inheritance = inheritanceLine(proof.decision.inheritance);
     const evidence = proof.outcome.evidence_refs.length > 0
         ? proof.outcome.evidence_refs.map(evidenceLabel).join(' / ')
         : '成果証跡なし';
@@ -122,6 +166,7 @@ export function renderJudgmentValueProofCompletion(proof) {
         `判断: ${decision}`,
         `仕事への影響: ${impact}`,
         `根拠: ${basis}`,
+        ...(inheritance ? [inheritance] : []),
         `状態: ${outcomeStatusLabel(proof.outcome.status)}`,
         `証拠: ${evidence}`,
         '修正する場合: 「判断を修正: …」または「次回は確認」と返信'

package/dist/judgment-view-http.d.ts

@@ -0,0 +1,22 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type JudgmentViewAccessContext, type JudgmentViewReadPort, type JudgmentViewService } from './judgment-view.js';
+/** Identity supplied by the authenticated host, never by the request body. */
+export interface TrustedJudgmentViewRequestContext extends JudgmentViewAccessContext {
+}
+export type JudgmentViewServiceFactory = (context: TrustedJudgmentViewRequestContext) => JudgmentViewService | Promise<JudgmentViewService>;
+export interface JudgmentViewHttpOptions {
+    /** Bind the common read-only service to the host's trusted tenant/scope. */
+    readonly serviceFactory?: JudgmentViewServiceFactory;
+    /** Convenience for hosts that share one read port across contexts. */
+    readonly readPort?: JudgmentViewReadPort;
+    readonly basePath?: string;
+}
+export type JudgmentViewHttpHandler = (request: IncomingMessage, response: ServerResponse, context: TrustedJudgmentViewRequestContext | null) => Promise<boolean>;
+/**
+ * Composable GET handler.  It returns false outside `/judgment-views/:runId`
+ * so an organization host can compose it with reservation or other routes in
+ * one local server.
+ */
+export declare function createJudgmentViewHttpHandler(options: JudgmentViewHttpOptions): JudgmentViewHttpHandler;
+/** Alias matching hosts that name all composable adapters as routes. */
+export declare const createJudgmentViewRoute: typeof createJudgmentViewHttpHandler;

package/dist/judgment-view-http.js

@@ -0,0 +1,128 @@
+import { createJudgmentViewService, } from './judgment-view.js';
+const DEFAULT_BASE_PATH = '/judgment-views';
+function requestPath(request) {
+    try {
+        return new URL(request.url ?? '/', 'http://localhost').pathname;
+    }
+    catch {
+        return '/';
+    }
+}
+function writeJson(response, statusCode, body, headers = {}) {
+    if (response.headersSent)
+        return;
+    response.statusCode = statusCode;
+    response.setHeader('Content-Type', 'application/json');
+    for (const [name, value] of Object.entries(headers))
+        response.setHeader(name, value);
+    response.end(JSON.stringify(body));
+}
+function writeError(response, statusCode, code, message, headers = {}) {
+    writeJson(response, statusCode, { error: { code, message } }, headers);
+}
+function normalizeBasePath(basePath) {
+    const value = basePath ?? DEFAULT_BASE_PATH;
+    if (typeof value !== 'string' || !value.startsWith('/') || value === '/' || /[\u0000-\u001f\u007f]/u.test(value)) {
+        throw new TypeError('basePath must be an absolute URL path');
+    }
+    const normalized = value.replace(/\/+$/u, '');
+    if (normalized.length === 0)
+        throw new TypeError('basePath must not be root');
+    return normalized;
+}
+function matchRoute(pathname, basePath) {
+    const normalized = pathname.length > 1 ? pathname.replace(/\/+$/u, '') : pathname;
+    const prefix = `${basePath}/`;
+    if (!normalized.startsWith(prefix))
+        return null;
+    const encodedRunId = normalized.slice(prefix.length);
+    if (!encodedRunId || encodedRunId.includes('/'))
+        return null;
+    try {
+        const runId = decodeURIComponent(encodedRunId);
+        if (!runId.trim() || /[\u0000-\u001f\u007f]/u.test(runId))
+            return null;
+        return { runId };
+    }
+    catch {
+        return null;
+    }
+}
+function validContext(context) {
+    return context !== null
+        && typeof context === 'object'
+        && typeof context.tenantId === 'string'
+        && context.tenantId.trim().length > 0
+        && typeof context.principal === 'string'
+        && context.principal.trim().length > 0
+        && typeof context.scopeId === 'string'
+        && context.scopeId.trim().length > 0;
+}
+function queryEvaluationId(request) {
+    try {
+        const url = new URL(request.url ?? '/', 'http://localhost');
+        const value = url.searchParams.get('evaluationId');
+        if (value === null || value.trim().length === 0)
+            return undefined;
+        if (/[\u0000-\u001f\u007f]/u.test(value))
+            return undefined;
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+function httpStatusForDocument(document) {
+    if (document.status === 'permission_denied')
+        return 403;
+    if (document.status === 'invalid')
+        return 400;
+    if (document.status === 'unavailable')
+        return 503;
+    return 200;
+}
+function serviceFromOptions(options, context) {
+    if (options.serviceFactory)
+        return Promise.resolve(options.serviceFactory(context));
+    if (options.readPort)
+        return Promise.resolve(createJudgmentViewService(options.readPort));
+    return Promise.reject(new TypeError('serviceFactory or readPort is required'));
+}
+/**
+ * Composable GET handler.  It returns false outside `/judgment-views/:runId`
+ * so an organization host can compose it with reservation or other routes in
+ * one local server.
+ */
+export function createJudgmentViewHttpHandler(options) {
+    if (!options || typeof options !== 'object')
+        throw new TypeError('options are required');
+    if (typeof options.serviceFactory !== 'function' && !options.readPort) {
+        throw new TypeError('serviceFactory or readPort is required');
+    }
+    const basePath = normalizeBasePath(options.basePath);
+    return async (request, response, context) => {
+        const route = matchRoute(requestPath(request), basePath);
+        if (!route)
+            return false;
+        if ((request.method ?? 'GET').toUpperCase() !== 'GET') {
+            writeError(response, 405, 'method_not_allowed', 'Method is not allowed for this judgment view route', { Allow: 'GET' });
+            return true;
+        }
+        if (!validContext(context)) {
+            writeError(response, 401, 'unauthorized', 'Authenticated judgment view context is required');
+            return true;
+        }
+        const evaluationId = queryEvaluationId(request);
+        try {
+            const service = await serviceFromOptions(options, context);
+            const document = await service.read({ runId: route.runId, ...(evaluationId ? { evaluationId } : {}), access: context });
+            writeJson(response, httpStatusForDocument(document), document);
+        }
+        catch {
+            writeError(response, 503, 'unavailable', 'Judgment view is temporarily unavailable');
+        }
+        return true;
+    };
+}
+/** Alias matching hosts that name all composable adapters as routes. */
+export const createJudgmentViewRoute = createJudgmentViewHttpHandler;

package/dist/judgment-view.d.ts

@@ -0,0 +1,222 @@
+import type { CompanyOsEvaluationRecord, EvaluationJudgmentValidity, EvaluationResultStatus, PredictionComparison } from './company-os-evaluation.js';
+import type { FoundationRef } from './foundation-catalog.js';
+import type { FoundationOperator, ObjectiveDefinition, VariableDefinition } from './ontology-foundation.js';
+import type { JudgmentDAGCompositionRunRecord, JudgmentDAGEvidenceReference, JudgmentDAGProblemSnapshotReference, JudgmentDAGSubDAGRunRecord, JudgmentDAGVersionReference } from './judgment-dag-composition.js';
+import type { JudgmentDAGJSONValue, JudgmentDAGRunRecord } from './judgment-dag-runner.js';
+import type { JudgmentProblemSnapshot } from './judgment-problem-snapshot.js';
+import type { FoundationCatalogRecord } from './types.js';
+/**
+ * Read-only projection contract for following one judgment from its
+ * conclusion back to the exact Problem, Objective, evidence, child runs, and
+ * evaluation that were used at the time.
+ *
+ * This module deliberately owns neither a store nor an authorization policy.
+ * A host supplies a port after authenticating the request and binding its
+ * tenant/scope.  Every reference read is explicitly historical so the view
+ * cannot silently replace a past definition with its latest revision.
+ */
+export declare const JUDGMENT_VIEW_CONTRACT_VERSION: "judgment-view.v1";
+export declare const JUDGMENT_VIEW_STATUSES: readonly ["resolved", "unknown", "permission_denied", "unavailable", "undecidable", "invalid"];
+export type JudgmentViewStatus = (typeof JUDGMENT_VIEW_STATUSES)[number];
+export type JudgmentViewFailureStatus = Exclude<JudgmentViewStatus, 'resolved'>;
+export interface JudgmentViewAccessContext {
+    /** Identity and scope are resolved by the trusted host boundary. */
+    readonly tenantId: string;
+    readonly principal: string;
+    readonly scopeId: string;
+}
+export interface JudgmentViewReadResult<T> {
+    readonly status: 'resolved';
+    readonly value: T;
+}
+export interface JudgmentViewReadFailure {
+    readonly status: JudgmentViewFailureStatus;
+    readonly reason: string;
+}
+export type JudgmentViewPortResult<T> = JudgmentViewReadResult<T> | JudgmentViewReadFailure;
+export interface JudgmentViewSection<T> {
+    readonly status: JudgmentViewStatus;
+    readonly value?: T;
+    readonly reason?: string;
+}
+/**
+ * A collection carries an explicit absence marker.  `items: []` means the
+ * source confirmed that there are no records; an unknown or unauthorized
+ * source must use `items: null` and `absence_confirmed: false`.
+ */
+export interface JudgmentViewCollection<T> {
+    readonly status: JudgmentViewStatus;
+    readonly items: readonly T[] | null;
+    readonly absence_confirmed: boolean;
+    readonly reason?: string;
+}
+export interface JudgmentViewReadCompositionRunRequest {
+    readonly runId: string;
+    readonly access: JudgmentViewAccessContext;
+}
+export interface JudgmentViewReadProblemSnapshotRequest {
+    readonly reference: JudgmentDAGProblemSnapshotReference;
+    readonly access: JudgmentViewAccessContext;
+    readonly resolution: 'historical';
+}
+export interface JudgmentViewReadFoundationReferenceRequest {
+    readonly reference: FoundationRef;
+    readonly access: JudgmentViewAccessContext;
+    readonly resolution: 'historical';
+}
+export interface JudgmentViewReadRunArtifactRequest {
+    readonly runId: string;
+    readonly dag: JudgmentDAGVersionReference;
+    readonly artifactId?: string;
+    readonly access: JudgmentViewAccessContext;
+    readonly resolution: 'historical';
+}
+export interface JudgmentViewReadEvaluationRequest {
+    readonly runId: string;
+    readonly snapshot: JudgmentDAGProblemSnapshotReference;
+    readonly objective: FoundationRef;
+    readonly evaluationId?: string;
+    readonly access: JudgmentViewAccessContext;
+    readonly resolution: 'historical';
+}
+/**
+ * Evidence is intentionally read through a host-owned port.  The host must
+ * re-check the caller's current ACL and resolve the exact historical
+ * kind/id/revision requested here; the view never treats a reference string
+ * as proof that the evidence can still be read.
+ */
+export interface JudgmentViewReadEvidenceRequest {
+    readonly invocationId: string;
+    readonly runId?: string;
+    readonly reference: JudgmentDAGEvidenceReference;
+    readonly access: JudgmentViewAccessContext;
+    readonly resolution: 'historical';
+}
+export interface JudgmentViewEvidenceRecord {
+    readonly kind: string;
+    readonly id: string;
+    readonly revision: string;
+    readonly digest?: string;
+}
+/**
+ * Adapters can be backed by the canonical Foundation store, Problem snapshot
+ * store, DAG artifact store, and Evaluation store.  They return an explicit
+ * failure instead of turning a missing or unauthorized record into null.
+ */
+export interface JudgmentViewReadPort {
+    readonly readCompositionRun: (request: JudgmentViewReadCompositionRunRequest) => JudgmentViewPortResult<JudgmentDAGCompositionRunRecord> | Promise<JudgmentViewPortResult<JudgmentDAGCompositionRunRecord>>;
+    readonly readProblemSnapshot: (request: JudgmentViewReadProblemSnapshotRequest) => JudgmentViewPortResult<JudgmentProblemSnapshot> | Promise<JudgmentViewPortResult<JudgmentProblemSnapshot>>;
+    readonly readFoundationReference: (request: JudgmentViewReadFoundationReferenceRequest) => JudgmentViewPortResult<FoundationCatalogRecord> | Promise<JudgmentViewPortResult<FoundationCatalogRecord>>;
+    readonly readRunArtifact: (request: JudgmentViewReadRunArtifactRequest) => JudgmentViewPortResult<JudgmentDAGRunRecord> | Promise<JudgmentViewPortResult<JudgmentDAGRunRecord>>;
+    /** Current ACL plus exact historical evidence reference validation. */
+    readonly readEvidence: (request: JudgmentViewReadEvidenceRequest) => JudgmentViewPortResult<JudgmentViewEvidenceRecord> | Promise<JudgmentViewPortResult<JudgmentViewEvidenceRecord>>;
+    /** Optional until a host has an exact run-to-evaluation index. */
+    readonly readEvaluation?: (request: JudgmentViewReadEvaluationRequest) => JudgmentViewPortResult<CompanyOsEvaluationRecord> | Promise<JudgmentViewPortResult<CompanyOsEvaluationRecord>>;
+}
+export interface JudgmentViewReadRequest {
+    readonly runId: string;
+    readonly evaluationId?: string;
+    readonly access: JudgmentViewAccessContext;
+}
+export interface JudgmentViewRun {
+    readonly runId: string;
+    readonly status: JudgmentDAGCompositionRunRecord['status'];
+    readonly question: string;
+    readonly composition: JudgmentDAGVersionReference;
+    readonly parentDag: JudgmentDAGVersionReference;
+    readonly problemSnapshot: JudgmentDAGProblemSnapshotReference;
+}
+export interface JudgmentViewConclusion {
+    readonly source: 'parent-run-artifact';
+    readonly runId: string;
+    readonly dag: JudgmentDAGVersionReference;
+    /** The final node output; node internals are intentionally not exposed. */
+    readonly value: JudgmentDAGJSONValue;
+}
+export interface JudgmentViewProblem {
+    readonly snapshotId: string;
+    readonly problemId: string;
+    readonly revision: string;
+    readonly question: string;
+    readonly references: readonly JudgmentViewProblemReference[];
+}
+export interface JudgmentViewProblemReference {
+    readonly kind: string;
+    readonly id: string;
+    readonly revision: string;
+    readonly digest: string;
+}
+export interface JudgmentViewCriterion {
+    readonly variableRef: FoundationRef;
+    readonly operator: FoundationOperator;
+    readonly target?: string | number | boolean;
+    readonly variable: {
+        readonly meaning: string;
+        readonly subject: string;
+        readonly valueKind: VariableDefinition['valueKind'];
+        readonly unit?: string;
+        readonly aggregation: VariableDefinition['aggregation'];
+        readonly granularity: string;
+    };
+}
+export interface JudgmentViewObjective {
+    readonly ref: FoundationRef;
+    readonly meaning: string;
+    readonly desiredState: string;
+    readonly adoptionState: ObjectiveDefinition['adoptionState'];
+    readonly epistemicState?: ObjectiveDefinition['epistemicState'];
+    readonly beneficiaryIds: readonly string[];
+    readonly criteria: JudgmentViewCollection<JudgmentViewCriterion>;
+}
+export interface JudgmentViewEvidence {
+    readonly source: 'subdag';
+    readonly invocationId: string;
+    readonly runId?: string;
+    readonly kind: string;
+    readonly id: string;
+    readonly revision: string;
+    readonly digest?: string;
+}
+export interface JudgmentViewChildRun {
+    readonly invocationId: string;
+    readonly dag: JudgmentDAGVersionReference;
+    readonly status: JudgmentDAGSubDAGRunRecord['result']['status'];
+    readonly question: string;
+    readonly runId?: string;
+    readonly conclusion: JudgmentDAGSubDAGRunRecord['result']['conclusion'];
+    readonly uncertainty: JudgmentDAGSubDAGRunRecord['result']['uncertainty'];
+    readonly applicability: JudgmentDAGSubDAGRunRecord['result']['applicability'];
+    readonly reason?: string;
+}
+export interface JudgmentViewResultEvaluation {
+    readonly evaluationId: string;
+    readonly achievement: EvaluationResultStatus;
+    readonly criteria: CompanyOsEvaluationRecord['criteria'];
+    readonly predictionComparisons: readonly PredictionComparison[];
+    readonly evaluatedAt: string;
+    readonly outcomeCaseRef: CompanyOsEvaluationRecord['outcomeCaseRef'];
+}
+export interface JudgmentViewJudgmentValidity {
+    readonly status: EvaluationJudgmentValidity;
+    readonly basis: string;
+    readonly evidenceRefs: readonly string[];
+}
+export interface JudgmentViewDocument {
+    readonly contract_version: typeof JUDGMENT_VIEW_CONTRACT_VERSION;
+    readonly mode: 'historical';
+    readonly status: JudgmentViewStatus;
+    readonly reason?: string;
+    readonly run: JudgmentViewSection<JudgmentViewRun>;
+    readonly conclusion: JudgmentViewSection<JudgmentViewConclusion>;
+    readonly problem: JudgmentViewSection<JudgmentViewProblem>;
+    readonly objective: JudgmentViewSection<JudgmentViewObjective>;
+    readonly evidence: JudgmentViewCollection<JudgmentViewEvidence>;
+    readonly childRuns: JudgmentViewCollection<JudgmentViewChildRun>;
+    readonly resultEvaluation: JudgmentViewSection<JudgmentViewResultEvaluation>;
+    readonly judgmentValidity: JudgmentViewSection<JudgmentViewJudgmentValidity>;
+}
+export interface JudgmentViewService {
+    readonly read: (request: JudgmentViewReadRequest) => Promise<JudgmentViewDocument>;
+}
+export declare function createJudgmentViewService(port: JudgmentViewReadPort): JudgmentViewService;
+export declare function readJudgmentView(port: JudgmentViewReadPort, request: JudgmentViewReadRequest): Promise<JudgmentViewDocument>;