@unson/brainbase-mcp 0.43.0 → 0.44.1

package/dist/judgment-execution-outcome.js

@@ -0,0 +1,149 @@
+/**
+ * Portable execution outcome contract shared by a judgment Host and its
+ * adapters.  The contract deliberately carries references only; transcript,
+ * process, Task, and delivery details stay at the Host boundary.
+ */
+export const JUDGMENT_EXECUTION_OUTCOME_SCHEMA_VERSION = 'judgment_execution_outcome.v1';
+const FIELDS = new Set([
+    'schema_version', 'host', 'execution_id', 'turn_id', 'scope', 'status', 'stage',
+    'failure', 'resume_from', 'evidence'
+]);
+const HOST_FIELDS = new Set(['type', 'adapter_id', 'adapter_version']);
+const FAILURE_FIELDS = new Set(['code', 'summary', 'upstream_code', 'retryable']);
+const EVIDENCE_FIELDS = new Set(['state', 'refs']);
+const STATUSES = new Set(['completed', 'partial', 'failed', 'blocked', 'unknown']);
+const STAGES = new Set(['open', 'resolve', 'execute', 'finalize', 'deliver', 'readback']);
+const EVIDENCE_STATES = new Set(['confirmed', 'unconfirmed', 'no_data']);
+const HOST_TYPES = new Set(['codex', 'claude-code']);
+const SCOPES = new Set(['host_turn', 'external_effect']);
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+function object(value, field) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new TypeError(`${field} must be an object`);
+    }
+    return value;
+}
+function exact(value, allowed, field) {
+    const record = object(value, field);
+    for (const key of Object.keys(record)) {
+        if (!allowed.has(key))
+            throw new TypeError(`${field}.${key} is not allowed`);
+    }
+    return record;
+}
+function id(value, field) {
+    if (typeof value !== 'string' || !ID.test(value))
+        throw new TypeError(`${field} is invalid`);
+    return value;
+}
+function text(value, field) {
+    if (typeof value !== 'string'
+        || !value.trim()
+        || value.length > 1000
+        || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u.test(value)) {
+        throw new TypeError(`${field} is invalid`);
+    }
+    return value;
+}
+function ref(value, field) {
+    if (typeof value !== 'string'
+        || !value.trim()
+        || value.length > 512
+        || /[\u0000-\u001f\u007f]/u.test(value)) {
+        throw new TypeError(`${field} is invalid`);
+    }
+    return value;
+}
+function evidenceRef(value, field) {
+    const normalized = ref(value, field);
+    if (normalized.startsWith('/') || /^file:/iu.test(normalized)) {
+        throw new TypeError(`${field} is invalid`);
+    }
+    return normalized;
+}
+/**
+ * Validate and normalize a host execution outcome.
+ *
+ * The function intentionally rejects unknown keys and unsafe filesystem
+ * references so adapters cannot accidentally turn private runtime state into
+ * a public contract.
+ */
+export function normalizeJudgmentExecutionOutcome(input) {
+    const outcome = exact(input, FIELDS, 'outcome');
+    if (outcome.schema_version !== JUDGMENT_EXECUTION_OUTCOME_SCHEMA_VERSION) {
+        throw new TypeError('schema_version is invalid');
+    }
+    const hostInput = exact(outcome.host, HOST_FIELDS, 'host');
+    const host = {
+        type: id(hostInput.type, 'host.type'),
+        adapter_id: id(hostInput.adapter_id, 'host.adapter_id'),
+        adapter_version: id(hostInput.adapter_version, 'host.adapter_version')
+    };
+    if (!HOST_TYPES.has(host.type))
+        throw new TypeError('host.type is not registered');
+    if (!SCOPES.has(outcome.scope))
+        throw new TypeError('scope is invalid');
+    if (!STATUSES.has(outcome.status))
+        throw new TypeError('status is invalid');
+    if (!STAGES.has(outcome.stage))
+        throw new TypeError('stage is invalid');
+    const evidenceInput = exact(outcome.evidence, EVIDENCE_FIELDS, 'evidence');
+    if (!EVIDENCE_STATES.has(evidenceInput.state)) {
+        throw new TypeError('evidence.state is invalid');
+    }
+    if (!Array.isArray(evidenceInput.refs))
+        throw new TypeError('evidence.refs is invalid');
+    let evidenceRefs;
+    try {
+        evidenceRefs = evidenceInput.refs.map((reference, index) => evidenceRef(reference, `evidence.refs[${index}]`));
+    }
+    catch {
+        throw new TypeError('evidence.refs is invalid');
+    }
+    const status = outcome.status;
+    const scope = outcome.scope;
+    const stage = outcome.stage;
+    const evidenceState = evidenceInput.state;
+    const incomplete = status !== 'completed';
+    if (incomplete && (!outcome.failure || !outcome.resume_from)) {
+        throw new TypeError('failure and resume_from are required for a non-completed outcome');
+    }
+    let failure = null;
+    if (outcome.failure != null) {
+        const failureInput = exact(outcome.failure, FAILURE_FIELDS, 'failure');
+        failure = {
+            code: id(failureInput.code, 'failure.code'),
+            summary: text(failureInput.summary, 'failure.summary'),
+            upstream_code: failureInput.upstream_code == null
+                ? null
+                : id(failureInput.upstream_code, 'failure.upstream_code'),
+            retryable: failureInput.retryable
+        };
+        if (typeof failure.retryable !== 'boolean')
+            throw new TypeError('failure.retryable is invalid');
+    }
+    if (status === 'completed' && (failure || outcome.resume_from != null)) {
+        throw new TypeError('completed outcome cannot have failure or resume_from');
+    }
+    if (status === 'completed' && (evidenceState !== 'confirmed' || evidenceRefs.length === 0)) {
+        throw new TypeError('completed outcome requires confirmed evidence refs');
+    }
+    if (status === 'completed' && scope === 'external_effect' && stage !== 'readback') {
+        throw new TypeError('completed external effect requires readback');
+    }
+    if (status === 'completed' && scope === 'host_turn' && stage !== 'finalize') {
+        throw new TypeError('completed host turn requires finalize');
+    }
+    return {
+        schema_version: JUDGMENT_EXECUTION_OUTCOME_SCHEMA_VERSION,
+        host,
+        execution_id: ref(outcome.execution_id, 'execution_id'),
+        turn_id: ref(outcome.turn_id, 'turn_id'),
+        scope,
+        status,
+        stage,
+        failure,
+        resume_from: outcome.resume_from == null ? null : id(outcome.resume_from, 'resume_from'),
+        evidence: { state: evidenceState, refs: evidenceRefs }
+    };
+}

package/dist/judgment-host.d.ts

@@ -1,4 +1,5 @@
 import { type JudgmentAutonomyEvaluation, type JudgmentAutonomyResolver } from './judgment-autonomy.js';
+import type { JudgmentKnowledgeEventSink } from './judgment-event-outbox.js';
 import { canonicalJson } from './judgment-resolution-contract.js';
 type Environment = Record<string, string | undefined>;
 export interface ConversationMessage {
@@ -59,6 +60,16 @@ export interface JudgmentNodeDefinition {
     kind: 'common' | 'judgment' | 'constraint' | 'clarification';
     instruction: string;
 }
+/**
+ * The resolver adapter binding accepted by the Host. The adapter identity is
+ * supplied by the Host configuration and is never inferred from a receipt.
+ */
+export interface JudgmentHostBinding {
+    adapter_id: string;
+    adapter_version: string;
+    status: 'managed';
+    enforcement_level: 'host_contract';
+}
 export interface JudgmentReceipt {
     resolution_id: string;
     resolved_at: string;
@@ -69,12 +80,7 @@ export interface JudgmentReceipt {
     status: 'resolved' | 'needs_clarification';
     runtime_version: string;
     manifest_digest: string;
-    host_binding: {
-        adapter_id: 'brainbase-local';
-        adapter_version: '1';
-        status: 'managed';
-        enforcement_level: 'host_contract';
-    };
+    host_binding: JudgmentHostBinding;
     project_code?: string;
     classification: JudgmentClassification | null;
     classification_evidence: {
@@ -106,10 +112,14 @@ export interface JudgmentHookOutput {
 export interface JudgmentHostOptions {
     env?: Environment;
     resolver?: (request: JudgmentRequest) => Promise<JudgmentReceipt>;
+    /** Expected resolver binding; defaults to the built-in local adapter. */
+    expectedHostBinding?: JudgmentHostBinding;
     autonomyResolver?: JudgmentAutonomyResolver;
     autonomyMode?: JudgmentAutonomyMode;
     autonomyCanaryProjects?: readonly string[];
     trustedConversationMessages?: ConversationMessage[];
+    /** Optional adapter-owned queue. The default Host lifecycle remains unchanged. */
+    knowledgeEventSink?: JudgmentKnowledgeEventSink;
 }
 export type JudgmentAutonomyMode = 'off' | 'canary' | 'on';
 interface LocalResolverOptions {
@@ -206,9 +216,10 @@ export interface JudgmentStopBlock {
     reason: string;
 }
 export { canonicalJson };
-export declare function buildJudgmentRequest(payload: JudgmentHookPayload, { env, trustedConversationMessages }?: {
+export declare function buildJudgmentRequest(payload: JudgmentHookPayload, { env, trustedConversationMessages, expectedHostBinding }?: {
     env?: Environment;
     trustedConversationMessages?: ConversationMessage[];
+    expectedHostBinding?: JudgmentHostBinding;
 }): JudgmentRequest;
 export declare function resolveLocalJudgment(request: JudgmentRequest, options?: LocalResolverOptions): Promise<JudgmentReceipt>;
 export declare function buildOwnerAudit(request: JudgmentRequest, receipt: JudgmentReceipt, { historicalExact }?: {

package/dist/judgment-host.js

@@ -3,7 +3,14 @@ import { closeSync, constants as fsConstants, fsyncSync, linkSync, mkdirSync, op
 import { homedir } from 'node:os';
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { evaluateJudgmentAutonomy, renderJudgmentAutonomyContinuation } from './judgment-autonomy.js';
+import { toKnowledgeEventFromJudgmentEpisode } from './judgment-event-adapter.js';
 import { canonicalJson } from './judgment-resolution-contract.js';
+const DEFAULT_HOST_BINDING = Object.freeze({
+    adapter_id: 'brainbase-local',
+    adapter_version: '1',
+    status: 'managed',
+    enforcement_level: 'host_contract'
+});
 const RUNTIME_VERSION = 'portable-judgment-runtime-1.0.0';
 const ZERO_CALL_DISPLAY_LINE = '📚 Brainbase未参照: 必須参照なし・実呼び出し0回 ✓';
 const PORTABLE_KNOWLEDGE_TOOLS = {
@@ -71,6 +78,24 @@ function sha256(value) {
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
 }
+function normalizeExpectedHostBinding(value) {
+    const candidate = value === undefined ? DEFAULT_HOST_BINDING : record(value);
+    if (!candidate
+        || typeof candidate.adapter_id !== 'string'
+        || candidate.adapter_id.trim().length === 0
+        || typeof candidate.adapter_version !== 'string'
+        || candidate.adapter_version.trim().length === 0
+        || candidate.status !== 'managed'
+        || candidate.enforcement_level !== 'host_contract') {
+        throw new Error('judgment_host_binding_config_invalid');
+    }
+    return {
+        adapter_id: candidate.adapter_id,
+        adapter_version: candidate.adapter_version,
+        status: 'managed',
+        enforcement_level: 'host_contract'
+    };
+}
 function contentText(content) {
     if (typeof content === 'string')
         return content;
@@ -298,7 +323,8 @@ function acceptedProjection(receipt) {
         selected_dag_ids: receipt.selected_dag_ids
     };
 }
-function readAdoptionEntry(path) {
+function readAdoptionEntry(path, expectedHostBinding = DEFAULT_HOST_BINDING) {
+    const expectedBinding = normalizeExpectedHostBinding(expectedHostBinding);
     let parsed;
     try {
         parsed = JSON.parse(readFileSync(path, 'utf8'));
@@ -326,7 +352,7 @@ function readAdoptionEntry(path) {
     if (entry.request_text_digest !== sha256(request.request)) {
         throw new Error(`judgment_journal_request_digest_mismatch:${basename(path)}`);
     }
-    const verifiedReceipt = verifyReceipt(receipt, request);
+    const verifiedReceipt = verifyReceipt(receipt, request, expectedBinding);
     if (entry.schema_version === 'brainbase-judgment-adoption-v2') {
         if (typeof entry.receipt_digest !== 'string'
             || entry.receipt_digest !== sha256(canonicalJson(verifiedReceipt))) {
@@ -351,7 +377,7 @@ function readAdoptionEntry(path) {
         owner_audit: buildOwnerAudit(request, verifiedReceipt, { historicalExact: false })
     };
 }
-function priorReceipts(sessionRef, currentTurnId, env) {
+function priorReceipts(sessionRef, currentTurnId, env, expectedHostBinding = DEFAULT_HOST_BINDING) {
     const { directory, target } = journalPaths(sessionRef, currentTurnId, env);
     let names;
     try {
@@ -363,7 +389,7 @@ function priorReceipts(sessionRef, currentTurnId, env) {
         throw error;
     }
     return names.filter((name) => name !== basename(target)).map((name) => {
-        const entry = readAdoptionEntry(join(directory, name));
+        const entry = readAdoptionEntry(join(directory, name), expectedHostBinding);
         if (entry.request.conversation_context.session_ref !== sessionRef) {
             throw new Error(`judgment_journal_session_mismatch:${name}`);
         }
@@ -371,7 +397,7 @@ function priorReceipts(sessionRef, currentTurnId, env) {
     }).sort((left, right) => left.accepted_at.localeCompare(right.accepted_at))
         .map((entry) => entry.projection);
 }
-export function buildJudgmentRequest(payload, { env = process.env, trustedConversationMessages } = {}) {
+export function buildJudgmentRequest(payload, { env = process.env, trustedConversationMessages, expectedHostBinding } = {}) {
     const request = typeof payload.prompt === 'string' && payload.prompt.trim() ? payload.prompt : '';
     const turnId = typeof payload.turn_id === 'string' ? payload.turn_id.trim() : '';
     const sessionId = typeof payload.session_id === 'string' ? payload.session_id : '';
@@ -395,7 +421,7 @@ export function buildJudgmentRequest(payload, { env = process.env, trustedConver
         schema_version: 'brainbase-conversation-context-v1',
         session_ref: sessionRef,
         messages: messages.map((message, sequence) => ({ ...message, sequence })),
-        prior_receipts: priorReceipts(sessionRef, turnId, env),
+        prior_receipts: priorReceipts(sessionRef, turnId, env, expectedHostBinding),
         runtime: {
             host: 'codex',
             model: typeof payload.model === 'string' && payload.model ? payload.model : null,
@@ -599,7 +625,8 @@ function receiptPlanDigest(receipt) {
     delete planValue.plan_digest;
     return sha256(canonicalJson(planValue));
 }
-function verifyReceipt(receipt, request) {
+function verifyReceipt(receipt, request, expectedHostBinding = DEFAULT_HOST_BINDING) {
+    const expectedBinding = normalizeExpectedHostBinding(expectedHostBinding);
     if (!record(receipt) || receipt.turn_id !== request.turn_id)
         throw new Error('judgment_receipt_turn_mismatch');
     if (receipt.request_digest !== sha256(canonicalJson(request)))
@@ -609,10 +636,10 @@ function verifyReceipt(receipt, request) {
     if (receipt.runtime_version !== RUNTIME_VERSION || receipt.manifest_digest !== MANIFEST_DIGEST) {
         throw new Error('judgment_receipt_runtime_mismatch');
     }
-    if (receipt.host_binding?.adapter_id !== 'brainbase-local'
-        || receipt.host_binding.adapter_version !== '1'
-        || receipt.host_binding.status !== 'managed'
-        || receipt.host_binding.enforcement_level !== 'host_contract') {
+    if (receipt.host_binding?.adapter_id !== expectedBinding.adapter_id
+        || receipt.host_binding.adapter_version !== expectedBinding.adapter_version
+        || receipt.host_binding.status !== expectedBinding.status
+        || receipt.host_binding.enforcement_level !== expectedBinding.enforcement_level) {
         throw new Error('judgment_receipt_binding_unmanaged');
     }
     if (!Array.isArray(receipt.active_node_definitions) || receipt.active_node_definitions.length === 0) {
@@ -623,10 +650,10 @@ function verifyReceipt(receipt, request) {
     }
     return receipt;
 }
-function existingAdoption(request, env) {
+function existingAdoption(request, env, expectedHostBinding = DEFAULT_HOST_BINDING) {
     const { target } = journalPaths(request.conversation_context.session_ref, request.turn_id, env);
     try {
-        const entry = readAdoptionEntry(target);
+        const entry = readAdoptionEntry(target, expectedHostBinding);
         if (entry.request_text_digest !== sha256(request.request)
             || entry.request.turn_id !== request.turn_id
             || entry.request.conversation_context.session_ref !== request.conversation_context.session_ref) {
@@ -640,7 +667,7 @@ function existingAdoption(request, env) {
         throw error;
     }
 }
-function existingAdoptionForPayload(payload, env) {
+function existingAdoptionForPayload(payload, env, expectedHostBinding = DEFAULT_HOST_BINDING) {
     const request = typeof payload.prompt === 'string' && payload.prompt.trim() ? payload.prompt : '';
     const turnId = typeof payload.turn_id === 'string' ? payload.turn_id.trim() : '';
     const sessionId = typeof payload.session_id === 'string' ? payload.session_id : '';
@@ -649,7 +676,7 @@ function existingAdoptionForPayload(payload, env) {
     const sessionRef = sha256(sessionId);
     const { target } = journalPaths(sessionRef, turnId, env);
     try {
-        const entry = readAdoptionEntry(target);
+        const entry = readAdoptionEntry(target, expectedHostBinding);
         if (entry.request_text_digest !== sha256(request)
             || entry.request.turn_id !== turnId
             || entry.request.conversation_context.session_ref !== sessionRef) {
@@ -663,7 +690,7 @@ function existingAdoptionForPayload(payload, env) {
         throw error;
     }
 }
-function adoptReceipt(request, receipt, env) {
+function adoptReceipt(request, receipt, env, expectedHostBinding = DEFAULT_HOST_BINDING) {
     const { directory, target } = journalPaths(request.conversation_context.session_ref, request.turn_id, env);
     mkdirSync(directory, { recursive: true, mode: 0o700 });
     const ownerAudit = buildOwnerAudit(request, receipt);
@@ -691,7 +718,7 @@ function adoptReceipt(request, receipt, env) {
         catch (error) {
             if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST'))
                 throw error;
-            return existingAdoption(request, env);
+            return existingAdoption(request, env, expectedHostBinding);
         }
     }
     finally {
@@ -831,8 +858,8 @@ function readEpisode(path) {
     }
     return value;
 }
-function verifyEpisodeAdoption(episode, adoptionPath) {
-    const adoption = readAdoptionEntry(adoptionPath);
+function verifyEpisodeAdoption(episode, adoptionPath, expectedHostBinding = DEFAULT_HOST_BINDING) {
+    const adoption = readAdoptionEntry(adoptionPath, expectedHostBinding);
     if (sha256(canonicalJson(adoption.receipt)) !== episode.initial_receipt_digest
         || adoption.request.turn_id !== episode.turn_id
         || adoption.request.conversation_context.session_ref !== episode.session_ref) {
@@ -1093,6 +1120,7 @@ function successOutput(request, receipt, ownerAudit = buildOwnerAudit(request, r
 }
 export async function runJudgmentHost(payload, options = {}) {
     const env = options.env ?? process.env;
+    const expectedHostBinding = normalizeExpectedHostBinding(options.expectedHostBinding);
     const sessionId = typeof payload.session_id === 'string' ? payload.session_id : '';
     const turnId = typeof payload.turn_id === 'string' ? payload.turn_id.trim() : '';
     if (!sessionId || !turnId)
@@ -1101,7 +1129,7 @@ export async function runJudgmentHost(payload, options = {}) {
     return withTurnLock(paths.lock, async () => {
         try {
             const episode = readEpisode(paths.episode);
-            verifyEpisodeAdoption(episode, paths.target);
+            verifyEpisodeAdoption(episode, paths.target, expectedHostBinding);
             const requestText = typeof payload.prompt === 'string' ? payload.prompt.trim() : '';
             if (!requestText || episode.request_text_digest !== sha256(requestText)) {
                 throw new Error('judgment_episode_binding_mismatch');
@@ -1112,13 +1140,14 @@ export async function runJudgmentHost(payload, options = {}) {
             if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT'))
                 throw error;
         }
-        const adopted = existingAdoptionForPayload(payload, env);
+        const adopted = existingAdoptionForPayload(payload, env, expectedHostBinding);
         const request = adopted?.request ?? buildJudgmentRequest(payload, {
             env,
-            trustedConversationMessages: options.trustedConversationMessages
+            trustedConversationMessages: options.trustedConversationMessages,
+            expectedHostBinding
         });
-        const existing = adopted ?? existingAdoption(request, env);
-        const adoption = existing ?? adoptReceipt(request, verifyReceipt(await (options.resolver ?? resolveLocalJudgment)(request), request), env);
+        const existing = adopted ?? existingAdoption(request, env, expectedHostBinding);
+        const adoption = existing ?? adoptReceipt(request, verifyReceipt(await (options.resolver ?? resolveLocalJudgment)(request), request, expectedHostBinding), env, expectedHostBinding);
         const episodeWithoutDigest = {
             schema_version: 'brainbase-judgment-episode-v1',
             session_ref: request.conversation_context.session_ref,
@@ -1241,7 +1270,7 @@ function toolDisplayLine(tool, input, response, status) {
     const result = selectionParts.length > 0 ? selectionParts.join('／') : '正常応答を確認';
     return `📚 ${contract.label}: 「${target}」→ ${result} ✓`;
 }
-async function recordToolUse(payload, env) {
+async function recordToolUse(payload, env, expectedHostBinding = DEFAULT_HOST_BINDING) {
     const { sessionRef, turnId } = hookIdentity(payload);
     const paths = journalPaths(sessionRef, turnId, env);
     const toolUseId = typeof payload.tool_use_id === 'string' ? payload.tool_use_id.trim() : '';
@@ -1255,7 +1284,7 @@ async function recordToolUse(payload, env) {
         let episode;
         try {
             episode = readEpisode(paths.episode);
-            verifyEpisodeAdoption(episode, paths.target);
+            verifyEpisodeAdoption(episode, paths.target, expectedHostBinding);
         }
         catch (error) {
             if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
@@ -1385,7 +1414,7 @@ function persistAutonomyReceipt(paths, sessionRef, snapshot, evaluation, mode) {
     writeImmutableJson(path, receipt);
     return receipt;
 }
-async function autonomyStopSnapshot(payload, env) {
+async function autonomyStopSnapshot(payload, env, expectedHostBinding = DEFAULT_HOST_BINDING) {
     const answer = typeof payload.last_assistant_message === 'string' ? payload.last_assistant_message : '';
     if (!answer.trim())
         return null;
@@ -1395,7 +1424,7 @@ async function autonomyStopSnapshot(payload, env) {
         let episode;
         try {
             episode = readEpisode(paths.episode);
-            verifyEpisodeAdoption(episode, paths.target);
+            verifyEpisodeAdoption(episode, paths.target, expectedHostBinding);
         }
         catch (error) {
             if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
@@ -1434,7 +1463,7 @@ async function evaluateAutonomyStop(payload, env, options) {
     const config = resolveAutonomyMode(options, env);
     if (config.mode === 'off')
         return null;
-    const snapshot = await autonomyStopSnapshot(payload, env);
+    const snapshot = await autonomyStopSnapshot(payload, env, options.expectedHostBinding);
     if (!snapshot)
         return null;
     if (config.mode === 'canary'
@@ -1448,7 +1477,7 @@ async function evaluateAutonomyStop(payload, env, options) {
     const paths = journalPaths(sessionRef, turnId, env);
     const stillActive = await withTurnLock(paths.lock, async () => {
         const episode = readEpisode(paths.episode);
-        verifyEpisodeAdoption(episode, paths.target);
+        verifyEpisodeAdoption(episode, paths.target, options.expectedHostBinding);
         if (episode.episode_digest !== snapshot.episode_digest) {
             throw new Error('judgment_autonomy_episode_changed');
         }
@@ -1484,7 +1513,7 @@ async function evaluateAutonomyStop(payload, env, options) {
         reason: renderJudgmentAutonomyContinuation(evaluation)
     };
 }
-async function finalizeEpisode(payload, env) {
+async function finalizeEpisode(payload, env, knowledgeEventSink, expectedHostBinding = DEFAULT_HOST_BINDING) {
     const { sessionRef, turnId } = hookIdentity(payload);
     const paths = journalPaths(sessionRef, turnId, env);
     const answerDigest = sha256(typeof payload.last_assistant_message === 'string' ? payload.last_assistant_message : '');
@@ -1492,7 +1521,7 @@ async function finalizeEpisode(payload, env) {
         let episode;
         try {
             episode = readEpisode(paths.episode);
-            verifyEpisodeAdoption(episode, paths.target);
+            verifyEpisodeAdoption(episode, paths.target, expectedHostBinding);
         }
         catch (error) {
             if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
@@ -1512,6 +1541,7 @@ async function finalizeEpisode(payload, env) {
                 || existing.answer_digest !== answerDigest) {
                 throw new Error('judgment_final_conflict');
             }
+            await enqueueFinalizedKnowledgeEvent(knowledgeEventSink, sessionRef, turnId, existing, payload.last_assistant_message ?? '');
             return existing;
         }
         catch (error) {
@@ -1595,23 +1625,41 @@ async function finalizeEpisode(payload, env) {
             final_digest: sha256(canonicalJson(finalWithoutDigest))
         };
         writeImmutableJson(paths.final, final);
+        await enqueueFinalizedKnowledgeEvent(knowledgeEventSink, sessionRef, turnId, final, answer);
         return final;
     });
 }
+async function enqueueFinalizedKnowledgeEvent(sink, sessionRef, turnId, final, answer) {
+    if (!sink)
+        return null;
+    const event = toKnowledgeEventFromJudgmentEpisode({
+        episode_id: `${sessionRef}:${turnId}`,
+        session_id: sessionRef,
+        turn_id: turnId,
+        finalized_at: final.finalized_at,
+        answer_digest: final.answer_digest,
+        completion_status: 'complete',
+        final_answer: answer
+    });
+    if (event)
+        await sink.enqueue(event);
+    return event;
+}
 export async function processJudgmentHook(payload, options = {}) {
     const eventName = payload.hook_event_name ?? payload.hookEventName ?? 'UserPromptSubmit';
     const env = options.env ?? process.env;
+    const expectedHostBinding = normalizeExpectedHostBinding(options.expectedHostBinding);
     if (eventName === 'UserPromptSubmit')
         return runJudgmentHost(payload, options);
     if (eventName === 'PostToolUse') {
-        const event = await recordToolUse(payload, env);
+        const event = await recordToolUse(payload, env, expectedHostBinding);
         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);
+        const output = await finalizeEpisode(payload, env, options.knowledgeEventSink, expectedHostBinding);
         if ('decision' in output && output.decision === 'block' && payload.stop_hook_active === true) {
             throw new Error('judgment_stop_repair_exhausted');
         }