@unson/brainbase-mcp 0.3.1 → 0.4.1

package/dist/judgment-dag-runner.js

@@ -0,0 +1,325 @@
+import { JudgmentDAGValidationError, validateJudgmentDAG } from './judgment-dag-core.js';
+export class JudgmentDAGExecutionError extends Error {
+    code;
+    node_id;
+    node_type;
+    runner_type;
+    failure_kind;
+    cause;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = 'JudgmentDAGExecutionError';
+        this.code = code;
+        this.node_id = details.node_id;
+        this.node_type = details.node_type;
+        this.runner_type = details.runner_type;
+        this.failure_kind = details.failure_kind;
+        this.cause = details.cause;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isPlainRecord(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function invalidJSON(path, reason) {
+    throw new JudgmentDAGExecutionError('invalid_json', `${path} must be a JSON value: ${reason}`);
+}
+function snapshotJSON(value, path, active = new Set()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        if (Number.isFinite(value)) {
+            return value;
+        }
+        invalidJSON(path, 'numbers must be finite');
+    }
+    if (typeof value !== 'object') {
+        invalidJSON(path, 'undefined, functions, symbols, and bigint are not supported');
+    }
+    const objectValue = value;
+    if (active.has(objectValue)) {
+        invalidJSON(path, 'cyclic values are not supported');
+    }
+    active.add(objectValue);
+    let snapshot;
+    if (Array.isArray(value)) {
+        const result = [];
+        for (let index = 0; index < value.length; index += 1) {
+            if (!(index in value)) {
+                invalidJSON(`${path}[${index}]`, 'array holes are not supported');
+            }
+            result.push(snapshotJSON(value[index], `${path}[${index}]`, active));
+        }
+        snapshot = result;
+    }
+    else {
+        if (!isPlainRecord(value)) {
+            invalidJSON(path, 'only plain objects are supported');
+        }
+        const result = {};
+        for (const key of Object.keys(value)) {
+            Object.defineProperty(result, key, {
+                configurable: true,
+                enumerable: true,
+                value: snapshotJSON(value[key], `${path}.${key}`, active),
+                writable: true
+            });
+        }
+        snapshot = result;
+    }
+    active.delete(objectValue);
+    return snapshot;
+}
+function deepFreeze(value) {
+    if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value)) {
+            deepFreeze(child);
+        }
+    }
+    return value;
+}
+function invalidRequest(message) {
+    return new JudgmentDAGExecutionError('invalid_request', message);
+}
+function snapshotRequest(value) {
+    let requestRecord;
+    try {
+        if (!isPlainRecord(value)) {
+            throw invalidRequest('request must be a plain object');
+        }
+        requestRecord = value;
+    }
+    catch (error) {
+        if (error instanceof JudgmentDAGExecutionError) {
+            throw error;
+        }
+        throw invalidRequest('request must be a readable plain object');
+    }
+    let runId;
+    let dag;
+    let input;
+    let runners;
+    try {
+        // Read each public request field exactly once. The local values below are
+        // the only values used for validation, execution, and recording.
+        runId = requestRecord.run_id;
+        dag = requestRecord.dag;
+        input = requestRecord.input;
+        runners = requestRecord.runners;
+    }
+    catch {
+        throw invalidRequest('request fields must be readable');
+    }
+    if (typeof runId !== 'string' || runId.trim().length === 0) {
+        throw invalidRequest('request.run_id must be a non-empty string');
+    }
+    try {
+        if (!isPlainRecord(runners)) {
+            throw invalidRequest('request.runners must be a plain object');
+        }
+    }
+    catch (error) {
+        if (error instanceof JudgmentDAGExecutionError) {
+            throw error;
+        }
+        throw invalidRequest('request.runners must be a readable plain object');
+    }
+    return { run_id: runId, dag, input, runners };
+}
+function snapshotRequestJSON(value, path) {
+    try {
+        return snapshotJSON(value, path);
+    }
+    catch (error) {
+        if (error instanceof JudgmentDAGExecutionError) {
+            throw error;
+        }
+        throw invalidRequest(`${path} must be readable`);
+    }
+}
+function snapshotRunnerOutput(value, node) {
+    try {
+        return snapshotJSON(value, `node ${node.id} output`);
+    }
+    catch {
+        // Runner output is an untrusted boundary. Do not expose an arbitrary
+        // getter/proxy exception or preserve it as cause; retain only stable node
+        // context in the public machine-readable error.
+        throw new JudgmentDAGExecutionError('invalid_json', `node ${node.id} output must be a JSON value`, {
+            node_id: node.id,
+            node_type: node.node_type,
+            runner_type: node.runner_type
+        });
+    }
+}
+function validateRequestDAG(value) {
+    try {
+        return validateJudgmentDAG(value);
+    }
+    catch (error) {
+        if (error instanceof JudgmentDAGValidationError) {
+            throw error;
+        }
+        throw invalidRequest('request.dag must be readable');
+    }
+}
+function requiredRunnerEntries(dag, executionOrder, runners) {
+    const nodeById = new Map(dag.nodes.map((node) => [node.id, node]));
+    const required = new Map();
+    for (const nodeId of executionOrder) {
+        const node = nodeById.get(nodeId);
+        if (node === undefined) {
+            throw invalidRequest(`validated execution order references unknown node ${nodeId}`);
+        }
+        const runnerType = node.runner_type;
+        if (required.has(runnerType)) {
+            continue;
+        }
+        let hasRegistration;
+        let registration;
+        try {
+            hasRegistration = Object.prototype.hasOwnProperty.call(runners, runnerType);
+            registration = hasRegistration ? runners[runnerType] : undefined;
+        }
+        catch {
+            throw new JudgmentDAGExecutionError('invalid_runner', `Runner registration for ${runnerType} is invalid`, { node_id: node.id, runner_type: runnerType });
+        }
+        if (!hasRegistration || registration === undefined) {
+            throw new JudgmentDAGExecutionError('missing_runner', `DAG node ${node.id} requires a ${runnerType} runner registration`, { node_id: node.id, runner_type: runnerType });
+        }
+        let registrationRecord;
+        let version = undefined;
+        let run = undefined;
+        try {
+            registrationRecord = isPlainRecord(registration) ? registration : undefined;
+            if (registrationRecord !== undefined) {
+                version = registrationRecord.version;
+                run = registrationRecord.run;
+            }
+        }
+        catch {
+            throw new JudgmentDAGExecutionError('invalid_runner', `Runner registration for ${runnerType} is invalid`, { node_id: node.id, runner_type: runnerType });
+        }
+        if (registrationRecord === undefined ||
+            typeof version !== 'string' ||
+            version.trim().length === 0 ||
+            typeof run !== 'function') {
+            throw new JudgmentDAGExecutionError('invalid_runner', `Runner registration for ${runnerType} is invalid`, { node_id: node.id, runner_type: runnerType });
+        }
+        // Capture the registration's immutable contract before the first runner
+        // invocation. A runner is allowed to close over the caller's registration
+        // object, so retaining that object here would let it rewrite the version
+        // recorded for nodes that execute later in the same run.
+        required.set(runnerType, {
+            version,
+            run: run
+        });
+    }
+    return required;
+}
+/**
+ * Execute a validated local DAG sequentially using only explicit runner
+ * registrations. No clock, randomness, filesystem, network, or persistence
+ * is consulted by this function.
+ */
+export async function executeJudgmentDAG(request) {
+    const requestSnapshot = snapshotRequest(request);
+    const runIdSnapshot = requestSnapshot.run_id;
+    // Keep the validator's machine-readable error and details intact. Validate
+    // the captured source before cloning, then validate the exact JSON snapshot
+    // that will be executed and recorded so no later mutation can change the
+    // execution order or node lookup basis.
+    validateRequestDAG(requestSnapshot.dag);
+    const dagSnapshot = snapshotRequestJSON(requestSnapshot.dag, 'request.dag');
+    const validation = validateRequestDAG(dagSnapshot);
+    const inputSnapshot = snapshotRequestJSON(requestSnapshot.input, 'request.input');
+    const runners = requiredRunnerEntries(dagSnapshot, validation.execution_order, requestSnapshot.runners);
+    const nodeById = new Map(dagSnapshot.nodes.map((node) => [node.id, node]));
+    const outputByNode = new Map();
+    const nodeRecords = [];
+    for (const nodeId of validation.execution_order) {
+        const node = nodeById.get(nodeId);
+        if (node === undefined) {
+            throw invalidRequest(`validated execution order references unknown node ${nodeId}`);
+        }
+        const registration = runners.get(node.runner_type);
+        if (registration === undefined) {
+            throw new JudgmentDAGExecutionError('missing_runner', `DAG node ${node.id} requires a ${node.runner_type} runner registration`, { node_id: node.id, runner_type: node.runner_type });
+        }
+        const dependencyOutputs = node.depends_on
+            .slice()
+            .sort()
+            .map((dependencyId) => {
+            const output = outputByNode.get(dependencyId);
+            if (output === undefined) {
+                throw invalidRequest(`dependency ${dependencyId} has not executed before ${node.id}`);
+            }
+            return {
+                node_id: dependencyId,
+                output
+            };
+        });
+        const runnerInput = deepFreeze({
+            run_id: runIdSnapshot,
+            dag: dagSnapshot,
+            node,
+            input: inputSnapshot,
+            dependency_outputs: dependencyOutputs
+        });
+        let rawOutput;
+        let runnerResult;
+        try {
+            runnerResult = registration.run(runnerInput);
+        }
+        catch (error) {
+            throw new JudgmentDAGExecutionError('runner_failed', `Runner ${node.runner_type} failed for node ${node.id}`, {
+                node_id: node.id,
+                runner_type: node.runner_type,
+                failure_kind: 'sync_throw',
+                cause: error
+            });
+        }
+        try {
+            rawOutput = await runnerResult;
+        }
+        catch (error) {
+            throw new JudgmentDAGExecutionError('runner_failed', `Runner ${node.runner_type} failed for node ${node.id}`, {
+                node_id: node.id,
+                runner_type: node.runner_type,
+                failure_kind: 'async_reject',
+                cause: error
+            });
+        }
+        const output = snapshotRunnerOutput(rawOutput, node);
+        outputByNode.set(node.id, output);
+        nodeRecords.push({
+            node_id: node.id,
+            runner_type: node.runner_type,
+            runner_version: registration.version,
+            input_contract: node.input_contract,
+            output_contract: node.output_contract,
+            input: inputSnapshot,
+            dependency_outputs: dependencyOutputs,
+            output
+        });
+    }
+    const runnerVersions = [...runners.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([runner_type, registration]) => ({ runner_type, version: registration.version }));
+    return deepFreeze({
+        run_id: runIdSnapshot,
+        dag: dagSnapshot,
+        input: inputSnapshot,
+        execution_order: validation.execution_order.slice(),
+        runner_versions: runnerVersions,
+        nodes: nodeRecords
+    });
+}

package/dist/judgment-dag.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 { executeJudgmentDAG, JudgmentDAGExecutionError } from './judgment-dag-runner.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';

package/dist/judgment-dag.js

@@ -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 { executeJudgmentDAG, JudgmentDAGExecutionError } from './judgment-dag-runner.js';

package/dist/judgment-host.d.ts

@@ -1,3 +1,4 @@
+import { type JudgmentAutonomyEvaluation, type JudgmentAutonomyResolver } from './judgment-autonomy.js';
 type Environment = Record<string, string | undefined>;
 export interface ConversationMessage {
     sequence?: number;
@@ -104,8 +105,12 @@ export interface JudgmentHookOutput {
 export interface JudgmentHostOptions {
     env?: Environment;
     resolver?: (request: JudgmentRequest) => Promise<JudgmentReceipt>;
+    autonomyResolver?: JudgmentAutonomyResolver;
+    autonomyMode?: JudgmentAutonomyMode;
+    autonomyCanaryProjects?: readonly string[];
     trustedConversationMessages?: ConversationMessage[];
 }
+export type JudgmentAutonomyMode = 'off' | 'canary' | 'on';
 interface LocalResolverOptions {
     now?: () => Date;
     id?: () => string;
@@ -179,8 +184,24 @@ export interface JudgmentFinalReceipt {
     owner_audit_line_count?: number;
     final_digest: string;
 }
+export interface JudgmentAutonomyReceipt {
+    schema_version: 'brainbase-judgment-autonomy-receipt-v1';
+    session_ref: string;
+    turn_id: string;
+    recorded_at: string;
+    mode: Exclude<JudgmentAutonomyMode, 'off'>;
+    project_code: string | null;
+    case_id: string;
+    verdict: JudgmentAutonomyEvaluation['verdict'];
+    reason_code: JudgmentAutonomyEvaluation['reason_code'];
+    source: JudgmentAutonomyEvaluation['source'];
+    question_digest: string | null;
+    basis_entity_ids: string[];
+    autonomy_digest: string;
+}
 export interface JudgmentStopBlock {
     decision: 'block';
+    block_kind?: 'autonomy_continue' | 'audit_repair';
     reason: string;
 }
 export declare function canonicalJson(value: unknown): string;

package/dist/judgment-host.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { closeSync, constants as fsConstants, fsyncSync, linkSync, mkdirSync, openSync, readdirSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { evaluateJudgmentAutonomy, renderJudgmentAutonomyContinuation } from './judgment-autonomy.js';
 const RUNTIME_VERSION = 'portable-judgment-runtime-1.0.0';
 const ZERO_CALL_DISPLAY_LINE = '📚 Brainbase未参照: 必須参照なし・実呼び出し0回 ✓';
 const PORTABLE_KNOWLEDGE_TOOLS = {
@@ -306,6 +307,7 @@ function journalPaths(sessionRef, turnId, env) {
         events: join(directory, `${turnRef}.events`),
         final: join(directory, `${turnRef}.final.json`),
         continuation: join(directory, `${turnRef}.continuation.json`),
+        autonomy: join(directory, `${turnRef}.autonomy`),
         lock: join(directory, `${turnRef}.lock`)
     };
 }
@@ -1334,6 +1336,180 @@ async function recordToolUse(payload, env) {
         return event;
     });
 }
+function resolveAutonomyMode(options, env) {
+    const rawMode = options.autonomyMode ?? env.BRAINBASE_JUDGMENT_AUTONOMY_MODE ?? 'off';
+    if (!['off', 'canary', 'on'].includes(rawMode)) {
+        throw new Error('judgment_autonomy_mode_invalid');
+    }
+    const configuredProjects = options.autonomyCanaryProjects
+        ?? (env.BRAINBASE_JUDGMENT_AUTONOMY_CANARY_PROJECTS ?? '').split(',');
+    const canaryProjects = [...new Set(configuredProjects.map((value) => value.trim()).filter(Boolean))];
+    if (rawMode === 'canary' && canaryProjects.length === 0) {
+        throw new Error('judgment_autonomy_canary_project_missing');
+    }
+    return { mode: rawMode, canaryProjects };
+}
+function readAutonomyReceipt(path) {
+    const value = readJsonArtifact(path);
+    if (value.schema_version !== 'brainbase-judgment-autonomy-receipt-v1'
+        || typeof value.session_ref !== 'string'
+        || typeof value.turn_id !== 'string'
+        || typeof value.recorded_at !== 'string'
+        || !['canary', 'on'].includes(String(value.mode))
+        || (value.project_code !== null && typeof value.project_code !== 'string')
+        || typeof value.case_id !== 'string'
+        || !['continue', 'human_required', 'not_applicable'].includes(String(value.verdict))
+        || typeof value.reason_code !== 'string'
+        || !['deterministic', 'same_codex', 'independent_resolver'].includes(String(value.source))
+        || (value.question_digest !== null && typeof value.question_digest !== 'string')
+        || !Array.isArray(value.basis_entity_ids)
+        || !value.basis_entity_ids.every((entry) => typeof entry === 'string')
+        || typeof value.autonomy_digest !== 'string') {
+        throw new Error(`judgment_journal_invalid:${basename(path)}`);
+    }
+    if (value.autonomy_digest !== artifactDigest(value, 'autonomy_digest')) {
+        throw new Error(`judgment_autonomy_receipt_digest_mismatch:${basename(path)}`);
+    }
+    return value;
+}
+function autonomyReceiptProjection(receipt) {
+    const { recorded_at: _recordedAt, autonomy_digest: _digest, ...projection } = receipt;
+    return projection;
+}
+function persistAutonomyReceipt(paths, sessionRef, snapshot, evaluation, mode) {
+    const path = join(paths.autonomy, `${evaluation.case_id}.json`);
+    const basisEntityIds = evaluation.resolver_decision?.basis.map((entry) => entry.entity_id) ?? [];
+    const receiptWithoutDigest = {
+        schema_version: 'brainbase-judgment-autonomy-receipt-v1',
+        session_ref: sessionRef,
+        turn_id: snapshot.context.turn_id,
+        recorded_at: new Date().toISOString(),
+        mode,
+        project_code: snapshot.context.project_code ?? null,
+        case_id: evaluation.case_id,
+        verdict: evaluation.verdict,
+        reason_code: evaluation.reason_code,
+        source: evaluation.source,
+        question_digest: evaluation.question ? sha256(evaluation.question) : null,
+        basis_entity_ids: basisEntityIds
+    };
+    const receipt = {
+        ...receiptWithoutDigest,
+        autonomy_digest: artifactDigest(receiptWithoutDigest, 'autonomy_digest')
+    };
+    try {
+        const existing = readAutonomyReceipt(path);
+        if (canonicalJson(autonomyReceiptProjection(existing)) !== canonicalJson(autonomyReceiptProjection(receipt))) {
+            throw new Error('judgment_autonomy_receipt_conflict');
+        }
+        return existing;
+    }
+    catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT'))
+            throw error;
+    }
+    writeImmutableJson(path, receipt);
+    return receipt;
+}
+async function autonomyStopSnapshot(payload, env) {
+    const answer = typeof payload.last_assistant_message === 'string' ? payload.last_assistant_message : '';
+    if (!answer.trim())
+        return null;
+    const { sessionRef, turnId } = hookIdentity(payload);
+    const paths = journalPaths(sessionRef, turnId, env);
+    return withTurnLock(paths.lock, async () => {
+        let episode;
+        try {
+            episode = readEpisode(paths.episode);
+            verifyEpisodeAdoption(episode, paths.target);
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                throw new Error('judgment_orphan_stop');
+            }
+            throw error;
+        }
+        if (episode.session_ref !== sessionRef || episode.turn_id !== turnId) {
+            throw new Error('judgment_episode_binding_mismatch');
+        }
+        try {
+            readFinal(paths.final);
+            return null;
+        }
+        catch (error) {
+            if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT'))
+                throw error;
+        }
+        const events = readEvents(paths.events);
+        return {
+            episode_digest: episode.episode_digest,
+            event_set_digest: sha256(canonicalJson(events)),
+            context: {
+                turn_id: turnId,
+                request: episode.adoption.request.request,
+                final_answer: answer,
+                ...(episode.adoption.receipt.project_code
+                    ? { project_code: episode.adoption.receipt.project_code }
+                    : {}),
+                selected_dag_ids: [...episode.adoption.receipt.selected_dag_ids]
+            }
+        };
+    });
+}
+async function evaluateAutonomyStop(payload, env, options) {
+    const config = resolveAutonomyMode(options, env);
+    if (config.mode === 'off')
+        return null;
+    const snapshot = await autonomyStopSnapshot(payload, env);
+    if (!snapshot)
+        return null;
+    if (config.mode === 'canary'
+        && (!snapshot.context.project_code || !config.canaryProjects.includes(snapshot.context.project_code))) {
+        return null;
+    }
+    // A resumed Stop must not invoke an independent LLM twice. Reclassify with
+    // the pure fallback only; repeated routine/semantic escalation fails loud.
+    const evaluation = await evaluateJudgmentAutonomy(snapshot.context, payload.stop_hook_active === true ? undefined : options.autonomyResolver);
+    const { sessionRef, turnId } = hookIdentity(payload);
+    const paths = journalPaths(sessionRef, turnId, env);
+    const stillActive = await withTurnLock(paths.lock, async () => {
+        const episode = readEpisode(paths.episode);
+        verifyEpisodeAdoption(episode, paths.target);
+        if (episode.episode_digest !== snapshot.episode_digest) {
+            throw new Error('judgment_autonomy_episode_changed');
+        }
+        const events = readEvents(paths.events);
+        if (sha256(canonicalJson(events)) !== snapshot.event_set_digest) {
+            throw new Error('judgment_autonomy_event_set_changed');
+        }
+        try {
+            readFinal(paths.final);
+            return false;
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+                return true;
+            throw error;
+        }
+    });
+    if (!stillActive)
+        return null;
+    if (evaluation.verdict === 'continue' && payload.stop_hook_active === true) {
+        throw new Error('judgment_autonomy_continuation_exhausted');
+    }
+    if (evaluation.verdict !== 'not_applicable') {
+        await withTurnLock(paths.lock, async () => {
+            persistAutonomyReceipt(paths, sessionRef, snapshot, evaluation, config.mode);
+        });
+    }
+    if (evaluation.verdict !== 'continue')
+        return null;
+    return {
+        decision: 'block',
+        block_kind: 'autonomy_continue',
+        reason: renderJudgmentAutonomyContinuation(evaluation)
+    };
+}
 async function finalizeEpisode(payload, env) {
     const { sessionRef, turnId } = hookIdentity(payload);
     const paths = journalPaths(sessionRef, turnId, env);
@@ -1423,6 +1599,7 @@ async function finalizeEpisode(payload, env) {
             ];
             return {
                 decision: 'block',
+                block_kind: 'audit_repair',
                 reason: `Brainbase judgment episodeを完了する前に${reasons.join('。その後')}。監査行の後に、元の回答本文をそのまま続けてください。`
             };
         }
@@ -1457,6 +1634,9 @@ export async function processJudgmentHook(payload, options = {}) {
         return event ? { systemMessage: event.display_line } : {};
     }
     if (eventName === 'Stop') {
+        const autonomyBlock = await evaluateAutonomyStop(payload, env, options);
+        if (autonomyBlock)
+            return autonomyBlock;
         const output = await finalizeEpisode(payload, env);
         if ('decision' in output && output.decision === 'block' && payload.stop_hook_active === true) {
             throw new Error('judgment_stop_repair_exhausted');