@unson/brainbase-mcp 0.43.0 → 0.44.1

package/dist/judgment-node-evidence.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Portable evidence-chain contract for judgment nodes.
+ *
+ * The Host owns event binding and decides which events count as business
+ * evidence.  This module only validates the small node result and evaluates
+ * ordered references; it never reads a transcript, Task, or private store.
+ */
+export declare const JUDGMENT_NODE_EVIDENCE_SCHEMA_VERSION: "brainbase-judgment-node-result-v1";
+export declare const JUDGMENT_NODE_EVIDENCE_CONTRACT: "judgment-node-evidence-v1";
+export type JudgmentNodeStatus = 'supported' | 'insufficient';
+export type JudgmentNodeEvaluationStatus = 'not_required' | 'host_unsupported' | 'missing' | 'invalid' | 'insufficient' | 'ready';
+export interface JudgmentNodeResult {
+    schema_version: typeof JUDGMENT_NODE_EVIDENCE_SCHEMA_VERSION;
+    node_id: string;
+    status: JudgmentNodeStatus;
+    finding: string;
+    evidence_fit: string;
+    unknowns: string[];
+    evidence_tool_use_ids: string[];
+    previous_result_tool_use_id: string | null;
+    next_action: string;
+}
+export interface JudgmentNodeDefinition {
+    id: string;
+    instruction?: unknown;
+    execution_contract?: unknown;
+    [key: string]: unknown;
+}
+export type JudgmentNodeResultRecord = Omit<JudgmentNodeResult, 'status'> & {
+    status: JudgmentNodeStatus | 'invalid';
+    tool_use_id: string | null;
+    event_sequence: number;
+};
+export interface JudgmentNodeEvidenceEvaluation {
+    required: boolean;
+    ready: boolean;
+    status: JudgmentNodeEvaluationStatus;
+    next_node: string | null;
+    next_action: string | null;
+    results: JudgmentNodeResultRecord[];
+    unsupported_node_ids?: string[];
+}
+/** Normalize a result stored in a successful node-evidence event. */
+export declare function normalizeJudgmentNodeResult(value: unknown): JudgmentNodeResult | null;
+/** Return opted-in node ids in the order their results must be chained. */
+export declare function judgmentNodeEvidenceNodeIds(receipt: unknown): string[];
+/** Return whether an event is usable business evidence for a node. */
+export declare function isSuccessfulJudgmentEvidenceEvent(event: unknown): boolean;
+/**
+ * Evaluate the ordered result chain for a route receipt.
+ *
+ * Returned result entries contain only the normalized node result and its
+ * binding event id/sequence; event response bodies stay outside this module.
+ */
+export declare function evaluateJudgmentNodeEvidence(events: unknown, receipt: unknown, { hostSupported }?: {
+    hostSupported?: boolean;
+}): JudgmentNodeEvidenceEvaluation;

package/dist/judgment-node-evidence.js

@@ -0,0 +1,297 @@
+/**
+ * Portable evidence-chain contract for judgment nodes.
+ *
+ * The Host owns event binding and decides which events count as business
+ * evidence.  This module only validates the small node result and evaluates
+ * ordered references; it never reads a transcript, Task, or private store.
+ */
+export const JUDGMENT_NODE_EVIDENCE_SCHEMA_VERSION = 'brainbase-judgment-node-result-v1';
+export const JUDGMENT_NODE_EVIDENCE_CONTRACT = 'judgment-node-evidence-v1';
+const NODE_STATUSES = new Set(['supported', 'insufficient']);
+const CONTROL_EVENT_KINDS = new Set([
+    'control', 'route', 'evidence', 'node_evidence', 'state', 'value_proof',
+    'turn_resolution', 'ignored', 'personal_answer', 'frame_catalog', 'frame_read', 'frame'
+]);
+const NON_BUSINESS_TOOL_PATTERN = /(?:^|__)(?:get_goal|update_goal|create_goal|search_tools|tools_search|tool_search|list_tools|list_mcp_resources|list_mcp_resource_templates|curr_time|current_time|get_time|clock|sleep)$/u;
+const MAX_NODE_ID_LENGTH = 160;
+const MAX_TEXT_LENGTH = 2000;
+const MAX_UNKNOWN_LENGTH = 800;
+const MAX_ITEMS = 24;
+const SECRET_PATTERN = /\b(?:api[_-]?key|password|passwd|secret|token)\s*[:=]\s*\S+|\b(?:sk-[a-z0-9_-]{8,}|ghp_[a-z0-9_]{8,}|github_pat_[a-z0-9_]{8,}|xox[a-z]-[a-z0-9-]{8,})\b/iu;
+const INPUT_KEYS = Object.freeze([
+    'node_id', 'status', 'finding', 'evidence_fit', 'unknowns',
+    'evidence_tool_use_ids', 'previous_result_tool_use_id', 'next_action'
+]);
+const RESULT_KEYS = Object.freeze(['schema_version', ...INPUT_KEYS]);
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function exactKeys(value, keys) {
+    if (!isRecord(value))
+        return false;
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function cleanText(value, limit, { nullable = false } = {}) {
+    if (value === null && nullable)
+        return null;
+    if (typeof value !== 'string')
+        return undefined;
+    const text = value.replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
+    if (!text || [...text].length > limit || SECRET_PATTERN.test(text))
+        return undefined;
+    return text;
+}
+function cleanId(value, options = {}) {
+    return cleanText(value, MAX_NODE_ID_LENGTH, options);
+}
+function cleanStringArray(value, limit, { maxItems = MAX_ITEMS } = {}) {
+    if (!Array.isArray(value) || value.length > maxItems)
+        return undefined;
+    const result = [];
+    for (const entry of value) {
+        const text = cleanText(entry, limit);
+        if (typeof text !== 'string' || result.includes(text))
+            return undefined;
+        result.push(text);
+    }
+    return result;
+}
+function normalizeInput(value, { includeSchemaVersion = true } = {}) {
+    const expectedKeys = includeSchemaVersion ? RESULT_KEYS : INPUT_KEYS;
+    if (!exactKeys(value, expectedKeys))
+        return null;
+    if (includeSchemaVersion && value.schema_version !== JUDGMENT_NODE_EVIDENCE_SCHEMA_VERSION)
+        return null;
+    const nodeId = cleanId(value.node_id);
+    const status = value.status;
+    const finding = cleanText(value.finding, MAX_TEXT_LENGTH);
+    const evidenceFit = cleanText(value.evidence_fit, MAX_TEXT_LENGTH);
+    const unknowns = cleanStringArray(value.unknowns, MAX_UNKNOWN_LENGTH);
+    const evidenceIds = cleanStringArray(value.evidence_tool_use_ids, MAX_NODE_ID_LENGTH);
+    const previous = cleanId(value.previous_result_tool_use_id, { nullable: true });
+    const nextAction = cleanText(value.next_action, MAX_TEXT_LENGTH);
+    if (typeof nodeId !== 'string'
+        || !NODE_STATUSES.has(status)
+        || typeof finding !== 'string'
+        || typeof evidenceFit !== 'string'
+        || !unknowns
+        || !evidenceIds
+        || previous === undefined
+        || typeof nextAction !== 'string')
+        return null;
+    if (status === 'insufficient' && unknowns.length === 0)
+        return null;
+    const base = {
+        node_id: nodeId,
+        status: status,
+        finding,
+        evidence_fit: evidenceFit,
+        unknowns,
+        evidence_tool_use_ids: evidenceIds,
+        previous_result_tool_use_id: previous,
+        next_action: nextAction
+    };
+    return includeSchemaVersion
+        ? { schema_version: JUDGMENT_NODE_EVIDENCE_SCHEMA_VERSION, ...base }
+        : base;
+}
+/** Normalize a result stored in a successful node-evidence event. */
+export function normalizeJudgmentNodeResult(value) {
+    return normalizeInput(value, { includeSchemaVersion: true });
+}
+function contractNodes(receipt) {
+    if (!isRecord(receipt) || !Array.isArray(receipt.active_node_definitions))
+        return [];
+    return receipt.active_node_definitions.filter((node) => (isRecord(node)
+        && node.execution_contract === JUDGMENT_NODE_EVIDENCE_CONTRACT
+        && typeof node.id === 'string'
+        && node.id.trim().length > 0));
+}
+/** Return opted-in node ids in the order their results must be chained. */
+export function judgmentNodeEvidenceNodeIds(receipt) {
+    return contractNodes(receipt).map((node) => node.id);
+}
+function eventSequence(event, fallback) {
+    const record = isRecord(event) ? event : null;
+    return record && Number.isSafeInteger(record.event_sequence) ? record.event_sequence : fallback;
+}
+function sortEvents(events) {
+    return (Array.isArray(events) ? events : [])
+        .map((event, index) => ({ event, index, sequence: eventSequence(event, index) }))
+        .sort((left, right) => left.sequence - right.sequence || left.index - right.index);
+}
+function eventId(event) {
+    const record = isRecord(event) ? event : null;
+    return typeof record?.tool_use_id === 'string' && record.tool_use_id.trim() ? record.tool_use_id : null;
+}
+/** Return whether an event is usable business evidence for a node. */
+export function isSuccessfulJudgmentEvidenceEvent(event) {
+    if (!isRecord(event) || event.success !== true || !eventId(event))
+        return false;
+    if (CONTROL_EVENT_KINDS.has(event.event_kind))
+        return false;
+    const toolName = typeof event.tool_name === 'string' ? event.tool_name : '';
+    if (NON_BUSINESS_TOOL_PATTERN.test(toolName))
+        return false;
+    if (/(?:^|__)(?:brainbase_projects|brainbase_admin_read|brainbase_run_receipt_inbox|brainbase_run_receipt_history|authorize_tenant_resource)$/u.test(toolName)
+        && !/^mcp__brainbase(?:-|_)personal__brainbase_admin_read$/u.test(toolName))
+        return false;
+    if (/brainbase_(?:judgment_(?:node|audit|state|value_proof|frame)|knowledge_(?:resolve|evidence)|personal_kg_answer)(?:_|$)/u.test(toolName)) {
+        return false;
+    }
+    const safeMetadata = isRecord(event.safe_metadata) ? event.safe_metadata : undefined;
+    const retrievalOutcome = safeMetadata?.retrieval_outcome;
+    if (retrievalOutcome !== undefined && retrievalOutcome !== null && retrievalOutcome !== 'result')
+        return false;
+    if (isRecord(safeMetadata?.retrieval_evidence)
+        && safeMetadata.retrieval_evidence.status !== 'retrieved')
+        return false;
+    return true;
+}
+function isEarlierEvent(candidate, resultEvent) {
+    return eventSequence(candidate, 0) < eventSequence(resultEvent, Number.MAX_SAFE_INTEGER);
+}
+function evidenceForResult(result, resultEvent, eventsById, { required = true } = {}) {
+    if (required && result.status === 'supported' && result.evidence_tool_use_ids.length === 0)
+        return false;
+    return result.evidence_tool_use_ids.every((id) => {
+        const event = eventsById.get(id);
+        return Boolean(event && isEarlierEvent(event, resultEvent) && isSuccessfulJudgmentEvidenceEvent(event));
+    });
+}
+function resultRecord(result, event, sequence) {
+    return {
+        ...result,
+        tool_use_id: eventId(event),
+        event_sequence: sequence
+    };
+}
+function missingAction(node) {
+    const instruction = cleanText(node.instruction, MAX_TEXT_LENGTH);
+    return typeof instruction === 'string'
+        ? `実行: ${instruction}。完了後にこの段階の判断結果を記録してください。`
+        : `実行してから ${node.id} の判断結果を記録してください。`;
+}
+/**
+ * Evaluate the ordered result chain for a route receipt.
+ *
+ * Returned result entries contain only the normalized node result and its
+ * binding event id/sequence; event response bodies stay outside this module.
+ */
+export function evaluateJudgmentNodeEvidence(events, receipt, { hostSupported = true } = {}) {
+    const nodes = contractNodes(receipt);
+    if (nodes.length === 0) {
+        return { required: false, ready: true, status: 'not_required', next_node: null, next_action: null, results: [] };
+    }
+    if (!hostSupported) {
+        return {
+            required: false,
+            ready: true,
+            status: 'host_unsupported',
+            next_node: null,
+            next_action: null,
+            results: [],
+            unsupported_node_ids: nodes.map((node) => node.id)
+        };
+    }
+    const orderedEvents = sortEvents(events);
+    const eventsById = new Map();
+    for (const entry of orderedEvents) {
+        const id = eventId(entry.event);
+        if (id && isRecord(entry.event) && !eventsById.has(id))
+            eventsById.set(id, entry.event);
+    }
+    const recordsByNode = new Map();
+    for (const entry of orderedEvents) {
+        if (!isRecord(entry.event))
+            continue;
+        if (entry.event.event_kind !== 'node_evidence' || entry.event.success !== true)
+            continue;
+        const safeMetadata = isRecord(entry.event.safe_metadata) ? entry.event.safe_metadata : undefined;
+        const normalized = normalizeJudgmentNodeResult(safeMetadata?.node_result);
+        if (!normalized)
+            continue;
+        const node = nodes.find((candidate) => candidate.id === normalized.node_id);
+        if (!node || !eventId(entry.event))
+            continue;
+        const record = { result: normalized, event: entry.event, sequence: entry.sequence };
+        const records = recordsByNode.get(normalized.node_id) ?? [];
+        records.push(record);
+        recordsByNode.set(normalized.node_id, records);
+    }
+    const latestResults = [];
+    let firstProblem = null;
+    let priorCurrentToolUseId = null;
+    let priorCurrentNodeId = null;
+    let priorCurrentSequence = null;
+    for (const node of nodes) {
+        const records = recordsByNode.get(node.id) ?? [];
+        const latest = records.at(-1) ?? null;
+        if (!latest) {
+            firstProblem = { status: 'missing', node, next_action: missingAction(node) };
+            break;
+        }
+        const normalized = latest.result;
+        const latestToolUseId = eventId(latest.event);
+        let valid = true;
+        let status = normalized.status;
+        let action = normalized.next_action;
+        if (normalized.previous_result_tool_use_id !== priorCurrentToolUseId
+            || (priorCurrentSequence !== null && latest.sequence <= priorCurrentSequence)) {
+            valid = false;
+            status = 'invalid';
+            action = `前段 ${priorCurrentNodeId ?? '開始'} の最新結果に結び直してから ${node.id} を再評価してください。`;
+        }
+        const evidenceRequired = node.id !== 'problem-frame';
+        if (valid && !evidenceForResult(normalized, latest.event, eventsById, { required: evidenceRequired })) {
+            valid = false;
+            status = 'invalid';
+            action = 'この段階の結論に対応する、先に実行した成功済み業務tool_use_idを記録して再評価してください。';
+        }
+        const priorInsufficient = [...records].reverse().find((record) => record !== latest && record.result.status === 'insufficient');
+        if (valid && priorInsufficient) {
+            const priorIds = new Set(priorInsufficient.result.evidence_tool_use_ids);
+            const hasNewEvidence = normalized.evidence_tool_use_ids.some((id) => {
+                const evidence = eventsById.get(id);
+                return Boolean(!priorIds.has(id)
+                    && evidence
+                    && eventSequence(evidence, -1) > priorInsufficient.sequence
+                    && isEarlierEvent(evidence, latest.event)
+                    && isSuccessfulJudgmentEvidenceEvent(evidence));
+            });
+            if (!hasNewEvidence) {
+                valid = false;
+                status = 'insufficient';
+                action = `不足した根拠を追加取得して ${node.id} を再評価してください。`;
+            }
+        }
+        if (!valid || normalized.status === 'insufficient') {
+            firstProblem = {
+                status: normalized.status === 'insufficient'
+                    ? 'insufficient'
+                    : status === 'insufficient' ? 'insufficient' : 'invalid',
+                node,
+                next_action: action
+            };
+        }
+        latestResults.push(resultRecord({ ...normalized, status }, latest.event, latest.sequence));
+        if (firstProblem)
+            break;
+        priorCurrentToolUseId = latestToolUseId;
+        priorCurrentNodeId = node.id;
+        priorCurrentSequence = latest.sequence;
+    }
+    if (firstProblem) {
+        return {
+            required: true,
+            ready: false,
+            status: firstProblem.status,
+            next_node: firstProblem.node.id,
+            next_action: firstProblem.next_action,
+            results: latestResults
+        };
+    }
+    return { required: true, ready: true, status: 'ready', next_node: null, next_action: null, results: latestResults };
+}

package/dist/judgment-runtime-resolution.d.ts

@@ -0,0 +1,264 @@
+/**
+ * Pure judgment runtime resolver core.
+ *
+ * This module is intentionally free of filesystem, transport, authentication,
+ * tenant, Host binding, policy authorization, TaskGraph persistence, and
+ * receipt I/O. Callers must validate and authorize those inputs in an adapter,
+ * then pass only the normalized request and already-applicable policies here.
+ * The implementation is kept behaviorally aligned with the former Unson
+ * service so the Host can opt into it without changing live behavior.
+ */
+import { JudgmentResolutionError, canonicalJson, computeRequestDigest, sha256Hex } from './judgment-resolution-contract.js';
+export { JudgmentResolutionError, canonicalJson, computeRequestDigest, sha256Hex };
+/**
+ * Public contract for the pure runtime resolver.
+ *
+ * The implementation below is intentionally kept in the compatibility layer
+ * while it is being moved out of the Unson service. These types describe the
+ * normalized boundary explicitly so a Host/Organization adapter cannot pass
+ * raw, unauthorised state by accident. Internal legacy helpers remain covered
+ * by the narrowly scoped `@ts-nocheck` migration exception above.
+ */
+export type JudgmentRuntimeIntent = 'answer' | 'investigate' | 'diagnose' | 'design' | 'implement' | 'review' | 'operate';
+export type JudgmentRuntimeDomain = 'general' | 'knowledge' | 'personal_judgment' | 'engineering' | 'organization' | 'operations';
+export type JudgmentRuntimeSignal = 'cumulative_effect' | 'complexity_growth' | 'threshold_proposal' | 'parallel_exploration' | 'authority_boundary' | 'problem_frame_uncertain' | 'external_outcome';
+export type JudgmentRuntimeActionKind = 'none' | 'read' | 'write' | 'external';
+export type JudgmentRuntimeRisk = 'low' | 'medium' | 'high' | 'critical';
+export type JudgmentRuntimeConfidence = 'confirmed' | 'inferred' | 'unknown';
+export type JudgmentRuntimeStatus = 'resolved' | 'needs_classification' | 'needs_policy_resolution';
+export type JudgmentRuntimeAutonomyDecision = 'continue' | 'escalate';
+export interface JudgmentRuntimeClassification {
+    intent: JudgmentRuntimeIntent;
+    domains: JudgmentRuntimeDomain[];
+    action_kind: JudgmentRuntimeActionKind;
+    risk: JudgmentRuntimeRisk;
+    confidence: JudgmentRuntimeConfidence;
+    signals: JudgmentRuntimeSignal[];
+}
+export interface JudgmentRuntimeMessage {
+    sequence: number;
+    turn_id: string | null;
+    role: 'user' | 'assistant';
+    phase: string | null;
+    text: string;
+}
+export interface JudgmentRuntimePriorReceipt {
+    turn_id: string;
+    resolution_id: string;
+    request_digest: string;
+    context_digest: string | null;
+    plan_digest: string;
+    classification: JudgmentRuntimeClassification;
+    selected_dag_ids: string[];
+}
+export interface JudgmentRuntimeRuntimeContext {
+    host: 'codex' | 'claude-code';
+    entrypoint?: 'codex' | 'claude_code' | 'mana' | 'company_os' | 'unknown';
+    model: string | null;
+    permission_mode: string | null;
+    project_binding: string | null;
+}
+export interface JudgmentRuntimeInstructionBinding {
+    scope: string;
+    source_ref: string;
+    digest: string;
+}
+export interface JudgmentRuntimeConversationContext {
+    schema_version: 'brainbase-conversation-context-v1';
+    session_ref: string;
+    messages: JudgmentRuntimeMessage[];
+    prior_receipts: JudgmentRuntimePriorReceipt[];
+    runtime: JudgmentRuntimeRuntimeContext;
+    instruction_bindings: JudgmentRuntimeInstructionBinding[];
+    completeness: 'complete' | 'partial';
+    source_digest: string;
+}
+export interface JudgmentRuntimeInput {
+    request: string;
+    turn_id: string;
+    project_code: string | null;
+    conversation_context: JudgmentRuntimeConversationContext;
+    model_interpretation: JudgmentRuntimeClassification | null;
+}
+export interface JudgmentRuntimeManifestLockEntry {
+    runtime_version: string;
+    manifest_digest: string;
+}
+export interface JudgmentRuntimeManifestLock {
+    schema_version: 'brainbase-judgment-manifest-lock-v1';
+    entries: JudgmentRuntimeManifestLockEntry[];
+}
+export interface JudgmentRuntimeHostBinding {
+    adapter_id: string;
+    adapter_version: string;
+    status?: string;
+    [key: string]: unknown;
+}
+export interface JudgmentRuntimePolicyScope {
+    type: 'global' | 'organization' | 'project' | 'owner';
+    id: string | null;
+}
+export interface JudgmentRuntimePolicyEffect {
+    target: string;
+    decision: 'require' | 'forbid' | 'prefer';
+}
+export interface JudgmentRuntimeHumanApproval {
+    action_kinds?: JudgmentRuntimeActionKind[];
+    risks?: JudgmentRuntimeRisk[];
+}
+export interface JudgmentRuntimePolicy {
+    id: string;
+    version: string;
+    priority: number;
+    strength: 'hard' | 'soft';
+    scope: JudgmentRuntimePolicyScope;
+    visibility: 'organization' | 'owner';
+    owner_person_id: string | null;
+    evidence_requirement: string;
+    effect: JudgmentRuntimePolicyEffect;
+    instruction: string;
+    human_approval?: JudgmentRuntimeHumanApproval;
+    [key: string]: unknown;
+}
+export type JudgmentRuntimeNodeKind = 'common' | 'judgment' | 'capability' | 'constraint' | 'fail_closed';
+export interface JudgmentRuntimeNode {
+    id: string;
+    kind: JudgmentRuntimeNodeKind;
+    instruction: string;
+    required_capability_template: string | null;
+    execution_contract?: string;
+    [key: string]: unknown;
+}
+export interface JudgmentRuntimeDag {
+    id: string;
+    kind: 'domain' | 'constraint' | 'fail_closed';
+    path: string[];
+    policy_ids: string[];
+    [key: string]: unknown;
+}
+export interface JudgmentRuntimeSelectors {
+    domain_order: JudgmentRuntimeDomain[];
+    signal_order: JudgmentRuntimeSignal[];
+    domain_dags: Record<JudgmentRuntimeDomain, string>;
+    signal_dags: Record<JudgmentRuntimeSignal, string>;
+    engineering_implementation_dag?: string;
+    authority_dag: string;
+    clarification_dag: string;
+    [key: string]: unknown;
+}
+export interface JudgmentRuntimeSemanticMatchers {
+    intents: Record<JudgmentRuntimeIntent, string[]>;
+    domains: Record<Exclude<JudgmentRuntimeDomain, 'general'>, string[]>;
+    signals: Record<JudgmentRuntimeSignal, string[]>;
+    safety: Record<'write' | 'external' | 'critical', string[]>;
+    positive_commands: string[];
+    follow_up: string[];
+    [key: string]: unknown;
+}
+export interface JudgmentRuntimeAutonomyPolicy {
+    schema_version: 'brainbase-autonomy-policy-v1';
+    continue_risks: JudgmentRuntimeRisk[];
+    escalate_risks: JudgmentRuntimeRisk[];
+    escalate_action_kinds: JudgmentRuntimeActionKind[];
+    runtime_escalation_reasons: string[];
+    [key: string]: unknown;
+}
+export interface JudgmentRuntimeManifest {
+    schema_version: 'brainbase-judgment-runtime-v1';
+    runtime_version: string;
+    host_bindings: JudgmentRuntimeHostBinding[];
+    policies: JudgmentRuntimePolicy[];
+    nodes: JudgmentRuntimeNode[];
+    dags: JudgmentRuntimeDag[];
+    composition_edges: Array<[string, string]>;
+    selectors: JudgmentRuntimeSelectors;
+    semantic_matchers: JudgmentRuntimeSemanticMatchers;
+    autonomy: JudgmentRuntimeAutonomyPolicy;
+    [key: string]: unknown;
+}
+export interface JudgmentRuntimeReconciliation {
+    status: 'resolved' | 'needs_classification';
+    classification: JudgmentRuntimeClassification | null;
+    assurance: 'verified' | 'bounded' | 'unknown';
+    reasons: string[];
+    evidence: Record<string, unknown>;
+}
+export interface JudgmentRuntimeAutonomyResolution {
+    autonomy_decision: JudgmentRuntimeAutonomyDecision;
+    autonomy_reason_code: 'routine_in_scope' | 'classification_missing' | 'policy_conflict' | 'risk_or_external';
+    allowed_runtime_escalation_reasons: string[];
+    autonomy_policy_ids: string[];
+}
+export interface JudgmentRuntimeGraph {
+    active_nodes: string[];
+    active_edges: Array<[string, string]>;
+}
+export interface JudgmentRuntimeCapability {
+    capability: string;
+    status: string;
+    input: Record<string, unknown>;
+    receipt_required: boolean;
+    [key: string]: unknown;
+}
+export interface JudgmentRuntimeSuppressedPolicy {
+    policy_id: string;
+    suppressed_by_policy_id: string;
+    reason: string;
+}
+export interface JudgmentRuntimePolicyMerge {
+    applicable: JudgmentRuntimePolicy[];
+    suppressed: JudgmentRuntimeSuppressedPolicy[];
+    conflict: boolean;
+}
+export interface JudgmentRuntimeResolutionPlan extends JudgmentRuntimeAutonomyResolution, JudgmentRuntimeGraph {
+    status: JudgmentRuntimeStatus;
+    reconciliation: JudgmentRuntimeReconciliation;
+    selected_dag_ids: string[];
+    applicable_policies: JudgmentRuntimePolicy[];
+    suppressed_policies: JudgmentRuntimeSuppressedPolicy[];
+    policy_conflict: boolean;
+    required_capabilities: JudgmentRuntimeCapability[];
+    active_node_definitions: JudgmentRuntimeNode[];
+    unresolved: string[];
+    rationale: string[];
+}
+export interface JudgmentRuntimeCoreInput {
+    input: JudgmentRuntimeInput;
+    manifest: JudgmentRuntimeManifest;
+    /** Policies already filtered by the Organization/Host authorization adapter. */
+    applicablePolicies?: JudgmentRuntimePolicy[];
+    ownerPersonId?: string | null;
+    clientCapabilities?: string[];
+}
+export interface JudgmentRuntimeGraphOptions {
+    clarification?: boolean;
+}
+export interface JudgmentRuntimeActiveNodeOptions {
+    evidenceRequired?: boolean;
+}
+export declare function validateManifestLock(lock: JudgmentRuntimeManifestLock, previous?: JudgmentRuntimeManifestLock | null, current?: {
+    runtimeVersion: string;
+    manifestDigest: string;
+} | null): true;
+export declare function validateManifest(manifest: JudgmentRuntimeManifest, lock: JudgmentRuntimeManifestLock): string;
+export declare function autonomyResolution(status: JudgmentRuntimeStatus, classification: JudgmentRuntimeClassification | null, manifest: JudgmentRuntimeManifest, applicablePolicies?: JudgmentRuntimePolicy[]): JudgmentRuntimeAutonomyResolution;
+export declare function validateRuntimeInput(rawInput: unknown, manifest: JudgmentRuntimeManifest): JudgmentRuntimeInput;
+export declare function reconcileModelInterpretation(input: JudgmentRuntimeInput, manifest: JudgmentRuntimeManifest): JudgmentRuntimeReconciliation;
+export declare function classify(input: JudgmentRuntimeInput, manifest: JudgmentRuntimeManifest): JudgmentRuntimeReconciliation;
+export declare function materializePolicy(policy: JudgmentRuntimePolicy, ownerPersonId: string | null): JudgmentRuntimePolicy;
+export declare function mergePolicies(policies: JudgmentRuntimePolicy[]): JudgmentRuntimePolicyMerge;
+export declare function selectedDags(classification: JudgmentRuntimeClassification, manifest: JudgmentRuntimeManifest): string[];
+export declare function buildGraph(dagIds: string[], manifest: JudgmentRuntimeManifest, { clarification }?: JudgmentRuntimeGraphOptions): JudgmentRuntimeGraph;
+export declare function materializeActiveNodeDefinitions(activeNodes: string[], manifest: JudgmentRuntimeManifest, { evidenceRequired }?: JudgmentRuntimeActiveNodeOptions): JudgmentRuntimeNode[];
+export declare function topologicallySortNodes(nodes: string[], edges: Array<[string, string]>): string[];
+export declare const JUDGMENT_FRAME_CAPABILITY = "judgment.frame";
+export declare function isJudgmentBearing(classification: JudgmentRuntimeClassification | null): boolean;
+export declare function frameCapabilities(input: JudgmentRuntimeInput, classification: JudgmentRuntimeClassification | null, clientCapabilities: ReadonlySet<string>, status: JudgmentRuntimeStatus): JudgmentRuntimeCapability[];
+export declare function knowledgeCapabilities(input: JudgmentRuntimeInput, classification: JudgmentRuntimeClassification | null): JudgmentRuntimeCapability[];
+/**
+ * Resolve the deterministic runtime plan from normalized, already-authorized
+ * inputs. `applicablePolicies` must have been filtered by the Org/Host adapter;
+ * this core deliberately has no access or tenant lookup and never broadens a
+ * deny decision.
+ */
+export declare function resolveJudgmentRuntimeCore({ input, manifest, applicablePolicies, ownerPersonId, clientCapabilities }: JudgmentRuntimeCoreInput): JudgmentRuntimeResolutionPlan;