@unson/brainbase-mcp 0.3.1 → 0.4.0

package/README.md

@@ -8,6 +8,35 @@ Ontology 2.0.0は、ローカルファイルへ持ち運べる意味契約に、
 
 このリポジトリに、社内BrainbaseのUI、セッション実行基盤、xterm転送、ワークフロー管制、SNS運用、ホスト型バックエンド、Infisical設定、雲孫の社内データは含みません。それらは社内版`brainbase-unson`の範囲です。
 
+## Judgment DAG公開契約
+
+Judgment DAGの型と副作用のない事前検証は、公開`./judgment-dag` subpath（`@unson/brainbase-mcp/judgment-dag`）から利用できます。機械可読の4つの契約ファイルは次のとおりです。
+
+- `contracts/judgment-dag/schema.json`
+- `contracts/judgment-dag/fixture.json`
+- `contracts/judgment-dag/source-lock.json`
+- `contracts/judgment-dag/digest.json`
+
+最小の検証例:
+
+```ts
+import { readFileSync } from 'node:fs';
+import { validateJudgmentDAG } from '@unson/brainbase-mcp/judgment-dag';
+
+const fixtureUrl = import.meta.resolve(
+  '@unson/brainbase-mcp/contracts/judgment-dag/fixture.json'
+);
+const dag = JSON.parse(readFileSync(new URL(fixtureUrl), 'utf8'));
+const checked = validateJudgmentDAG(dag);
+console.log(checked.execution_order); // deterministic node-ID ascending tie-break
+```
+
+`node.depends_on`と`relation: "depends_on"` edgeは完全なmirrorであり、missing・cycle・reverse-layer・scope不一致は実行前に拒否されます。
+
+配布済みconsumerは、installed package rootから`source-lock.sources`と`digest.files`の各package-relative pathをSHA-256で再計算し、`digest.files`をpath順に`path + NUL + sha256 + LF`で連結したaggregate digestまでreadbackします。`source-lock`はimmutableな`repository`と`accepted_base_commit`を示し、`src/`のような非同梱ファイルはhash対象にしません。
+
+この契約はrunner、artifact、execution log、replay/evaluation、Execution/Evaluation mutation protectionを含まないJ0-2非目標のcore sliceです。
+
 ## マニュアル
 
 Read the public onboarding manual at [brainbase.pages.dev](https://brainbase.pages.dev/). It guides users through five phases: choose one real use case, register approved work context, prove the first value, add only necessary sources, and operationalize Skills, routines, and MCP.

package/contracts/judgment-dag/digest.json

@@ -0,0 +1,32 @@
+{
+  "contract": "judgment-dag-core",
+  "algorithm": "sha256",
+  "canonicalization": "UTF-8 lines sorted by path as path + NUL + sha256 + LF",
+  "files": [
+    {
+      "path": "contracts/judgment-dag/fixture.json",
+      "sha256": "c191ea129c55c97d131998698a79f656c900150fb97abb4715aa44d2abca39c5"
+    },
+    {
+      "path": "contracts/judgment-dag/schema.json",
+      "sha256": "af783617e76dc3cdc878210311821f9b0e982b31102ab6bf46ad726d5423745d"
+    },
+    {
+      "path": "contracts/judgment-dag/source-lock.json",
+      "sha256": "c7b3020fe3952d90bd8ed991f613be66c0798983bb6cc2285a9aefff7ab2f0e9"
+    },
+    {
+      "path": "docs/architecture/judgment-dag-core.md",
+      "sha256": "24305aaa97df9c734d468c49f52784e94b77a4f506bae41d482bee05625d7e2a"
+    },
+    {
+      "path": "docs/management/judgment-dag-milestones.md",
+      "sha256": "ef51313f33de64f702fd6c86012984bd70cf99eeca5b4f4cfc27f6cb266172bd"
+    },
+    {
+      "path": "README.md",
+      "sha256": "7cd5721b9a932f5b43dd01557dfbcd8ea73563d5d23337fabdd322367d678e28"
+    }
+  ],
+  "digest": "fd5587b97cf343290c7d6c78f365d2d78bef668b04578e5ab55c67886ba0e827"
+}

package/contracts/judgment-dag/fixture.json

@@ -0,0 +1,21 @@
+{
+  "id": "j0-valid",
+  "version": "2026-08-20.1",
+  "nodes": [
+    { "id": "context.customer", "node_type": "observation", "layer": "context", "scope": { "type": "project", "id": "project-j0-fixture" }, "version": "1.0.0", "description": "customer observation", "depends_on": [], "input_contract": "fixture.input.v1", "output_contract": "fixture.output.v1", "runner_type": "deterministic", "authority": ["fixture-owner"], "confidence": 1, "valid_from": "2026-08-20T00:00:00.000Z", "valid_to": null, "provenance": [{ "source": "j0-fixture", "reference": "context.customer" }], "evaluation": { "criteria": ["context.customer is evaluated"] } },
+    { "id": "context.account", "node_type": "observation", "layer": "context", "scope": { "type": "project", "id": "project-j0-fixture" }, "version": "1.0.0", "description": "account observation", "depends_on": [], "input_contract": "fixture.input.v1", "output_contract": "fixture.output.v1", "runner_type": "deterministic", "authority": ["fixture-owner"], "confidence": 1, "valid_from": "2026-08-20T00:00:00.000Z", "valid_to": null, "provenance": [{ "source": "j0-fixture", "reference": "context.account" }], "evaluation": { "criteria": ["context.account is evaluated"] } },
+    { "id": "judgment.fit", "node_type": "judgment", "layer": "judgment", "scope": { "type": "project", "id": "project-j0-fixture" }, "version": "1.0.0", "description": "fit judgment", "depends_on": ["context.customer", "context.account"], "input_contract": "fixture.input.v1", "output_contract": "fixture.output.v1", "runner_type": "deterministic", "authority": ["fixture-owner"], "confidence": 1, "valid_from": "2026-08-20T00:00:00.000Z", "valid_to": null, "provenance": [{ "source": "j0-fixture", "reference": "judgment.fit" }], "evaluation": { "criteria": ["judgment.fit is evaluated"] } },
+    { "id": "resource.scope", "node_type": "resource", "layer": "resource", "scope": { "type": "project", "id": "project-j0-fixture" }, "version": "1.0.0", "description": "resource scope", "depends_on": ["judgment.fit"], "input_contract": "fixture.input.v1", "output_contract": "fixture.output.v1", "runner_type": "deterministic", "authority": ["fixture-owner"], "confidence": 1, "valid_from": "2026-08-20T00:00:00.000Z", "valid_to": null, "provenance": [{ "source": "j0-fixture", "reference": "resource.scope" }], "evaluation": { "criteria": ["resource.scope is evaluated"] } },
+    { "id": "execution.proposal", "node_type": "execution", "layer": "execution", "scope": { "type": "project", "id": "project-j0-fixture" }, "version": "1.0.0", "description": "execution proposal", "depends_on": ["resource.scope"], "input_contract": "fixture.input.v1", "output_contract": "fixture.output.v1", "runner_type": "deterministic", "authority": ["fixture-owner"], "confidence": 1, "valid_from": "2026-08-20T00:00:00.000Z", "valid_to": null, "provenance": [{ "source": "j0-fixture", "reference": "execution.proposal" }], "evaluation": { "criteria": ["execution.proposal is evaluated"] } },
+    { "id": "execution.outcome", "node_type": "outcome", "layer": "execution", "scope": { "type": "project", "id": "project-j0-fixture" }, "version": "1.0.0", "description": "execution outcome", "depends_on": ["execution.proposal"], "input_contract": "fixture.input.v1", "output_contract": "fixture.output.v1", "runner_type": "deterministic", "authority": ["fixture-owner"], "confidence": 1, "valid_from": "2026-08-20T00:00:00.000Z", "valid_to": null, "provenance": [{ "source": "j0-fixture", "reference": "execution.outcome" }], "evaluation": { "criteria": ["execution.outcome is evaluated"] } },
+    { "id": "evaluation.result", "node_type": "evaluation", "layer": "evaluation", "scope": { "type": "project", "id": "project-j0-fixture" }, "version": "1.0.0", "description": "evaluation result", "depends_on": ["execution.outcome"], "input_contract": "fixture.input.v1", "output_contract": "fixture.output.v1", "runner_type": "deterministic", "authority": ["fixture-owner"], "confidence": 1, "valid_from": "2026-08-20T00:00:00.000Z", "valid_to": null, "provenance": [{ "source": "j0-fixture", "reference": "evaluation.result" }], "evaluation": { "criteria": ["evaluation.result is evaluated"] } }
+  ],
+  "edges": [
+    { "from": "context.customer", "to": "judgment.fit", "relation": "depends_on" },
+    { "from": "context.account", "to": "judgment.fit", "relation": "depends_on" },
+    { "from": "judgment.fit", "to": "resource.scope", "relation": "depends_on" },
+    { "from": "resource.scope", "to": "execution.proposal", "relation": "depends_on" },
+    { "from": "execution.proposal", "to": "execution.outcome", "relation": "depends_on" },
+    { "from": "execution.outcome", "to": "evaluation.result", "relation": "depends_on" }
+  ]
+}

package/contracts/judgment-dag/schema.json

@@ -0,0 +1,80 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/Unson-LLC/brainbase/blob/develop/contracts/judgment-dag/schema.json",
+  "title": "Brainbase Judgment DAG core contract",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["id", "version", "nodes", "edges"],
+  "properties": {
+    "id": { "$ref": "#/$defs/identifier" },
+    "version": { "type": "string", "minLength": 1, "pattern": "\\S" },
+    "nodes": { "type": "array", "items": { "$ref": "#/$defs/node" } },
+    "edges": { "type": "array", "items": { "$ref": "#/$defs/edge" } }
+  },
+  "$defs": {
+    "identifier": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^(?![\\s\\S]*[\\u0000-\\u001F\\u007F])(?=[\\s\\S]*\\S)[\\s\\S]+$"
+    },
+    "metadata": {
+      "anyOf": [
+        { "type": "string" },
+        { "type": "number" },
+        { "type": "boolean" },
+        { "type": "null" },
+        { "type": "array", "items": { "$ref": "#/$defs/metadata" } },
+        { "type": "object", "additionalProperties": { "$ref": "#/$defs/metadata" } }
+      ]
+    },
+    "scope": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["type", "id"],
+      "properties": {
+        "type": { "enum": ["personal", "project", "organization"] },
+        "id": { "$ref": "#/$defs/identifier" }
+      }
+    },
+    "node": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "node_type", "layer", "scope", "version", "description", "depends_on", "input_contract", "output_contract", "runner_type"],
+      "properties": {
+        "id": { "$ref": "#/$defs/identifier" },
+        "node_type": { "enum": ["observation", "judgment", "decision", "resource", "execution", "outcome", "evaluation"] },
+        "layer": { "enum": ["context", "judgment", "resource", "execution", "evaluation"] },
+        "scope": { "$ref": "#/$defs/scope" },
+        "version": { "type": "string", "minLength": 1, "pattern": "\\S" },
+        "description": { "type": "string", "minLength": 1, "pattern": "\\S" },
+        "depends_on": { "type": "array", "items": { "$ref": "#/$defs/identifier" }, "uniqueItems": true },
+        "input_contract": { "type": "string", "minLength": 1, "pattern": "\\S" },
+        "output_contract": { "type": "string", "minLength": 1, "pattern": "\\S" },
+        "runner_type": { "enum": ["deterministic", "agent", "human", "committee", "external"] },
+        "authority": { "$ref": "#/$defs/metadata" },
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+        "valid_from": { "type": ["string", "null"] },
+        "valid_to": { "type": ["string", "null"] },
+        "provenance": { "type": "array", "items": { "$ref": "#/$defs/metadata" } },
+        "evaluation": { "$ref": "#/$defs/metadata" }
+      },
+      "allOf": [
+        { "if": { "properties": { "node_type": { "const": "observation" } } }, "then": { "properties": { "layer": { "const": "context" } } } },
+        { "if": { "properties": { "node_type": { "enum": ["judgment", "decision"] } } }, "then": { "properties": { "layer": { "const": "judgment" } } } },
+        { "if": { "properties": { "node_type": { "const": "resource" } } }, "then": { "properties": { "layer": { "const": "resource" } } } },
+        { "if": { "properties": { "node_type": { "enum": ["execution", "outcome"] } } }, "then": { "properties": { "layer": { "const": "execution" } } } },
+        { "if": { "properties": { "node_type": { "const": "evaluation" } } }, "then": { "properties": { "layer": { "const": "evaluation" } } } }
+      ]
+    },
+    "edge": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["from", "to", "relation"],
+      "properties": {
+        "from": { "$ref": "#/$defs/identifier" },
+        "to": { "$ref": "#/$defs/identifier" },
+        "relation": { "enum": ["depends_on", "supports", "contradicts", "gates", "supersedes", "produces", "evaluated_by", "triggers"] }
+      }
+    }
+  }
+}

package/contracts/judgment-dag/source-lock.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "contract": "judgment-dag-core",
+  "repository": "https://github.com/Unson-LLC/brainbase",
+  "status": "accepted",
+  "accepted_base_commit": "7e5d5693f988f4ba84072c5910ef32f0e70871e1",
+  "sources": [
+    {
+      "kind": "architecture",
+      "path": "docs/architecture/judgment-dag-core.md",
+      "sha256": "24305aaa97df9c734d468c49f52784e94b77a4f506bae41d482bee05625d7e2a"
+    },
+    {
+      "kind": "milestones",
+      "path": "docs/management/judgment-dag-milestones.md",
+      "sha256": "ef51313f33de64f702fd6c86012984bd70cf99eeca5b4f4cfc27f6cb266172bd"
+    }
+  ],
+  "notes": [
+    "Outcome is produced and recorded by the Execution DAG and maps to the execution layer.",
+    "This J0 contract slice does not implement runner, artifact, execution-log, replay, evaluation, or mutation protection; those remain J0-2 non-goals and unverified.",
+    "Public DAG identifiers reject C0 and DEL control characters so dependency pair keys cannot collide.",
+    "J0 multi-tenancy evidence is limited to exact scope equality; cross-scope authorization, runtime, secret, database, and deployment are non-goals."
+  ]
+}

package/dist/judgment-dag-core.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Shared semantic contract for the local Judgment DAG kernel.
+ *
+ * This module deliberately contains only the contract and preflight checks.
+ * Runners, artifact stores, replay, and public MCP/CLI adapters belong to
+ * later milestones and must not be coupled to this core surface.
+ */
+export declare const JUDGMENT_DAG_NODE_TYPES: readonly ["observation", "judgment", "decision", "resource", "execution", "outcome", "evaluation"];
+export type JudgmentDAGNodeType = (typeof JUDGMENT_DAG_NODE_TYPES)[number];
+export declare const JUDGMENT_DAG_LAYERS: readonly ["context", "judgment", "resource", "execution", "evaluation"];
+export type JudgmentDAGLayer = (typeof JUDGMENT_DAG_LAYERS)[number];
+/**
+ * The accepted ontology has five layers. An outcome is the result produced
+ * by the Execution DAG; it is not a sixth layer of its own.
+ */
+export declare const JUDGMENT_DAG_NODE_TYPE_TO_LAYER: Readonly<{
+    readonly observation: "context";
+    readonly judgment: "judgment";
+    readonly decision: "judgment";
+    readonly resource: "resource";
+    readonly execution: "execution";
+    readonly outcome: "execution";
+    readonly evaluation: "evaluation";
+}>;
+export declare const JUDGMENT_DAG_SCOPE_TYPES: readonly ["personal", "project", "organization"];
+export type JudgmentDAGScopeType = (typeof JUDGMENT_DAG_SCOPE_TYPES)[number];
+export declare const JUDGMENT_DAG_RUNNER_TYPES: readonly ["deterministic", "agent", "human", "committee", "external"];
+export type JudgmentDAGRunnerType = (typeof JUDGMENT_DAG_RUNNER_TYPES)[number];
+export declare const JUDGMENT_DAG_EDGE_RELATIONS: readonly ["depends_on", "supports", "contradicts", "gates", "supersedes", "produces", "evaluated_by", "triggers"];
+export type JudgmentDAGEdgeRelation = (typeof JUDGMENT_DAG_EDGE_RELATIONS)[number];
+/**
+ * Exact JSON object keys accepted by the runtime contract. Metadata records
+ * are intentionally not listed here because their nested keys are arbitrary.
+ */
+export declare const JUDGMENT_DAG_ALLOWED_KEYS: Readonly<{
+    readonly root: readonly ["id", "version", "nodes", "edges"];
+    readonly node: readonly ["id", "node_type", "layer", "scope", "version", "description", "depends_on", "input_contract", "output_contract", "runner_type", "authority", "confidence", "valid_from", "valid_to", "provenance", "evaluation"];
+    readonly scope: readonly ["type", "id"];
+    readonly edge: readonly ["from", "to", "relation"];
+}>;
+export type JudgmentDAGMetadata = string | number | boolean | null | readonly JudgmentDAGMetadata[] | {
+    readonly [key: string]: JudgmentDAGMetadata;
+};
+export interface JudgmentDAGScope {
+    readonly type: JudgmentDAGScopeType;
+    readonly id: string;
+}
+export interface JudgmentDAGNode {
+    readonly id: string;
+    readonly node_type: JudgmentDAGNodeType;
+    readonly layer: JudgmentDAGLayer;
+    readonly scope: JudgmentDAGScope;
+    readonly version: string;
+    readonly description: string;
+    readonly depends_on: readonly string[];
+    readonly input_contract: string;
+    readonly output_contract: string;
+    readonly runner_type: JudgmentDAGRunnerType;
+    readonly authority?: JudgmentDAGMetadata;
+    readonly confidence?: number;
+    readonly valid_from?: string | null;
+    readonly valid_to?: string | null;
+    readonly provenance?: readonly JudgmentDAGMetadata[];
+    readonly evaluation?: JudgmentDAGMetadata | null;
+}
+/**
+ * For a `depends_on` relation, `from` is the dependency and `to` is the
+ * dependent node. This keeps the edge direction aligned with execution flow.
+ */
+export interface JudgmentDAGEdge {
+    readonly from: string;
+    readonly to: string;
+    readonly relation: JudgmentDAGEdgeRelation;
+}
+export interface JudgmentDAG {
+    readonly id: string;
+    readonly version: string;
+    readonly nodes: readonly JudgmentDAGNode[];
+    readonly edges: readonly JudgmentDAGEdge[];
+}
+export type JudgmentDAGValidationCode = 'invalid_contract' | 'duplicate_node' | 'missing_dependency' | 'scope_boundary_violation' | 'reverse_layer_dependency' | 'cycle';
+export interface JudgmentDAGValidationDetails {
+    readonly node_id?: string;
+    readonly dependency_id?: string;
+    readonly node_layer?: JudgmentDAGLayer;
+    readonly dependency_layer?: JudgmentDAGLayer;
+    readonly cycle?: readonly string[];
+}
+export declare class JudgmentDAGValidationError extends Error {
+    readonly code: JudgmentDAGValidationCode;
+    readonly node_id?: string;
+    readonly dependency_id?: string;
+    readonly node_layer?: JudgmentDAGLayer;
+    readonly dependency_layer?: JudgmentDAGLayer;
+    readonly cycle?: readonly string[];
+    constructor(code: JudgmentDAGValidationCode, message: string, details?: JudgmentDAGValidationDetails);
+}
+export interface JudgmentDAGValidationResult {
+    readonly valid: true;
+    readonly dag_id: string;
+    readonly dag_version: string;
+    readonly execution_order: readonly string[];
+}
+/**
+ * Validate a DAG before any runner can execute it.
+ *
+ * The input is never mutated. Dependencies declared on nodes and explicit
+ * `depends_on` edges are both checked. They are two required representations
+ * of the same dependency topology and must be exact mirrors; other edge
+ * relations are not part of the execution topology.
+ */
+export declare function validateJudgmentDAG(value: unknown): JudgmentDAGValidationResult;
+export declare function assertValidJudgmentDAG(value: unknown): asserts value is JudgmentDAG;

package/dist/judgment-dag-core.js

@@ -0,0 +1,439 @@
+/**
+ * Shared semantic contract for the local Judgment DAG kernel.
+ *
+ * This module deliberately contains only the contract and preflight checks.
+ * Runners, artifact stores, replay, and public MCP/CLI adapters belong to
+ * later milestones and must not be coupled to this core surface.
+ */
+export const JUDGMENT_DAG_NODE_TYPES = Object.freeze([
+    'observation',
+    'judgment',
+    'decision',
+    'resource',
+    'execution',
+    'outcome',
+    'evaluation'
+]);
+export const JUDGMENT_DAG_LAYERS = Object.freeze([
+    'context',
+    'judgment',
+    'resource',
+    'execution',
+    'evaluation'
+]);
+/**
+ * The accepted ontology has five layers. An outcome is the result produced
+ * by the Execution DAG; it is not a sixth layer of its own.
+ */
+export const JUDGMENT_DAG_NODE_TYPE_TO_LAYER = Object.freeze({
+    observation: 'context',
+    judgment: 'judgment',
+    decision: 'judgment',
+    resource: 'resource',
+    execution: 'execution',
+    outcome: 'execution',
+    evaluation: 'evaluation'
+});
+export const JUDGMENT_DAG_SCOPE_TYPES = Object.freeze([
+    'personal',
+    'project',
+    'organization'
+]);
+export const JUDGMENT_DAG_RUNNER_TYPES = Object.freeze([
+    'deterministic',
+    'agent',
+    'human',
+    'committee',
+    'external'
+]);
+export const JUDGMENT_DAG_EDGE_RELATIONS = Object.freeze([
+    'depends_on',
+    'supports',
+    'contradicts',
+    'gates',
+    'supersedes',
+    'produces',
+    'evaluated_by',
+    'triggers'
+]);
+/**
+ * Exact JSON object keys accepted by the runtime contract. Metadata records
+ * are intentionally not listed here because their nested keys are arbitrary.
+ */
+export const JUDGMENT_DAG_ALLOWED_KEYS = Object.freeze({
+    root: Object.freeze(['id', 'version', 'nodes', 'edges']),
+    node: Object.freeze([
+        'id',
+        'node_type',
+        'layer',
+        'scope',
+        'version',
+        'description',
+        'depends_on',
+        'input_contract',
+        'output_contract',
+        'runner_type',
+        'authority',
+        'confidence',
+        'valid_from',
+        'valid_to',
+        'provenance',
+        'evaluation'
+    ]),
+    scope: Object.freeze(['type', 'id']),
+    edge: Object.freeze(['from', 'to', 'relation'])
+});
+export class JudgmentDAGValidationError extends Error {
+    code;
+    node_id;
+    dependency_id;
+    node_layer;
+    dependency_layer;
+    cycle;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = 'JudgmentDAGValidationError';
+        this.code = code;
+        this.node_id = details.node_id;
+        this.dependency_id = details.dependency_id;
+        this.node_layer = details.node_layer;
+        this.dependency_layer = details.dependency_layer;
+        this.cycle = details.cycle;
+    }
+}
+const LAYER_INDEX = {
+    context: 0,
+    judgment: 1,
+    resource: 2,
+    execution: 3,
+    evaluation: 4
+};
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+function isNonEmptyString(value) {
+    return isString(value) && value.trim().length > 0;
+}
+function isSafeIdentifier(value) {
+    return isNonEmptyString(value) && !/[\u0000-\u001F\u007F]/u.test(value);
+}
+function isOneOf(values, value) {
+    return isString(value) && values.includes(value);
+}
+function invalidContract(message) {
+    throw new JudgmentDAGValidationError('invalid_contract', message);
+}
+function requireRecord(value, path) {
+    if (!isRecord(value)) {
+        invalidContract(`${path} must be an object`);
+    }
+    return value;
+}
+function requireExactKeys(value, allowedKeys, path) {
+    for (const key of Object.keys(value)) {
+        if (!allowedKeys.includes(key)) {
+            invalidContract(`${path}.${key} is not an allowed contract field`);
+        }
+    }
+}
+function requireNonEmptyString(value, path) {
+    if (!isNonEmptyString(value)) {
+        invalidContract(`${path} must be a non-empty string`);
+    }
+    return value;
+}
+function requireIdentifier(value, path) {
+    if (!isSafeIdentifier(value)) {
+        invalidContract(`${path} must be a non-empty string without control characters`);
+    }
+    return value;
+}
+function requireArray(value, path) {
+    if (!Array.isArray(value)) {
+        invalidContract(`${path} must be an array`);
+    }
+    return value;
+}
+function validateMetadata(value, path, active = new Set()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return;
+    }
+    if (typeof value === 'number') {
+        if (Number.isFinite(value)) {
+            return;
+        }
+        invalidContract(`${path} must contain only finite JSON numbers`);
+    }
+    if (typeof value !== 'object') {
+        invalidContract(`${path} must contain JSON-compatible metadata`);
+    }
+    const objectValue = value;
+    if (active.has(objectValue)) {
+        invalidContract(`${path} must not contain cyclic metadata`);
+    }
+    active.add(objectValue);
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            if (!(index in value)) {
+                invalidContract(`${path}[${index}] must be defined`);
+            }
+            validateMetadata(value[index], `${path}[${index}]`, active);
+        }
+    }
+    else {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            invalidContract(`${path} must contain only plain metadata objects`);
+        }
+        for (const [key, child] of Object.entries(value)) {
+            validateMetadata(child, `${path}.${key}`, active);
+        }
+    }
+    active.delete(objectValue);
+}
+function validateNode(value, index) {
+    const path = `nodes[${index}]`;
+    const node = requireRecord(value, path);
+    requireExactKeys(node, JUDGMENT_DAG_ALLOWED_KEYS.node, path);
+    const nodeType = node.node_type;
+    const layer = node.layer;
+    const runnerType = node.runner_type;
+    const scope = requireRecord(node.scope, `${path}.scope`);
+    requireExactKeys(scope, JUDGMENT_DAG_ALLOWED_KEYS.scope, `${path}.scope`);
+    if (!isOneOf(JUDGMENT_DAG_NODE_TYPES, nodeType)) {
+        invalidContract(`${path}.node_type is not a supported node type`);
+    }
+    if (!isOneOf(JUDGMENT_DAG_LAYERS, layer)) {
+        invalidContract(`${path}.layer is not a supported layer`);
+    }
+    if (!isOneOf(JUDGMENT_DAG_RUNNER_TYPES, runnerType)) {
+        invalidContract(`${path}.runner_type is not a supported runner type`);
+    }
+    if (!isOneOf(JUDGMENT_DAG_SCOPE_TYPES, scope.type)) {
+        invalidContract(`${path}.scope.type is not a supported scope type`);
+    }
+    if (JUDGMENT_DAG_NODE_TYPE_TO_LAYER[nodeType] !== layer) {
+        invalidContract(`${path}.layer does not match ${path}.node_type`);
+    }
+    requireIdentifier(node.id, `${path}.id`);
+    requireIdentifier(scope.id, `${path}.scope.id`);
+    requireNonEmptyString(node.version, `${path}.version`);
+    requireNonEmptyString(node.description, `${path}.description`);
+    requireNonEmptyString(node.input_contract, `${path}.input_contract`);
+    requireNonEmptyString(node.output_contract, `${path}.output_contract`);
+    const dependencies = requireArray(node.depends_on, `${path}.depends_on`);
+    for (let index = 0; index < dependencies.length; index += 1) {
+        requireIdentifier(dependencies[index], `${path}.depends_on[${index}]`);
+    }
+    if (new Set(dependencies).size !== dependencies.length) {
+        invalidContract(`${path}.depends_on must not contain duplicate node IDs`);
+    }
+    if (node.confidence !== undefined &&
+        (typeof node.confidence !== 'number' || !Number.isFinite(node.confidence) ||
+            node.confidence < 0 || node.confidence > 1)) {
+        invalidContract(`${path}.confidence must be a number between 0 and 1`);
+    }
+    for (const field of ['valid_from', 'valid_to']) {
+        if (node[field] !== undefined && node[field] !== null && !isString(node[field])) {
+            invalidContract(`${path}.${field} must be a string or null`);
+        }
+    }
+    if (node.provenance !== undefined && !Array.isArray(node.provenance)) {
+        invalidContract(`${path}.provenance must be an array`);
+    }
+    if (node.authority !== undefined) {
+        validateMetadata(node.authority, `${path}.authority`);
+    }
+    if (node.provenance !== undefined) {
+        validateMetadata(node.provenance, `${path}.provenance`);
+    }
+    if (node.evaluation !== undefined) {
+        validateMetadata(node.evaluation, `${path}.evaluation`);
+    }
+    return node;
+}
+function validateEdge(value, index, nodeById) {
+    const path = `edges[${index}]`;
+    const edge = requireRecord(value, path);
+    requireExactKeys(edge, JUDGMENT_DAG_ALLOWED_KEYS.edge, path);
+    const from = requireIdentifier(edge.from, `${path}.from`);
+    const to = requireIdentifier(edge.to, `${path}.to`);
+    if (!isOneOf(JUDGMENT_DAG_EDGE_RELATIONS, edge.relation)) {
+        invalidContract(`${path}.relation is not a supported edge relation`);
+    }
+    if (!nodeById.has(from) || !nodeById.has(to)) {
+        throw new JudgmentDAGValidationError('missing_dependency', `${path} references a node that is not in the DAG`, { node_id: to, dependency_id: from });
+    }
+    return edge;
+}
+function edgeKey(from, to) {
+    // A delimiter-based key aliases pairs such as ("a\0b", "c") and
+    // ("a", "b\0c"). JSON preserves the pair structure even if an unsafe
+    // identifier reaches this internal helper, while public identifiers are
+    // rejected by the schema/runtime before this point.
+    return JSON.stringify([from, to]);
+}
+function edgePairLabel(pair) {
+    const [from, to] = JSON.parse(pair);
+    return `${from} -> ${to}`;
+}
+function findCycle(nodes, dependenciesByNode) {
+    const state = new Map();
+    const path = [];
+    function visit(nodeId) {
+        const currentState = state.get(nodeId) ?? 0;
+        if (currentState === 1) {
+            const cycleStart = path.indexOf(nodeId);
+            return [...path.slice(cycleStart), nodeId];
+        }
+        if (currentState === 2) {
+            return undefined;
+        }
+        state.set(nodeId, 1);
+        path.push(nodeId);
+        for (const dependencyId of [...(dependenciesByNode.get(nodeId) ?? [])].sort()) {
+            const cycle = visit(dependencyId);
+            if (cycle !== undefined) {
+                return cycle;
+            }
+        }
+        path.pop();
+        state.set(nodeId, 2);
+        return undefined;
+    }
+    for (const nodeId of nodes.map((node) => node.id).sort()) {
+        const cycle = visit(nodeId);
+        if (cycle !== undefined) {
+            return cycle;
+        }
+    }
+    return undefined;
+}
+/**
+ * Validate a DAG before any runner can execute it.
+ *
+ * The input is never mutated. Dependencies declared on nodes and explicit
+ * `depends_on` edges are both checked. They are two required representations
+ * of the same dependency topology and must be exact mirrors; other edge
+ * relations are not part of the execution topology.
+ */
+export function validateJudgmentDAG(value) {
+    const dag = requireRecord(value, 'dag');
+    requireExactKeys(dag, JUDGMENT_DAG_ALLOWED_KEYS.root, 'dag');
+    const dagId = requireIdentifier(dag.id, 'dag.id');
+    const dagVersion = requireNonEmptyString(dag.version, 'dag.version');
+    const nodeValues = requireArray(dag.nodes, 'dag.nodes');
+    const edgeValues = requireArray(dag.edges, 'dag.edges');
+    const nodes = nodeValues.map(validateNode);
+    const nodeById = new Map();
+    for (const node of nodes) {
+        if (nodeById.has(node.id)) {
+            throw new JudgmentDAGValidationError('duplicate_node', `DAG contains duplicate node ID: ${node.id}`, { node_id: node.id });
+        }
+        nodeById.set(node.id, node);
+    }
+    const dependenciesByNode = new Map(nodes.map((node) => [node.id, new Set()]));
+    const dependentsByNode = new Map(nodes.map((node) => [node.id, []]));
+    const dependencyPairs = new Set();
+    const nodeDependencyPairs = new Set();
+    function addDependency(dependencyId, dependentId) {
+        const dependent = nodeById.get(dependentId);
+        const dependency = nodeById.get(dependencyId);
+        if (dependent === undefined || dependency === undefined) {
+            throw new JudgmentDAGValidationError('missing_dependency', `Node ${dependentId} depends on missing node ${dependencyId}`, { node_id: dependentId, dependency_id: dependencyId });
+        }
+        if (dependency.scope.type !== dependent.scope.type || dependency.scope.id !== dependent.scope.id) {
+            throw new JudgmentDAGValidationError('scope_boundary_violation', `Dependency ${dependencyId} -> ${dependentId} crosses an exact scope boundary`, { node_id: dependentId, dependency_id: dependencyId });
+        }
+        const pair = edgeKey(dependencyId, dependentId);
+        if (dependencyPairs.has(pair)) {
+            return;
+        }
+        dependencyPairs.add(pair);
+        dependenciesByNode.get(dependentId)?.add(dependencyId);
+        dependentsByNode.get(dependencyId)?.push(dependentId);
+        const dependencyLayerIndex = LAYER_INDEX[dependency.layer];
+        const dependentLayerIndex = LAYER_INDEX[dependent.layer];
+        if (dependencyLayerIndex > dependentLayerIndex) {
+            throw new JudgmentDAGValidationError('reverse_layer_dependency', `Node ${dependentId} in layer ${dependent.layer} depends on later layer ` +
+                `${dependency.layer} node ${dependencyId}`, {
+                node_id: dependentId,
+                dependency_id: dependencyId,
+                node_layer: dependent.layer,
+                dependency_layer: dependency.layer
+            });
+        }
+    }
+    for (const node of nodes) {
+        for (const dependencyId of node.depends_on) {
+            nodeDependencyPairs.add(edgeKey(dependencyId, node.id));
+            addDependency(dependencyId, node.id);
+        }
+    }
+    const seenEdges = new Set();
+    const edgeDependencyPairs = new Set();
+    const edges = edgeValues.map((value, index) => validateEdge(value, index, nodeById));
+    for (const edge of edges) {
+        const key = `${edge.relation}:${edgeKey(edge.from, edge.to)}`;
+        if (seenEdges.has(key)) {
+            invalidContract(`edges contains duplicate relation ${key}`);
+        }
+        seenEdges.add(key);
+        if (edge.relation === 'depends_on') {
+            edgeDependencyPairs.add(edgeKey(edge.from, edge.to));
+            addDependency(edge.from, edge.to);
+        }
+    }
+    for (const pair of nodeDependencyPairs) {
+        if (!edgeDependencyPairs.has(pair)) {
+            invalidContract(`depends_on edge is missing for node dependency ${edgePairLabel(pair)}`);
+        }
+    }
+    for (const pair of edgeDependencyPairs) {
+        if (!nodeDependencyPairs.has(pair)) {
+            invalidContract(`node dependency is missing for depends_on edge ${edgePairLabel(pair)}`);
+        }
+    }
+    const cycle = findCycle(nodes, dependenciesByNode);
+    if (cycle !== undefined) {
+        throw new JudgmentDAGValidationError('cycle', `DAG contains a dependency cycle: ${cycle.join(' -> ')}`, { cycle });
+    }
+    const remainingDependencies = new Map([...dependenciesByNode.entries()].map(([id, dependencies]) => [id, dependencies.size]));
+    const ready = nodes
+        .filter((node) => remainingDependencies.get(node.id) === 0)
+        .map((node) => node.id)
+        .sort();
+    const executionOrder = [];
+    while (ready.length > 0) {
+        const completedNodeId = ready.shift();
+        if (completedNodeId === undefined) {
+            break;
+        }
+        executionOrder.push(completedNodeId);
+        for (const dependentId of [...(dependentsByNode.get(completedNodeId) ?? [])].sort()) {
+            const remaining = (remainingDependencies.get(dependentId) ?? 0) - 1;
+            remainingDependencies.set(dependentId, remaining);
+            if (remaining === 0) {
+                ready.push(dependentId);
+                ready.sort();
+            }
+        }
+    }
+    // This is defensive after findCycle, but keeps the preflight invariant
+    // explicit if the topology implementation changes later.
+    if (executionOrder.length !== nodes.length) {
+        throw new JudgmentDAGValidationError('cycle', 'DAG does not have a complete topological order');
+    }
+    return {
+        valid: true,
+        dag_id: dagId,
+        dag_version: dagVersion,
+        execution_order: executionOrder
+    };
+}
+export function assertValidJudgmentDAG(value) {
+    validateJudgmentDAG(value);
+}

package/dist/judgment-dag.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Side-effect-free public entrypoint for the Judgment DAG core contract.
+ *
+ * The package root remains the MCP server entrypoint. Consumers that only
+ * need to validate a DAG can import this subpath without starting MCP.
+ */
+export { JUDGMENT_DAG_EDGE_RELATIONS, JUDGMENT_DAG_ALLOWED_KEYS, JUDGMENT_DAG_LAYERS, JUDGMENT_DAG_NODE_TYPE_TO_LAYER, JUDGMENT_DAG_NODE_TYPES, JUDGMENT_DAG_RUNNER_TYPES, JUDGMENT_DAG_SCOPE_TYPES, JudgmentDAGValidationError, assertValidJudgmentDAG, validateJudgmentDAG } from './judgment-dag-core.js';
+export type { JudgmentDAG, JudgmentDAGEdge, JudgmentDAGEdgeRelation, JudgmentDAGLayer, JudgmentDAGMetadata, JudgmentDAGNode, JudgmentDAGNodeType, JudgmentDAGRunnerType, JudgmentDAGScope, JudgmentDAGScopeType, JudgmentDAGValidationCode, JudgmentDAGValidationDetails, JudgmentDAGValidationResult } from './judgment-dag-core.js';

package/dist/judgment-dag.js

@@ -0,0 +1,7 @@
+/**
+ * Side-effect-free public entrypoint for the Judgment DAG core contract.
+ *
+ * The package root remains the MCP server entrypoint. Consumers that only
+ * need to validate a DAG can import this subpath without starting MCP.
+ */
+export { JUDGMENT_DAG_EDGE_RELATIONS, JUDGMENT_DAG_ALLOWED_KEYS, JUDGMENT_DAG_LAYERS, JUDGMENT_DAG_NODE_TYPE_TO_LAYER, JUDGMENT_DAG_NODE_TYPES, JUDGMENT_DAG_RUNNER_TYPES, JUDGMENT_DAG_SCOPE_TYPES, JudgmentDAGValidationError, assertValidJudgmentDAG, validateJudgmentDAG } from './judgment-dag-core.js';

package/docs/architecture/judgment-dag-core.md

@@ -0,0 +1,313 @@
+---
+title: Brainbase Judgment DAG Core
+status: accepted
+date: 2026-08-20
+scope: OSS Brainbase / shared core
+supersedes_in_part: docs/architecture/brainbase-memory-loop-product-boundary.md
+---
+
+# Brainbase Judgment DAG Core
+
+## Decision
+
+Brainbase OSS and organization deployments share the same Judgment DAG semantic model and runtime core.
+
+Brainbase is not only a memory/knowledge store. Its core responsibility is to externalize, preserve, replay, evaluate, and improve the structure by which a person or organization turns context into judgment and action.
+
+The prior product boundary that limited OSS Brainbase to `Remember / Organize / Retrieve / Learn` is revised. Brainbase owns the **judgment substrate**; Mana may own autonomous operating loops, continuous follow-through, and outcome ownership on top of that substrate.
+
+```text
+Brainbase = Remember / Organize / Retrieve / Judge / Replay / Learn
+Mana      = Operate / Prioritize continuously / Act autonomously / Follow-through
+```
+
+Brainbase may represent and execute judgment nodes. It does not become an always-on autonomous operator merely because it can execute a DAG.
+
+## Core hypothesis
+
+A person or organization can be modeled as a stateful system that repeatedly executes a directed judgment graph:
+
+```text
+State(t)
+   ↓
+Context / Observation DAG
+   ↓
+Judgment DAG
+   ↓
+Resource / Risk DAG
+   ↓
+Execution DAG
+   ↓
+Outcome
+   ↓
+Evaluation DAG
+   ↓
+State(t+1) + DAG update
+```
+
+The durable asset is not the document corpus itself. It is the reusable structure connecting evidence, assumptions, judgments, decisions, commitments, actions, outcomes, and updates.
+
+## Shared five-layer model
+
+### Layer 1: Context DAG
+Produces normalized observations and state required by downstream judgment.
+
+Allowed:
+- facts and observations
+- metrics and snapshots
+- entity resolution
+- source provenance
+- temporal validity
+
+Forbidden:
+- strategic choice
+- resource allocation
+- external action
+
+### Layer 2: Judgment DAG
+Produces reusable interpretations and decisions from Context outputs.
+
+Examples:
+- priority judgment
+- pricing judgment
+- product fit judgment
+- go/no-go judgment
+- policy selection
+
+Forbidden:
+- direct mutation of execution state
+- hidden reads from raw sources that bypass Context contracts
+- direct resource commitment
+
+### Layer 3: Resource / Risk DAG
+Converts judgments into bounded commitments.
+
+Examples:
+- budget
+- time allocation
+- staffing
+- risk limit
+- approval threshold
+- scope
+
+Forbidden:
+- reimplementing upstream business judgment
+- performing the external action itself
+
+### Layer 4: Execution DAG
+Turns approved commitments into actions and records execution artifacts.
+
+An **outcome** is the result that the Execution DAG generates and records. It is
+an execution-layer node, not an independent sixth layer. The canonical node
+type-to-layer mapping is `observation -> context`, `judgment/decision ->
+judgment`, `resource -> resource`, `execution/outcome -> execution`, and
+`evaluation -> evaluation`.
+
+Examples:
+- create task
+- send proposal
+- deploy software
+- sign/route contract
+- schedule meeting
+
+Forbidden:
+- silently changing upstream judgment or policy
+- acquiring authority that was not granted by the DAG
+
+### Layer 5: Evaluation DAG
+Compares outcomes against explicit goals and evaluation criteria.
+
+Examples:
+- forecast error
+- KPI pass/fail
+- decision quality
+- resource efficiency
+- user value confirmation
+
+Evaluation can propose an update to a judgment/policy/DAG version; it does not silently rewrite canonical judgment without the required authority.
+
+## Node contract
+
+A shared Judgment DAG node SHOULD converge on the following semantic contract:
+
+```text
+id
+node_type
+layer
+scope
+version
+description
+
+depends_on[]
+input_contract
+output_contract
+
+runner_type
+  deterministic
+  agent
+  human
+  committee
+  external
+
+authority
+confidence
+valid_from
+valid_to
+provenance
+
+evaluation
+```
+
+Initial node types should stay intentionally small:
+
+```text
+observation
+judgment
+decision
+resource
+execution
+outcome
+evaluation
+```
+
+The `outcome` node type therefore remains in the Execution layer even though
+the flow diagram shows it between Execution and Evaluation.
+
+Ontology growth must be driven by failed real use cases, not by speculative completeness.
+
+## Edge contract
+
+Knowledge/identity relations and judgment dependencies are different concepts and must not be collapsed.
+
+Judgment DAG edges include:
+
+```text
+depends_on
+supports
+contradicts
+gates
+supersedes
+produces
+evaluated_by
+triggers
+```
+
+`depends_on` defines executable DAG topology. `node.depends_on` is the
+topology SSOT: every dependency pair must have exactly one matching
+`relation=depends_on` edge, and every `relation=depends_on` edge must have
+exactly one matching node dependency. The edge is a required complete mirror,
+not an optional duplicate declaration; a one-sided or mismatched
+representation is `invalid_contract`. Relations such as `member_of`,
+`owned_by`, or `accountable_for` remain graph semantics and can be referenced
+by DAG nodes.
+
+## Scope model: personal and organization use the same DAG
+
+Do not create separate `PersonalDecision` and `CompanyDecision` schemas.
+
+A node is scoped instead:
+
+```text
+scope:
+  type: personal | project | organization
+  id: <scope-id>
+```
+
+This enables promotion:
+
+```text
+Personal Judgment
+   ↓ evidence / repeated success
+Project Judgment
+   ↓ promotion / authority
+Organization Policy
+```
+
+A judgment can therefore move from an individual's learned heuristic into an organizational capability without translation into a separate schema.
+
+J0-1 does not implement cross-scope promotion or authority evidence. Before
+execution, both nodes in every dependency pair must have exactly equal
+`scope.type` and `scope.id`; otherwise validation fails closed with the
+machine-readable code `scope_boundary_violation`. A structurally valid DAG is
+not evidence of execution authority, approval, or promotion. Those governance
+boundaries remain later-scope work.
+
+## Runtime principles inherited from FX / keiba DAG work
+
+Brainbase adopts the architecture lessons proven in the `sintariran/FX` and `sintariran/keiba` DAG systems:
+
+1. **Layer ownership is explicit.** A downstream layer must not reimplement an upstream decision.
+2. **Inputs and outputs cross typed contracts.** No hidden state side channels.
+3. **Dependencies are validated before execution.** Missing or reverse-layer dependencies are errors.
+4. **Every run produces artifacts and an execution log.** A judgment must be replayable and auditable.
+5. **DAG versions are first-class.** A changed judgment structure is a new version, not an invisible mutation.
+6. **Evaluation is separate from execution.** Metrics must not be gamed by modifying the system under evaluation.
+
+## OSS / organization boundary
+
+The Judgment DAG core is OSS-level product capability.
+
+OSS includes:
+- node/edge semantic model
+- dependency validation
+- local execution runtime
+- human and agent runners
+- local artifact/execution log
+- versioning
+- replay/evaluation primitives
+- personal/project/organization scope primitives
+- basic authority metadata
+
+Organization/Enterprise adds operational concerns rather than a different brain model:
+- organization identity and directory integration
+- robust RBAC / authority graph
+- approval and escalation workflows
+- multi-user concurrency
+- managed connectors
+- audit/compliance retention
+- hosted runtime and HA
+- cross-project governance
+- enterprise security boundaries
+
+## Mana boundary after this decision
+
+Mana is no longer defined as the only place where judgment can occur.
+
+Brainbase owns **what the judgment graph is, what it depends on, who/what can run it, what it produced, and how it evaluated**.
+
+Mana owns the higher-order operating behavior that repeatedly decides *when* to run graphs, prioritizes across goals, initiates work, monitors progress, follows through, and intervenes over time.
+
+```text
+Brainbase: executable organizational cognition
+Mana: autonomous organizational operation
+```
+
+## Non-goals
+
+- Do not migrate the entire Brainbase ontology to a large Company Ontology in one release.
+- Do not make all knowledge executable.
+- Do not let an LLM infer authority implicitly.
+- Do not create a single monolithic company DAG.
+- Do not auto-promote personal judgments into organization policy without explicit evidence and authority.
+
+## First proving ground
+
+`Brainbase Deployment` is the first dogfooding domain.
+
+The initial DAG should capture:
+
+```text
+Customer Context
+  ↓
+Maturity / Problem Structure Judgment
+  ↓
+Deployment Pattern Selection
+  ↓
+Scope / Resource Decision
+  ↓
+Proposal / Implementation
+  ↓
+Outcome Evaluation
+```
+
+Human judgment can initially be a runner. Each repeated decision should then be tested for delegation to an agent. The key success signal is a falling count of decisions that still require the original expert directly.

package/docs/management/judgment-dag-milestones.md

@@ -0,0 +1,143 @@
+---
+title: Brainbase Judgment DAG Milestones
+status: active
+date: 2026-08-20
+scope: OSS Brainbase
+---
+
+# Brainbase Judgment DAG Milestones
+
+This roadmap replaces any implicit assumption that OSS Brainbase stops at memory retrieval. The next milestones make the shared Judgment DAG core real without prematurely building a complete enterprise ontology.
+
+## M0 — Architecture lock
+
+Goal: freeze semantic boundaries before implementation.
+
+Exit criteria:
+- `judgment-dag-core.md` is accepted.
+- Personal and organization scopes share one node/edge model.
+- Brainbase/Mana boundary is documented as cognition vs autonomous operation.
+- FX/keiba lessons are explicitly adopted: layered ownership, typed boundaries, artifact logs, versioning, evaluation separation.
+
+## M1 — Local DAG kernel
+
+Goal: execute a small deterministic DAG locally.
+
+Deliverables:
+- `JudgmentDAGNode` / edge types
+- `depends_on` validation
+- layer validation
+- deterministic runner
+- execution artifact store
+- execution log
+- DAG version identifier
+
+Exit criteria:
+- A DAG with Context → Judgment → Resource → Execution → Evaluation runs deterministically.
+- Missing dependency and reverse-layer dependency fail before execution.
+- Every node output is inspectable after execution.
+- Existing Brainbase Graph/Decision storage remains compatible.
+
+## M2 — Human + Agent judgment runners
+
+Goal: allow a judgment node to be performed by a human or an agent without changing DAG semantics.
+
+Deliverables:
+- `runner_type = human | agent | deterministic | external`
+- pending human-step representation
+- agent input/output contract
+- explicit authority metadata
+- confidence/provenance recording
+
+Exit criteria:
+- The same judgment node can be run manually and by an agent.
+- Outputs can be compared without hidden context.
+- Agent execution cannot silently acquire additional authority.
+
+## M3 — Replay and evaluation
+
+Goal: make judgment quality testable rather than anecdotal.
+
+Deliverables:
+- immutable run snapshot / artifact reference
+- replay against historical context
+- explicit goal/evaluation criteria
+- outcome attachment
+- pass/fail or scored evaluation
+- node-level comparison between versions
+
+Exit criteria:
+- A prior DAG version can be replayed against a recorded context.
+- A new version can be compared with the prior version without rewriting historical artifacts.
+- Evaluation cannot mutate the event set it evaluates.
+
+## M4 — Brainbase Deployment dogfood
+
+Goal: externalize the first real expert judgment process.
+
+Initial flow:
+
+```text
+Customer Context
+  -> Maturity Judgment
+  -> Problem Structure Judgment
+  -> Deployment Pattern
+  -> Scope / Resource Decision
+  -> Proposal / Implementation
+  -> Outcome Evaluation
+```
+
+Exit criteria:
+- At least one real deployment is represented end-to-end.
+- Human-only judgment nodes are explicit.
+- Each expert escalation is logged as a missing/uncertain DAG capability rather than disappearing into chat.
+- KPI: number of decisions requiring the original expert is measurable per deployment.
+
+## M5 — Scope promotion
+
+Goal: prove Personal → Project → Organization judgment promotion using one schema.
+
+Deliverables:
+- scope metadata
+- promotion candidate workflow
+- evidence links
+- authority/approval gate
+- supersession handling
+
+Exit criteria:
+- A personal judgment can become project guidance and then organization policy without schema conversion.
+- The historical personal/project records remain queryable.
+- Promotion never occurs solely because an LLM repeats the same output.
+
+## M6 — Organization-ready primitives
+
+Goal: keep the core reusable while allowing enterprise products to extend it.
+
+Deliverables in OSS core:
+- authority references
+- approval hooks
+- organization scope primitives
+- audit event contract
+- connector/runtime adapter interfaces
+
+Not required in OSS M6:
+- SSO/SCIM
+- enterprise directory sync
+- HA hosted runtime
+- compliance retention policies
+- full multi-user approval UI
+
+Exit criteria:
+- `brainbase-unson` can implement enterprise authority/governance without forking the DAG semantic model.
+
+## Product metric hierarchy
+
+The roadmap is not complete merely because graph/node counts increase. Measure:
+
+1. **Replayability** — can Brainbase explain and rerun why a judgment occurred?
+2. **Delegatability** — can an agent/another human run the node using explicit contracts?
+3. **Expert escalation count** — how often is tacit expert judgment still required?
+4. **Outcome calibration** — do judgment versions improve against declared goals?
+5. **Promotion quality** — are reusable judgments correctly distinguished from case-specific decisions?
+
+The primary dogfood KPI is **expert escalation count per deployment**, not total stored knowledge.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Local-first Brainbase MCP server and personal onboarding kit.",
   "type": "module",
   "license": "MIT",
@@ -10,12 +10,31 @@
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./judgment-dag": {
+      "types": "./dist/judgment-dag.d.ts",
+      "import": "./dist/judgment-dag.js"
+    },
+    "./dist/*": "./dist/*",
+    "./contracts/judgment-dag/schema.json": "./contracts/judgment-dag/schema.json",
+    "./contracts/judgment-dag/fixture.json": "./contracts/judgment-dag/fixture.json",
+    "./contracts/judgment-dag/source-lock.json": "./contracts/judgment-dag/source-lock.json",
+    "./contracts/judgment-dag/digest.json": "./contracts/judgment-dag/digest.json",
+    "./package.json": "./package.json"
+  },
   "bin": {
     "brainbase-mcp": "dist/index.js",
     "brainbase": "dist/cli.js"
   },
   "files": [
     "dist",
+    "contracts",
+    "docs/architecture/judgment-dag-core.md",
+    "docs/management/judgment-dag-milestones.md",
     "README.md",
     "LICENSE",
     "SECURITY.md"
@@ -40,6 +59,7 @@
     "onboard:seed": "node dist/cli.js onboard:seed",
     "onboard:demo": "node dist/cli.js onboard:demo",
     "onboard:install": "node dist/cli.js onboard:install",
+    "contracts:generate": "node scripts/generate-judgment-dag-contract-artifacts.mjs",
     "release:plan": "node scripts/npm-release.mjs plan",
     "release:validate": "node scripts/npm-release.mjs validate",
     "release:publish": "node scripts/npm-release.mjs publish",
@@ -62,5 +82,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "0ff2753a492aef09235be2792570000ef03dfa4b"
+  "gitHead": "0ee5db39ac8f91a484628cc07a2df21cdfb149b7"
 }