@unson/brainbase-mcp 0.6.0 → 0.7.0

package/dist/judgment-dag.d.ts

@@ -8,7 +8,9 @@ export { JUDGMENT_DAG_EDGE_RELATIONS, JUDGMENT_DAG_ALLOWED_KEYS, JUDGMENT_DAG_LA
 export { executeJudgmentDAG, JudgmentDAGExecutionError } from './judgment-dag-runner.js';
 export { computeJudgmentDAGRunArtifactId, JUDGMENT_DAG_RUN_ARTIFACT_VERSION, JudgmentDAGArtifactError, loadJudgmentDAGRunArtifact, saveJudgmentDAGRunArtifact } from './judgment-dag-artifact-store.js';
 export { JUDGMENT_DAG_EVALUATION_EVENT_SET_VERSION, JUDGMENT_DAG_OUTCOME_ATTACHMENT_VERSION, JudgmentDAGReplayEvaluationError, createJudgmentDAGEvaluationEventSet, createJudgmentDAGOutcomeAttachment, evaluateJudgmentDAGVersions, replayJudgmentDAGRun } from './judgment-dag-replay-evaluation.js';
+export { JUDGMENT_DAG_COMPOSITION_STATUSES, JUDGMENT_DAG_COMPOSITION_VERSION, JUDGMENT_DAG_SUBDAG_STATUSES, JudgmentDAGCompositionError, assertValidJudgmentDAGComposition, createJudgmentDAGCompositionDefinition, executeJudgmentDAGComposition, validateJudgmentDAGComposition } from './judgment-dag-composition.js';
 export type { JudgmentDAG, JudgmentDAGEdge, JudgmentDAGEdgeRelation, JudgmentDAGLayer, JudgmentDAGMetadata, JudgmentDAGNode, JudgmentDAGNodeType, JudgmentDAGRunnerType, JudgmentDAGScope, JudgmentDAGScopeType, JudgmentDAGValidationCode, JudgmentDAGValidationDetails, JudgmentDAGValidationResult } from './judgment-dag-core.js';
 export type { JudgmentDAGDependencyOutput, JudgmentDAGExecutionCode, JudgmentDAGExecutionErrorDetails, JudgmentDAGJSONValue, JudgmentDAGNodeRunRecord, JudgmentDAGRunRecord, JudgmentDAGRunRequest, JudgmentDAGRunnerFailureKind, JudgmentDAGRunnerInput, JudgmentDAGRunnerRegistration, JudgmentDAGRunnerVersion } from './judgment-dag-runner.js';
 export type { JudgmentDAGArtifactErrorCode, JudgmentDAGRunArtifactId, JudgmentDAGRunArtifactReceipt, LoadJudgmentDAGRunArtifactRequest, SaveJudgmentDAGRunArtifactRequest } from './judgment-dag-artifact-store.js';
 export type { CreateJudgmentDAGEvaluationEventSetRequest, CreateJudgmentDAGOutcomeAttachmentRequest, EvaluateJudgmentDAGVersionsRequest, JudgmentDAGEvaluationCriterion, JudgmentDAGEvaluationEvent, JudgmentDAGEvaluationEventSet, JudgmentDAGEvaluationRun, JudgmentDAGEvaluationScoring, JudgmentDAGNodeCalibration, JudgmentDAGNodeCalibrationStatus, JudgmentDAGOutcomeAttachment, JudgmentDAGOutcomeObservation, JudgmentDAGReplayEvaluationErrorCode, JudgmentDAGReplayResult, JudgmentDAGRunArtifactReference, JudgmentDAGScoreSummary, JudgmentDAGVersionComparison, ReplayJudgmentDAGRunRequest } from './judgment-dag-replay-evaluation.js';
+export type { JudgmentDAGCompositionChildRunSource, JudgmentDAGCompositionDefinition, JudgmentDAGCompositionErrorCode, JudgmentDAGCompositionRunRecord, JudgmentDAGCompositionRunRequest, JudgmentDAGCompositionStatus, JudgmentDAGCompositionValidationResult, JudgmentDAGDelegationScope, JudgmentDAGEvidenceReference, JudgmentDAGInputOutputContractValidationRequest, JudgmentDAGInputOutputContractValidator, JudgmentDAGProblemSnapshotId, JudgmentDAGProblemSnapshotReadRequest, JudgmentDAGProblemSnapshotReadResult, JudgmentDAGProblemSnapshotReader, JudgmentDAGProblemSnapshotReference, JudgmentDAGRunReference, JudgmentDAGRunArtifactReadRequest, JudgmentDAGRunArtifactReader, JudgmentDAGSubDAGDefinition, JudgmentDAGSubDAGExecutionPort, JudgmentDAGSubDAGExecutionRequest, JudgmentDAGSubDAGEvaluationPort, JudgmentDAGSubDAGResult, JudgmentDAGSubDAGRunRecord, JudgmentDAGSubDAGStatus, JudgmentDAGVersionResolution, JudgmentDAGVersionReference, JudgmentDAGVersionResolver, JudgmentDAGVersionResolverRequest } from './judgment-dag-composition.js';

package/dist/judgment-dag.js

@@ -8,3 +8,4 @@ export { JUDGMENT_DAG_EDGE_RELATIONS, JUDGMENT_DAG_ALLOWED_KEYS, JUDGMENT_DAG_LA
 export { executeJudgmentDAG, JudgmentDAGExecutionError } from './judgment-dag-runner.js';
 export { computeJudgmentDAGRunArtifactId, JUDGMENT_DAG_RUN_ARTIFACT_VERSION, JudgmentDAGArtifactError, loadJudgmentDAGRunArtifact, saveJudgmentDAGRunArtifact } from './judgment-dag-artifact-store.js';
 export { JUDGMENT_DAG_EVALUATION_EVENT_SET_VERSION, JUDGMENT_DAG_OUTCOME_ATTACHMENT_VERSION, JudgmentDAGReplayEvaluationError, createJudgmentDAGEvaluationEventSet, createJudgmentDAGOutcomeAttachment, evaluateJudgmentDAGVersions, replayJudgmentDAGRun } from './judgment-dag-replay-evaluation.js';
+export { JUDGMENT_DAG_COMPOSITION_STATUSES, JUDGMENT_DAG_COMPOSITION_VERSION, JUDGMENT_DAG_SUBDAG_STATUSES, JudgmentDAGCompositionError, assertValidJudgmentDAGComposition, createJudgmentDAGCompositionDefinition, executeJudgmentDAGComposition, validateJudgmentDAGComposition } from './judgment-dag-composition.js';

package/dist/judgment-problem-snapshot.d.ts

@@ -0,0 +1,185 @@
+import { type FoundationDefinition, type FoundationAcl, type FoundationRevision } from './ontology-foundation.js';
+/**
+ * An immutable input bundle for one judgment.
+ *
+ * The bundle deliberately stores references to canonical objects instead of
+ * copying Objective, Model, or Constraint definitions into a second SSOT.
+ * Providers validate those references at the boundary of save/load.
+ */
+export declare const JUDGMENT_PROBLEM_SNAPSHOT_VERSION: "judgment-problem-snapshot.v1";
+export type JudgmentProblemSnapshotId = `sha256:${string}`;
+export type JudgmentProblemReferenceKind = 'objective' | 'criterion' | 'variable' | 'observation' | 'model' | 'constraint' | 'authority' | 'resource' | 'deadline' | 'dag' | 'evidence';
+export type JudgmentProblemScopeType = 'personal' | 'project' | 'organization';
+export interface JudgmentProblemScope {
+    readonly type: JudgmentProblemScopeType;
+    readonly id: string;
+}
+export interface JudgmentProblemEvidenceAccess extends FoundationAcl {
+}
+export type JudgmentProblemJSONValue = null | string | boolean | number | JudgmentProblemJSONValue[] | {
+    readonly [key: string]: JudgmentProblemJSONValue;
+};
+export interface JudgmentProblemEvidenceBinding {
+    readonly mode: 'embedded_content' | 'immutable_reference';
+    readonly digest: JudgmentProblemSnapshotId;
+    readonly reference_id?: string;
+    readonly reference_revision?: string;
+    readonly content?: JudgmentProblemJSONValue;
+    readonly access: JudgmentProblemEvidenceAccess;
+}
+export interface JudgmentProblemReference {
+    readonly kind: JudgmentProblemReferenceKind;
+    readonly id: string;
+    readonly revision: string;
+    readonly digest: JudgmentProblemSnapshotId;
+    readonly scope: JudgmentProblemScope;
+    readonly valid_from: string;
+    readonly valid_to?: string | null;
+    readonly evidence?: JudgmentProblemEvidenceBinding;
+}
+/**
+ * Stable name shared by sub-DAG and reservation consumers.  A ProblemRef is
+ * intentionally only a versioned, scoped reference; it never carries an
+ * execution grant or a mutable canonical definition.
+ */
+export type ProblemRef = JudgmentProblemReference;
+export interface JudgmentProblemSnapshot {
+    readonly snapshot_version: typeof JUDGMENT_PROBLEM_SNAPSHOT_VERSION;
+    readonly problem_id: string;
+    readonly revision: string;
+    readonly question: string;
+    readonly owner_scope: JudgmentProblemScope;
+    readonly references: readonly JudgmentProblemReference[];
+    /** A FoundationAcl keeps owner/readers/writers separate from truth status. */
+    readonly read_policy: FoundationAcl;
+    /** A snapshot never grants execution permission. */
+    readonly execution_permission: 'none';
+    readonly created_at: string;
+}
+export interface JudgmentProblemSnapshotAccessContext {
+    /** Identity resolved by the caller's trusted boundary. */
+    readonly principal: string;
+}
+/**
+ * `current` revalidates canonical references for a new judgment.  `historical`
+ * rechecks only the current read ACL and exact digest of each canonical
+ * reference, while preserving the recorded use/applicability conditions for
+ * audit/replay.  Neither mode grants execution.
+ */
+export type JudgmentProblemReferenceResolutionMode = 'current' | 'historical';
+/** The resolver phase makes historical ACL checks explicit at the port. */
+export type JudgmentProblemReferenceResolutionPhase = 'save' | 'read' | 'historical_read';
+export type JudgmentProblemSnapshotAccessAction = 'read' | 'write';
+/**
+ * Organization-specific authorization is a provider boundary.  The default
+ * implementation below is intentionally limited to the ACL carried by the
+ * snapshot; tenants can inject a provider that checks current authority.
+ */
+export interface JudgmentProblemSnapshotAccessProvider {
+    authorize(input: {
+        readonly action: JudgmentProblemSnapshotAccessAction;
+        readonly context: JudgmentProblemSnapshotAccessContext;
+        readonly acl: FoundationAcl;
+        readonly snapshot?: JudgmentProblemSnapshot;
+        readonly reference?: JudgmentProblemReference;
+    }): void | boolean | Promise<void | boolean>;
+}
+export type JudgmentProblemReferenceResolutionStatus = 'resolved' | 'missing' | 'not_applicable' | 'unauthorized' | 'unresolved';
+export interface JudgmentProblemReferenceResolution {
+    readonly status: JudgmentProblemReferenceResolutionStatus;
+    /** The provider must return the digest of the exact revision it resolved. */
+    readonly digest?: JudgmentProblemSnapshotId;
+    readonly message?: string;
+}
+/**
+ * A provider is the only place that knows how an Observation, authority,
+ * Model, or Constraint is resolved.  This store does not duplicate their
+ * validation rules.  It is called on save and on every load.  A
+ * `historical_read` must still pass the provider's trusted current read ACL and
+ * exact revision/digest check, but must not re-evaluate recorded use or scope
+ * applicability.
+ */
+export interface JudgmentProblemReferenceProvider {
+    resolve(input: {
+        readonly reference: JudgmentProblemReference;
+        readonly phase: JudgmentProblemReferenceResolutionPhase;
+        readonly context: JudgmentProblemSnapshotAccessContext;
+    }): JudgmentProblemReferenceResolution | Promise<JudgmentProblemReferenceResolution>;
+}
+export interface SaveJudgmentProblemSnapshotRequest {
+    readonly root: string;
+    readonly snapshot: JudgmentProblemSnapshot;
+    readonly access: JudgmentProblemSnapshotAccessContext;
+    readonly accessProvider?: JudgmentProblemSnapshotAccessProvider;
+    readonly referenceProvider: JudgmentProblemReferenceProvider;
+}
+export interface LoadJudgmentProblemSnapshotRequest {
+    readonly root: string;
+    readonly snapshot_id?: string;
+    readonly problem_id?: string;
+    readonly revision?: string;
+    readonly access: JudgmentProblemSnapshotAccessContext;
+    readonly accessProvider?: JudgmentProblemSnapshotAccessProvider;
+    /** Defaults to `current`; historical reads still require the provider for current ACL/digest checks. */
+    readonly reference_resolution?: JudgmentProblemReferenceResolutionMode;
+    readonly referenceProvider?: JudgmentProblemReferenceProvider;
+}
+export interface JudgmentProblemSnapshotReceipt {
+    readonly snapshot_id: JudgmentProblemSnapshotId;
+    readonly snapshot_version: typeof JUDGMENT_PROBLEM_SNAPSHOT_VERSION;
+    readonly problem_id: string;
+    readonly revision: string;
+    readonly status: 'created' | 'existing';
+}
+export type JudgmentProblemSnapshotErrorCode = 'invalid_request' | 'missing_reference' | 'not_applicable' | 'unresolved_constraint' | 'unauthorized' | 'not_found' | 'conflict' | 'integrity_mismatch' | 'storage_io_error';
+export declare class JudgmentProblemSnapshotError extends Error {
+    readonly code: JudgmentProblemSnapshotErrorCode;
+    readonly reference?: JudgmentProblemReference;
+    constructor(code: JudgmentProblemSnapshotErrorCode, message: string, options?: {
+        readonly reference?: JudgmentProblemReference;
+    });
+}
+export declare const defaultJudgmentProblemSnapshotAccessProvider: JudgmentProblemSnapshotAccessProvider;
+/**
+ * Derive the content address without writing.  This validates only the
+ * snapshot shape; canonical reference resolution belongs to providers.
+ */
+export declare function computeJudgmentProblemSnapshotId(value: JudgmentProblemSnapshot): JudgmentProblemSnapshotId;
+export declare function saveJudgmentProblemSnapshot(request: SaveJudgmentProblemSnapshotRequest): Promise<JudgmentProblemSnapshotReceipt>;
+export declare function loadJudgmentProblemSnapshot(request: LoadJudgmentProblemSnapshotRequest): Promise<JudgmentProblemSnapshot>;
+/** Structural adapter for FoundationRevisionStore-like readers. */
+export interface JudgmentProblemFoundationReferenceReader {
+    read(reference: FoundationRevision, context: {
+        readonly principal: string;
+    }): Promise<{
+        readonly digest: string;
+        readonly definition?: unknown;
+    } | null>;
+}
+/**
+ * Adapt the generic foundation store to the snapshot resolver.  The store
+ * read and exact digest check always run before an optional caller validator.
+ * `save`/`read` additionally validate the definition for judgment use and
+ * reference scope.  `historical_read` deliberately skips those past-use and
+ * applicability checks, but the trusted store must still enforce its current
+ * read ACL; an old revision cannot be read through a revoked current ACL.
+ * The optional validator can add organization-specific policy, but cannot
+ * bypass the canonical store or digest check.
+ */
+export declare function createJudgmentProblemFoundationReferenceProvider(options: {
+    readonly store: JudgmentProblemFoundationReferenceReader;
+    readonly validate?: (input: {
+        readonly reference: JudgmentProblemReference;
+        readonly phase: JudgmentProblemReferenceResolutionPhase;
+        readonly context: JudgmentProblemSnapshotAccessContext;
+        readonly record: {
+            readonly definition: FoundationDefinition;
+            readonly digest: string;
+        };
+    }) => JudgmentProblemReferenceResolution | Promise<JudgmentProblemReferenceResolution>;
+    readonly resolveOther?: (input: {
+        readonly reference: JudgmentProblemReference;
+        readonly phase: JudgmentProblemReferenceResolutionPhase;
+        readonly context: JudgmentProblemSnapshotAccessContext;
+    }) => JudgmentProblemReferenceResolution | Promise<JudgmentProblemReferenceResolution>;
+}): JudgmentProblemReferenceProvider;