@unson/brainbase-mcp 0.7.0 → 0.9.0

package/dist/judgment-value-proof-review.js

@@ -0,0 +1,437 @@
+import { createHash } from 'node:crypto';
+import { appendFile, mkdir, readdir, readFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { placeJudgmentValueProof, validateJudgmentValueProof } from './judgment-value-proof.js';
+import { defaultDataDir } from './paths.js';
+export const JUDGMENT_VALUE_PROOF_FILE_SUFFIX = '.value-proof.json';
+export const JUDGMENT_VALUE_PROOF_FEEDBACK_SCHEMA = 'brainbase-judgment-value-proof-feedback-v1';
+export const JUDGMENT_VALUE_PROOF_FEEDBACK_FILE = 'judgment-value-proof-feedback.jsonl';
+const FEEDBACK_SUMMARY_LIMIT = 500;
+const DEFAULT_STALE_AFTER_MS = 48 * 60 * 60 * 1000;
+const FEEDBACK_STATUSES = [
+    'accepted',
+    'corrected',
+    'next_time_ask',
+    'reverted'
+];
+const SUMMARY_REQUIRED = ['corrected', 'reverted'];
+export const JUDGMENT_VALUE_PROOF_FEEDBACK_LAYERS = [
+    'delegation',
+    'method',
+    'objective',
+    'world_model',
+    'philosophy',
+    'other'
+];
+export function defaultJudgmentJournalRoot(dataDir = defaultDataDir()) {
+    return join(resolve(dataDir), 'judgment-journal');
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function errorCode(error) {
+    return typeof error === 'object' && error !== null && 'code' in error
+        ? String(error.code)
+        : undefined;
+}
+function compareRecordedAtDesc(left, right) {
+    return left < right ? 1 : left > right ? -1 : 0;
+}
+async function readProofFile(file) {
+    try {
+        const proof = validateJudgmentValueProof(JSON.parse(await readFile(file, 'utf8')));
+        return { file, proof };
+    }
+    catch (error) {
+        return { file, reason: errorMessage(error) };
+    }
+}
+/**
+ * Reads saved judgment value proofs from `<root>/*.value-proof.json` and
+ * `<root>/<session>/*.value-proof.json`. The journal is read-only here.
+ */
+export async function readJudgmentValueProofJournal(options = {}) {
+    const root = resolve(options.root ?? defaultJudgmentJournalRoot());
+    let topLevel;
+    try {
+        topLevel = await readdir(root, { withFileTypes: true });
+    }
+    catch (error) {
+        const code = errorCode(error);
+        const reason = code === 'ENOENT'
+            ? 'judgment_journal_not_found'
+            : code === 'ENOTDIR'
+                ? 'judgment_journal_not_directory'
+                : `judgment_journal_unreadable:${code ?? errorMessage(error)}`;
+        return { status: 'unavailable', root, reason };
+    }
+    const files = [];
+    for (const entry of topLevel) {
+        const path = join(root, entry.name);
+        if (entry.isFile() && entry.name.endsWith(JUDGMENT_VALUE_PROOF_FILE_SUFFIX)) {
+            files.push(path);
+        }
+        else if (entry.isDirectory()) {
+            const nested = await readdir(path, { withFileTypes: true });
+            for (const child of nested) {
+                if (child.isFile() && child.name.endsWith(JUDGMENT_VALUE_PROOF_FILE_SUFFIX)) {
+                    files.push(join(path, child.name));
+                }
+            }
+        }
+    }
+    const results = await Promise.all(files.sort().map(readProofFile));
+    const entries = results
+        .filter((result) => 'proof' in result)
+        .sort((left, right) => compareRecordedAtDesc(left.proof.recorded_at, right.proof.recorded_at)
+        || left.file.localeCompare(right.file));
+    const rejected = results.filter((result) => 'reason' in result);
+    return {
+        status: 'available',
+        root,
+        entries,
+        rejected,
+        latest_recorded_at: entries[0]?.proof.recorded_at ?? null
+    };
+}
+export function classifyJudgmentValueProof(proof) {
+    if (placeJudgmentValueProof(proof).web_surface === 'none')
+        return 'other';
+    if (proof.state === 'waiting_human')
+        return 'needs_human';
+    if (proof.state === 'blocked')
+        return 'blocked';
+    if (proof.interruption.resolution === 'continued_without_human')
+        return 'continued';
+    return 'other';
+}
+function feedbackFile(dataDir) {
+    return join(resolve(dataDir ?? defaultDataDir()), JUDGMENT_VALUE_PROOF_FEEDBACK_FILE);
+}
+function requiredId(value, field) {
+    const normalized = typeof value === 'string' ? value.trim() : '';
+    if (!normalized)
+        throw new TypeError(`${field} must be a non-empty string`);
+    return normalized;
+}
+function normalizeSummary(status, summary) {
+    const normalized = typeof summary === 'string' ? summary.trim() : '';
+    if (!normalized && SUMMARY_REQUIRED.includes(status)) {
+        throw new TypeError(`${status} feedback requires summary`);
+    }
+    if (Array.from(normalized).length > FEEDBACK_SUMMARY_LIMIT) {
+        throw new TypeError(`feedback summary must be at most ${FEEDBACK_SUMMARY_LIMIT} characters`);
+    }
+    return normalized || null;
+}
+/**
+ * `next_time_ask` always targets the delegation boundary; `corrected` must say what it corrects;
+ * `accepted` and `reverted` carry no layer.
+ */
+function normalizeTargetLayer(status, layer) {
+    if (layer !== undefined && layer !== null && !JUDGMENT_VALUE_PROOF_FEEDBACK_LAYERS.includes(layer)) {
+        throw new TypeError(`unsupported feedback target_layer: ${String(layer)}`);
+    }
+    if (status === 'next_time_ask') {
+        if (layer && layer !== 'delegation')
+            throw new TypeError('next_time_ask feedback targets delegation');
+        return 'delegation';
+    }
+    if (status === 'corrected') {
+        if (!layer)
+            throw new TypeError('corrected feedback requires target_layer');
+        return layer;
+    }
+    if (layer)
+        throw new TypeError(`${status} feedback does not take target_layer`);
+    return null;
+}
+function feedbackId(decisionAttemptId, status, layer, summary) {
+    return `sha256:${createHash('sha256').update(`${decisionAttemptId}\n${status}\n${layer ?? ''}\n${summary ?? ''}`).digest('hex')}`;
+}
+function parseFeedbackRecord(line, lineNumber) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch (error) {
+        throw new Error(`judgment_value_proof_feedback_corrupt:line_${lineNumber}`, { cause: error });
+    }
+    if (value.schema_version !== JUDGMENT_VALUE_PROOF_FEEDBACK_SCHEMA
+        || !FEEDBACK_STATUSES.includes(value.status)
+        || typeof value.feedback_id !== 'string'
+        || typeof value.intent_id !== 'string'
+        || typeof value.decision_attempt_id !== 'string'
+        || typeof value.recorded_at !== 'string'
+        || !(value.summary === null || typeof value.summary === 'string')
+        || !(value.target_layer === undefined || value.target_layer === null
+            || JUDGMENT_VALUE_PROOF_FEEDBACK_LAYERS.includes(value.target_layer))) {
+        throw new Error(`judgment_value_proof_feedback_invalid:line_${lineNumber}`);
+    }
+    return value;
+}
+/** Reads all recorded feedback in append order. A missing file means no feedback has been recorded. */
+export async function readJudgmentValueProofFeedback(options = {}) {
+    let text;
+    try {
+        text = await readFile(feedbackFile(options.dataDir), 'utf8');
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return [];
+        throw error;
+    }
+    return text.split('\n')
+        .map((line, index) => ({ line, lineNumber: index + 1 }))
+        .filter(({ line }) => line.trim())
+        .map(({ line, lineNumber }) => parseFeedbackRecord(line, lineNumber));
+}
+/**
+ * Appends one owner feedback record without touching the judgment journal.
+ * Re-sending the same attempt, status and summary returns the existing record.
+ */
+export async function recordJudgmentValueProofFeedback(input) {
+    const intentId = requiredId(input.intent_id, 'intent_id');
+    const decisionAttemptId = requiredId(input.decision_attempt_id, 'decision_attempt_id');
+    if (!FEEDBACK_STATUSES.includes(input.status)) {
+        throw new TypeError(`unsupported feedback status: ${String(input.status)}`);
+    }
+    const summary = normalizeSummary(input.status, input.summary);
+    const targetLayer = normalizeTargetLayer(input.status, input.target_layer);
+    const id = feedbackId(decisionAttemptId, input.status, targetLayer, summary);
+    const existing = (await readJudgmentValueProofFeedback({ dataDir: input.dataDir }))
+        .find((record) => record.feedback_id === id);
+    if (existing)
+        return { record: existing, created: false };
+    const record = {
+        schema_version: JUDGMENT_VALUE_PROOF_FEEDBACK_SCHEMA,
+        feedback_id: id,
+        intent_id: intentId,
+        decision_attempt_id: decisionAttemptId,
+        status: input.status,
+        summary,
+        target_layer: targetLayer,
+        recorded_at: (input.now ?? new Date()).toISOString()
+    };
+    const file = feedbackFile(input.dataDir);
+    await mkdir(dirname(file), { recursive: true });
+    await appendFile(file, `${JSON.stringify(record)}\n`, 'utf8');
+    const readBack = (await readJudgmentValueProofFeedback({ dataDir: input.dataDir }))
+        .find((entry) => entry.feedback_id === id);
+    if (!readBack)
+        throw new Error('judgment_value_proof_feedback_readback_missing');
+    return { record: readBack, created: true };
+}
+/** Returns the proof with its latest owner feedback applied, plus the feedback history for that attempt. */
+export function applyJudgmentValueProofFeedback(proof, records) {
+    const history = records.filter((record) => record.intent_id === proof.intent_id
+        && record.decision_attempt_id === proof.decision_attempt_id);
+    const latest = history.at(-1);
+    if (!latest)
+        return { proof, history };
+    const applied = {
+        ...proof,
+        feedback: {
+            status: latest.status,
+            summary: latest.summary,
+            evidence_ref: {
+                kind: 'human_feedback',
+                ref: `judgment-value-proof-feedback:${latest.feedback_id}`,
+                status: 'verified',
+                label: '本人の評価'
+            }
+        }
+    };
+    return { proof: validateJudgmentValueProof(applied), history };
+}
+export function buildJudgmentValueProofReviewHome(journal, feedback, options = {}) {
+    if (journal.status === 'unavailable')
+        return journal;
+    const sections = {
+        needs_human: [],
+        blocked: [],
+        continued: [],
+        other: []
+    };
+    for (const entry of journal.entries) {
+        const { proof, history } = applyJudgmentValueProofFeedback(entry.proof, feedback);
+        const section = classifyJudgmentValueProof(proof);
+        sections[section].push({ file: entry.file, section, proof, feedback_history: history });
+    }
+    const delegationMap = buildJudgmentDelegationMap([...sections.needs_human, ...sections.blocked, ...sections.continued], feedback);
+    const now = (options.now ?? new Date()).getTime();
+    const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
+    const latest = journal.latest_recorded_at === null ? null : Date.parse(journal.latest_recorded_at);
+    const possiblyStalled = latest === null || Number.isNaN(latest) || now - latest > staleAfterMs;
+    return {
+        status: 'available',
+        root: journal.root,
+        coverage: {
+            saved: journal.entries.length,
+            rejected: journal.rejected.length,
+            latest_recorded_at: journal.latest_recorded_at,
+            possibly_stalled: possiblyStalled
+        },
+        sections,
+        delegation_map: delegationMap,
+        rejected: journal.rejected
+    };
+}
+function delegationRowIdentity(proof) {
+    const kind = proof.decision.judgment_kind;
+    if (kind)
+        return { key: `kind:${kind.key}`, source: 'judgment_kind', label: kind.label };
+    const reason = proof.interruption.reason_code?.trim();
+    if (reason)
+        return { key: `reason:${reason}`, source: 'reason_code', label: reason };
+    return { key: 'unrecorded', source: 'unrecorded', label: null };
+}
+function laterFeedback(left, right) {
+    return !left || right.record.recorded_at > left.record.recorded_at
+        || (right.record.recorded_at === left.record.recorded_at && right.order > left.order);
+}
+function returnsDelegation(record) {
+    return record.status === 'next_time_ask' || record.status === 'reverted'
+        || (record.status === 'corrected' && record.target_layer === 'delegation');
+}
+function newestFirst(entries) {
+    return [...entries].sort((left, right) => compareRecordedAtDesc(left.at, right.at)).map((entry) => entry.ref);
+}
+function itemRef(item, rowKey) {
+    return { intent_id: item.proof.intent_id, decision_attempt_id: item.proof.decision_attempt_id, row_key: rowKey };
+}
+/**
+ * Groups reviewable judgments by kind and decides, per kind, whether Brainbase is trusted to
+ * proceed, is still being checked, or returns the judgment to the owner. Deterministic: the state
+ * follows only the newest judgment and the newest owner feedback in the row.
+ */
+export function buildJudgmentDelegationMap(items, feedback) {
+    const order = new Map(feedback.map((record, index) => [record, index]));
+    const sorted = [...items].sort((left, right) => compareRecordedAtDesc(left.proof.recorded_at, right.proof.recorded_at)
+        || left.file.localeCompare(right.file));
+    const groups = new Map();
+    for (const item of sorted) {
+        const identity = delegationRowIdentity(item.proof);
+        const group = groups.get(identity.key) ?? { identity, items: [] };
+        group.items.push(item);
+        groups.set(identity.key, group);
+    }
+    const correctedAfterContinue = [];
+    const continuedAfterAsk = [];
+    const rows = [];
+    for (const { identity, items: rowItems } of groups.values()) {
+        const byFeedback = { accepted: 0, corrected: 0, next_time_ask: 0, reverted: 0 };
+        let latestFeedback = null;
+        // The first ask is the cutoff: every later judgment that still proceeded without asking ignored it.
+        let firstAsk = null;
+        let continued = 0;
+        let returned = 0;
+        let rated = 0;
+        let inherited = 0;
+        for (const item of rowItems) {
+            const resolution = item.proof.interruption.resolution;
+            if (resolution === 'continued_without_human')
+                continued += 1;
+            if (resolution === 'human_required')
+                returned += 1;
+            if ((item.proof.decision.inheritance?.sources.length ?? 0) > 0)
+                inherited += 1;
+            const latest = item.feedback_history.at(-1);
+            if (latest) {
+                rated += 1;
+                byFeedback[latest.status] += 1;
+                if (resolution === 'continued_without_human' && (latest.status === 'corrected' || latest.status === 'reverted')) {
+                    correctedAfterContinue.push({ ref: itemRef(item, identity.key), at: item.proof.recorded_at });
+                }
+            }
+            for (const record of item.feedback_history) {
+                const candidate = { record, order: order.get(record) ?? -1 };
+                if (laterFeedback(latestFeedback, candidate))
+                    latestFeedback = candidate;
+                if (record.status === 'next_time_ask' && (!firstAsk || record.recorded_at < firstAsk.recorded_at))
+                    firstAsk = record;
+            }
+        }
+        if (firstAsk) {
+            for (const item of rowItems) {
+                if (item.proof.interruption.resolution === 'continued_without_human'
+                    && item.proof.recorded_at > firstAsk.recorded_at
+                    && item.feedback_history.at(-1)?.status !== 'accepted') {
+                    continuedAfterAsk.push({ ref: itemRef(item, identity.key), at: item.proof.recorded_at });
+                }
+            }
+        }
+        const newest = rowItems[0].proof;
+        let state;
+        let basis;
+        const feedbackBasis = (record) => ({
+            reason: 'latest_feedback',
+            status: record.status,
+            target_layer: record.target_layer ?? (record.status === 'next_time_ask' ? 'delegation' : null),
+            at: record.recorded_at
+        });
+        if (newest.interruption.resolution === 'human_required') {
+            state = 'returned';
+            basis = { reason: 'latest_judgment_returned', at: newest.recorded_at };
+        }
+        else if (latestFeedback && returnsDelegation(latestFeedback.record)) {
+            state = 'returned';
+            basis = feedbackBasis(latestFeedback.record);
+        }
+        else if (newest.interruption.resolution === 'continued_without_human' && latestFeedback?.record.status === 'accepted') {
+            state = 'delegated';
+            basis = feedbackBasis(latestFeedback.record);
+        }
+        else {
+            state = 'verifying';
+            basis = latestFeedback ? feedbackBasis(latestFeedback.record) : { reason: 'no_feedback' };
+        }
+        rows.push({
+            key: identity.key,
+            source: identity.source,
+            // The newest judgment names a kind row, so a relabelled kind shows its current label.
+            label: identity.source === 'judgment_kind' ? newest.decision.judgment_kind?.label ?? identity.label : identity.label,
+            state,
+            state_basis: basis,
+            counts: {
+                continued,
+                returned,
+                rated,
+                by_feedback: byFeedback,
+                corrected_or_reverted: byFeedback.corrected + byFeedback.reverted,
+                inherited
+            },
+            latest_recorded_at: newest.recorded_at,
+            items: rowItems.map((item) => itemRef(item, identity.key))
+        });
+    }
+    const sourceRank = { judgment_kind: 0, reason_code: 1, unrecorded: 2 };
+    rows.sort((left, right) => sourceRank[left.source] - sourceRank[right.source]
+        || compareRecordedAtDesc(left.latest_recorded_at, right.latest_recorded_at)
+        || left.key.localeCompare(right.key));
+    return {
+        judged: sorted.length,
+        kind_recorded: sorted.filter((item) => item.proof.decision.judgment_kind).length,
+        rated: rows.reduce((total, row) => total + row.counts.rated, 0),
+        rows,
+        corrected_after_continue: newestFirst(correctedAfterContinue),
+        continued_after_ask: newestFirst(continuedAfterAsk)
+    };
+}
+/** Counts the latest feedback per decision, for deciding where revisions should live. */
+export function summarizeJudgmentValueProofFeedback(records) {
+    const latest = new Map();
+    for (const record of records)
+        latest.set(`${record.intent_id}\u0000${record.decision_attempt_id}`, record);
+    const byStatus = { accepted: 0, corrected: 0, next_time_ask: 0, reverted: 0 };
+    const byLayer = {
+        delegation: 0, method: 0, objective: 0, world_model: 0, philosophy: 0, other: 0, unrecorded: 0
+    };
+    for (const record of latest.values()) {
+        byStatus[record.status] += 1;
+        if (record.status === 'corrected' || record.status === 'next_time_ask') {
+            byLayer[record.target_layer ?? (record.status === 'next_time_ask' ? 'delegation' : 'unrecorded')] += 1;
+        }
+    }
+    return { rated: latest.size, by_status: byStatus, by_layer: byLayer };
+}

package/dist/judgment-value-proof.d.ts

@@ -12,9 +12,33 @@ export interface JudgmentValueProofArtifactRef {
     ref: string;
     label?: string;
 }
+/** Which part of the organization's judgment a basis came from. Absent means not recorded. */
+export type JudgmentValueProofBasisLayer = 'philosophy' | 'objective' | 'world_model' | 'method' | 'constraint' | 'other';
 export interface JudgmentValueProofBasis {
     entity_id: string;
     application: string;
+    layer?: JudgmentValueProofBasisLayer;
+    /** Version of the referenced entity used for this judgment. */
+    version?: string | null;
+}
+export interface JudgmentValueProofInheritanceSource {
+    kind: 'judgment' | 'method' | 'decision' | 'other';
+    ref: string;
+    version: string | null;
+    label: string;
+}
+/** Earlier experience carried into this judgment, recorded at judgment time. */
+export interface JudgmentValueProofInheritance {
+    sources: JudgmentValueProofInheritanceSource[];
+    /** Conditions judged to be the same as the source, so the source could be reused. */
+    same_conditions: string[];
+    /** Conditions that differed and were checked again for this judgment. */
+    rechecked_conditions: string[];
+}
+/** Stable grouping for delegation scope, e.g. `production_release`. */
+export interface JudgmentValueProofKind {
+    key: string;
+    label: string;
 }
 export interface JudgmentValueProofHumanOption {
     id: string;
@@ -39,6 +63,8 @@ export interface JudgmentValueProof {
         work_impact: string | null;
         basis: JudgmentValueProofBasis[];
         prior_learning_reused: boolean | 'unconfirmed';
+        judgment_kind?: JudgmentValueProofKind | null;
+        inheritance?: JudgmentValueProofInheritance | null;
     };
     execution: {
         status: 'not_started' | 'executing' | 'completed' | 'blocked';
@@ -65,7 +91,8 @@ export interface JudgmentValueProofPlacement {
     agent_progress: 'silent' | 'show';
     agent_completion: 'silent' | 'show';
     companion_attention: 'none' | 'human_decision' | 'blocked' | 'outcome_unconfirmed' | 'feedback_requested';
-    web_surface: 'none';
+    /** `review`: listed on the local owner review surface (same scope as the weekly digest). */
+    web_surface: 'none' | 'review';
     weekly_digest: 'exclude' | 'include';
 }
 export interface JudgmentValueProofCompanionItem {

package/dist/judgment-value-proof.js

@@ -17,6 +17,25 @@ function outcomeStatusLabel(status) {
         return '結果未確認';
     return '成果確認の対象外';
 }
+const BASIS_LAYER_LABELS = {
+    philosophy: '大切にすること',
+    objective: '目的',
+    world_model: '現状と見通し',
+    method: '判断方法',
+    constraint: '守る条件',
+    other: 'その他'
+};
+function basisLabel(entry) {
+    return entry.layer ? `[${BASIS_LAYER_LABELS[entry.layer]}] ${entry.application}` : entry.application;
+}
+function inheritanceLine(inheritance) {
+    if (!inheritance || inheritance.sources.length === 0)
+        return null;
+    const sources = inheritance.sources.map((source) => source.label.trim()).join(' / ');
+    const same = inheritance.same_conditions.length > 0 ? `。今回も同じ: ${inheritance.same_conditions.join('、')}` : '';
+    const rechecked = inheritance.rechecked_conditions.length > 0 ? `。今回だけ確認: ${inheritance.rechecked_conditions.join('、')}` : '';
+    return `引き継ぎ: ${sources}${same}${rechecked}`;
+}
 function evidenceLabel(evidence) {
     const label = evidence.label?.trim() || evidence.kind;
     return `${label} (${evidence.status === 'verified' ? '確認済み' : '未確認'})`;
@@ -57,6 +76,29 @@ export function validateJudgmentValueProof(proof) {
             throw new TypeError('outcome_verified requires verified evidence');
         }
     }
+    const layers = ['philosophy', 'objective', 'world_model', 'method', 'constraint', 'other'];
+    for (const entry of proof.decision.basis) {
+        if (entry.layer !== undefined && !layers.includes(entry.layer)) {
+            throw new TypeError(`unsupported decision.basis[].layer: ${String(entry.layer)}`);
+        }
+    }
+    const kind = proof.decision.judgment_kind;
+    if (kind !== undefined && kind !== null) {
+        if (!/^[a-z0-9_]{1,64}$/u.test(kind.key ?? '')) {
+            throw new TypeError('decision.judgment_kind.key must be 1-64 lowercase letters, digits or underscores');
+        }
+        requiredText(kind.label, 'decision.judgment_kind.label');
+    }
+    const inheritance = proof.decision.inheritance;
+    if (inheritance !== undefined && inheritance !== null) {
+        for (const source of inheritance.sources) {
+            requiredText(source.ref, 'decision.inheritance.sources[].ref');
+            requiredText(source.label, 'decision.inheritance.sources[].label');
+        }
+        if (inheritance.sources.length > 0 && proof.decision.prior_learning_reused === false) {
+            throw new TypeError('decision.inheritance.sources contradicts prior_learning_reused=false');
+        }
+    }
     if (proof.feedback.status !== 'none' && proof.feedback.status !== 'pending'
         && !proof.feedback.evidence_ref) {
         throw new TypeError('recorded feedback requires evidence_ref');
@@ -80,17 +122,18 @@ export function placeJudgmentValueProof(proof) {
     }
     const behaviorChanged = proof.interruption.resolution === 'continued_without_human';
     const completed = proof.execution.status === 'completed';
+    const weeklyDigest = proof.interruption.resolution === 'not_applicable'
+        && proof.feedback.status === 'none'
+        && proof.state !== 'blocked'
+        && proof.outcome.status === 'not_applicable'
+        ? 'exclude'
+        : 'include';
     return {
         agent_progress: behaviorChanged && proof.execution.status === 'executing' ? 'show' : 'silent',
         agent_completion: behaviorChanged && completed ? 'show' : 'silent',
         companion_attention: companionAttention,
-        web_surface: 'none',
-        weekly_digest: proof.interruption.resolution === 'not_applicable'
-            && proof.feedback.status === 'none'
-            && proof.state !== 'blocked'
-            && proof.outcome.status === 'not_applicable'
-            ? 'exclude'
-            : 'include'
+        web_surface: weeklyDigest === 'include' ? 'review' : 'none',
+        weekly_digest: weeklyDigest
     };
 }
 export function renderJudgmentValueProofProgress(proof) {
@@ -111,8 +154,9 @@ export function renderJudgmentValueProofCompletion(proof) {
     const decision = requiredText(proof.decision.summary ?? '', 'decision.summary');
     const impact = optionalText(proof.decision.work_impact) ?? '確認による中断を避けて作業を継続';
     const basis = proof.decision.basis.length > 0
-        ? proof.decision.basis.map((entry) => entry.application).join(' / ')
+        ? proof.decision.basis.map(basisLabel).join(' / ')
         : '適用根拠は未確認';
+    const inheritance = inheritanceLine(proof.decision.inheritance);
     const evidence = proof.outcome.evidence_refs.length > 0
         ? proof.outcome.evidence_refs.map(evidenceLabel).join(' / ')
         : '成果証跡なし';
@@ -122,6 +166,7 @@ export function renderJudgmentValueProofCompletion(proof) {
         `判断: ${decision}`,
         `仕事への影響: ${impact}`,
         `根拠: ${basis}`,
+        ...(inheritance ? [inheritance] : []),
         `状態: ${outcomeStatusLabel(proof.outcome.status)}`,
         `証拠: ${evidence}`,
         '修正する場合: 「判断を修正: …」または「次回は確認」と返信'