kibi-opencode 0.14.0 → 0.15.1

package/dist/plugin.js

@@ -1,7 +1,4 @@
 import * as path from "node:path";
-import { loadBriefConfig } from "kibi-cli/brief-config";
-import { computeBriefIntent } from "./brief-intent.js";
-import { fetchBriefingResult, } from "./briefing-runtime.js";
 import { analyzeCodeFile, } from "./comment-analysis.js";
 import { getE2eCoverageSignal } from "./e2e-coverage-signals.js"; // implements REQ-opencode-file-context-guidance-v1
 import { buildDirtyRelevantFingerprint, buildEnforcementScopeKey, } from "./enforcement-scope.js";
@@ -9,56 +6,26 @@ import { getFileLinkedEntityIds } from "./file-entity-links.js"; // implements R
 import * as fileFilter from "./file-filter.js";
 import { deriveFileOperationReminder } from "./file-operation-reminders.js"; // implements REQ-opencode-file-context-guidance-v1
 import { createFileOperationState, } from "./file-operation-state.js"; // implements REQ-opencode-file-context-guidance-v1
-import { KibiCheckpointRunner, } from "./kibi-checkpoint-runner.js";
 import { getInitKibiCommandCapability, registerInitKibiCommand, } from "./init-kibi-capability.js";
-import { computeAuditDelta, getAuditTailCursor, guardBranchChanged, } from "./idle-brief-audit.js";
-import { hasTuiSeenBrief, selectLatestUnreadBrief, } from "./idle-brief-reader.js";
-import { generateIdleBrief } from "./idle-brief-runtime.js";
+import { createKbFreshnessEvidenceStore, evaluateKbFreshness, } from "./kb-freshness-state.js";
+import { KibiCheckpointRunner, } from "./kibi-checkpoint-runner.js";
 import * as logger from "./logger.js";
+import { classifyMeaningfulChange } from "./meaningful-change-classifier.js";
 import { analyzePath } from "./path-kind.js";
 import { runPluginStartup } from "./plugin-startup.js";
-import { resolveCurrentBranch } from "./plugin-startup.js";
 import { SENTINEL, buildPrompt } from "./prompt.js";
-import { reconcileAuditEntries } from "./reconcile-engine.js";
 import { isMustPriorityRequirement } from "./requirement-doc.js";
 import { classifyRisk } from "./risk-classifier.js";
 import { createSyncScheduler } from "./scheduler.js";
 import { createSessionEditState, } from "./session-edit-state.js";
-import { syncSessionBaselineState, } from "./session-fingerprint.js";
 import { getSessionTracker } from "./session-tracker.js";
 import { notifyStartup, } from "./startup-notifier.js";
-import { sendToast, } from "./toast.js";
-import { announceBriefTui, } from "./tui-brief-delivery.js";
-import { deletePendingBriefMarkers, loadPendingBriefMarkers, } from "./utils/brief-marker.js";
+import { readKibiPackageVersions } from "./version-metadata.js";
 import { resolveWorkContext, } from "./work-context-resolver.js";
 import * as fs from "node:fs";
 function deriveFileBucket(kind) {
     return kind;
 }
-function resolveIdleBriefDeliveryDelayMs(worktree) {
-    const envValue = Number(process.env.KIBI_OPENCODE_IDLE_BRIEF_DELAY_MS);
-    if (Number.isFinite(envValue) && envValue >= 0) {
-        return Math.min(60_000, Math.trunc(envValue));
-    }
-    const sharedPolicy = loadBriefConfig(worktree);
-    const configValue = Number(sharedPolicy.tui?.idleDelayMs ?? 1500);
-    if (!Number.isFinite(configValue))
-        return 1500;
-    if (configValue < 0)
-        return 0;
-    return Math.min(60_000, Math.trunc(configValue));
-}
-function readKibiOpencodePackageVersion() {
-    try {
-        const packageJson = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
-        return typeof packageJson.version === "string"
-            ? packageJson.version
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 const startupNotifyGlobals = globalThis;
 /**
  * Lint requirement documents for embedded scenarios/tests and oversized content.
@@ -129,7 +96,7 @@ const kibiOpencodePlugin = async (input) => {
     if (!startup) {
         return {};
     }
-    const { cfg, workspaceHealth, posture, currentBranch, cache, runtimeOverlay, scheduler: startupScheduler, maintenanceDegraded, getMaintenanceDegraded, getEffectiveMode, latchRuntimeDegraded, } = startup;
+    const { cfg, workspaceHealth, posture, cache, runtimeOverlay, scheduler: startupScheduler, maintenanceDegraded, getMaintenanceDegraded, getEffectiveMode, latchRuntimeDegraded, } = startup;
     const hooks = {};
     const initKibiCommandCapability = getInitKibiCommandCapability();
     if (initKibiCommandCapability.supported) {
@@ -143,11 +110,6 @@ const kibiOpencodePlugin = async (input) => {
     let hasRecentKbEdit = false;
     let recentCommentSuggestion = null;
     const seenFingerprints = new Set(); // For deduplication
-    // NOTE: autoBriefResults is ONLY for prompt-time auto-brief guidance (file.edited flow).
-    // Idle-brief runtime (session.idle flow) writes directly to .kb/briefs/ via generateIdleBrief()
-    // and MUST NEVER store results in this map or leak into prompt guidance.
-    const autoBriefResults = new Map();
-    const toastedFingerprints = new Set();
     let lastRiskClass = null;
     let lastRiskFilePath = null;
     let lastRiskScopeKey = null;
@@ -160,6 +122,7 @@ const kibiOpencodePlugin = async (input) => {
     const fileOperationStateRegistry = new Map();
     const checkpointRunnerRegistry = new Map();
     const pathKindCacheRegistry = new Map();
+    const freshnessStore = createKbFreshnessEvidenceStore();
     function resolveScopedWorkContext(filePath) {
         return resolveWorkContext({
             inputDirectory: input.directory,
@@ -289,36 +252,10 @@ const kibiOpencodePlugin = async (input) => {
         return cacheKey;
     }
     const rootWorkContext = resolveScopedWorkContext();
-    const sessionEditState = getSessionEditState(rootWorkContext);
     const fileOperationState = getFileOperationState(rootWorkContext);
     const scheduler = getSchedulerForContext(rootWorkContext);
     let degradedWarnedOnce = false;
     const pathKindCache = getPathKindCache(rootWorkContext);
-    // Idle-brief state — dedupe via semantic contentHash (persisted envelope is the delivery authority)
-    let idleBriefInFlight = false;
-    let idleBriefTrailingRerun = false;
-    let idleBriefTimer = null;
-    const idleBriefDeliveredHashes = new Set();
-    // Session-scoped flag: at most one idle-brief.sync-suppressed breadcrumb per session
-    let idleSyncSuppressedOnce = false;
-    const replayedBriefContentHashes = new Set();
-    // Session-local baseline cursor: captured once per session/worktree/branch from the audit-log tail,
-    // so the first idle brief in a fresh session only reports post-baseline changes.
-    let sessionBaselineCursor = null;
-    let sessionBaselineFingerprint = null;
-    function syncSessionBaseline(branch) {
-        const nextState = syncSessionBaselineState({
-            fingerprint: sessionBaselineFingerprint,
-            cursor: sessionBaselineCursor,
-        }, {
-            sessionId: input.sessionId,
-            branch,
-            worktree: input.worktree,
-        }, () => getAuditTailCursor(input.worktree, branch));
-        sessionBaselineFingerprint = nextState.fingerprint;
-        sessionBaselineCursor = nextState.cursor;
-    }
-    syncSessionBaseline(currentBranch);
     function normalizeSessionPath(filePath, worktree = input.worktree) {
         if (path.isAbsolute(filePath)) {
             const relativePath = path.relative(worktree, filePath);
@@ -334,44 +271,6 @@ const kibiOpencodePlugin = async (input) => {
     function buildRiskPathScopeKey(context, filePath) {
         return `${buildStateScopeKey(context, "risk")}:${normalizeSessionPath(filePath, context.worktreeRoot)}`;
     }
-    function getKbSnapshotFingerprint(worktree, branch) {
-        try {
-            const snapshotPath = path.join(worktree, ".kb", "branches", branch, "kb.rdf");
-            const stat = fs.statSync(snapshotPath);
-            return `${stat.size}:${stat.mtimeMs}`;
-        }
-        catch {
-            return "missing";
-        }
-    }
-    function buildSyntheticSyncAuditDelta(baseDelta, sourceFiles) {
-        const timestamp = new Date().toISOString();
-        const fileSource = sourceFiles[0] ?? "workspace-sync";
-        const entityId = path.basename(fileSource).replace(/\.md$/, "") || "workspace-sync";
-        return {
-            ...baseDelta,
-            hasChanges: true,
-            entries: [
-                {
-                    timestamp,
-                    operation: "upsert",
-                    entityId,
-                    payload: {
-                        kind: "entity",
-                        entityType: "fact",
-                        changeKind: "updated",
-                        title: entityId,
-                        source: fileSource,
-                        properties: {
-                            id: entityId,
-                            title: entityId,
-                            source: fileSource,
-                        },
-                    },
-                },
-            ],
-        };
-    }
     function getTransformFocusFilePath(transformInput) {
         if (!transformInput || typeof transformInput !== "object") {
             return null;
@@ -440,203 +339,44 @@ const kibiOpencodePlugin = async (input) => {
             precomputedSuggestion,
         };
     }
-    function buildBriefingWorkspaceContext(context = rootWorkContext, branch = context.branch) {
-        return {
-            workspaceRoot: context.worktreeRoot,
-            branch,
-            directory: context.worktreeRoot,
-            ...(input.workspace !== undefined ? { workspace: input.workspace } : {}),
-        };
-    }
-    function buildWorkspaceContextForBranch(branch, context = rootWorkContext) {
-        return {
-            ...buildBriefingWorkspaceContext(context),
-            branch,
-        };
-    }
-    function queueBriefingFetch(intentResult, options = {}) {
-        if (!intentResult.eligible ||
-            !input.client ||
-            getMaintenanceDegraded() ||
-            ((options.postureState ?? posture.state) !== "root_active" &&
-                (options.postureState ?? posture.state) !== "hybrid_root_plus_vendored")) {
-            return;
-        }
-        if (options.skipIfCachedResultExists === true &&
-            autoBriefResults.has(intentResult.fingerprint)) {
-            return;
-        }
-        const client = input.client;
-        const fingerprint = intentResult.fingerprint;
-        const workspaceCtx = options.workspaceCtx ?? buildBriefingWorkspaceContext();
-        void fetchBriefingResult(client, workspaceCtx, intentResult).then((result) => {
-            autoBriefResults.set(fingerprint, result);
-            if (!toastedFingerprints.has(fingerprint)) {
-                toastedFingerprints.add(fingerprint);
-                void sendToast(makeToastClient(client), {
-                    message: result.toastMessage,
-                });
-            }
-        });
-    }
     hooks.event = async ({ event }) => {
-        const activeBranch = resolveCurrentBranch(input.worktree);
-        syncSessionBaseline(activeBranch);
-        // Handle session.idle for idle-brief generation. OpenCode can emit idle
-        // while an assistant is between tool calls, so debounce until the work
-        // burst settles before generating/delivering a brief.
-        if (event.type === "session.idle") {
-            if (!input.client)
-                return;
-            const idleBranch = activeBranch;
-            const idleWorkspaceRoot = input.worktree;
-            const runIdleBrief = async () => {
-                if (idleBriefInFlight) {
-                    idleBriefTrailingRerun = true;
-                    return;
-                }
-                idleBriefInFlight = true;
-                idleBriefTrailingRerun = false;
+        // Observe KB tool execution events for freshness evidence (best-effort)
+        const TOOL_EVENT_TYPES = new Set([
+            "tool.execute.after",
+            "tool.executed",
+            "tool.call.completed",
+            "tool.Execute.after",
+            "tool.Call.completed",
+        ]);
+        if (TOOL_EVENT_TYPES.has(event.type)) {
+            const props = event.properties ?? {};
+            const toolName = (props.tool ??
+                props.toolName ??
+                props.name ??
+                props.call?.name ??
+                props.input?.tool);
+            if (typeof toolName === "string" && toolName.startsWith("kb_")) {
+                const scope = {
+                    ...(input.sessionId !== undefined
+                        ? { sessionId: input.sessionId }
+                        : {}),
+                    agentIdentity: input.agentIdentity ?? "unknown",
+                    worktree: input.worktree,
+                    branch: rootWorkContext.branch,
+                    fingerprint: `${input.sessionId ?? ""}-${rootWorkContext.branch}`,
+                };
                 try {
-                    // Gather session edits
-                    const sessionEdits = sessionEditState.getSessionEdits();
-                    const sourceFiles = sessionEdits.map((e) => e.filePath);
-                    const markerResult = loadPendingBriefMarkers(idleWorkspaceRoot, idleBranch);
-                    for (const issue of markerResult.issues) {
-                        logger.warn("idle-brief.marker-invalid", {
-                            event: "idle_brief_marker_invalid",
-                            branch: idleBranch,
-                            filePath: issue.filePath,
-                            reason: issue.reason,
-                        });
-                    }
-                    const markerEntityIds = markerResult.entityIds;
-                    const markerRelationships = markerResult.relationships;
-                    const snapshotBeforeSync = getKbSnapshotFingerprint(idleWorkspaceRoot, idleBranch);
-                    if (scheduler) {
-                        const idleSyncBlocked = runtimeOverlay.primaryCause === "scheduler_sync_failed";
-                        if (!idleSyncBlocked) {
-                            scheduler.scheduleSync("session.idle");
-                            await scheduler.flush();
-                        }
-                        else if (!idleSyncSuppressedOnce) {
-                            idleSyncSuppressedOnce = true;
-                            logger.info("idle-brief.sync-suppressed", {
-                                event: "idle_brief_sync_suppressed",
-                                primaryCause: runtimeOverlay.primaryCause,
-                            });
-                        }
-                    }
-                    const snapshotAfterSync = getKbSnapshotFingerprint(idleWorkspaceRoot, idleBranch);
-                    const rawAuditDelta = computeAuditDelta(idleWorkspaceRoot, idleBranch, sessionBaselineCursor);
-                    const auditDelta = rawAuditDelta.hasChanges || snapshotBeforeSync === snapshotAfterSync
-                        ? rawAuditDelta
-                        : buildSyntheticSyncAuditDelta(rawAuditDelta, sourceFiles);
-                    if (!auditDelta.hasChanges)
-                        return;
-                    // Branch switch guard
-                    const currentBranchNow = resolveCurrentBranch(input.worktree);
-                    if (guardBranchChanged(idleBranch, currentBranchNow)) {
-                        logger.info("idle-brief.branch-changed", {
-                            event: "idle_brief_branch_changed",
-                            idleBranch,
-                            currentBranch: currentBranchNow,
-                        });
-                        return;
-                    }
-                    // Generate brief
-                    const workspaceCtx = buildWorkspaceContextForBranch(idleBranch);
-                    const client = input.client;
-                    if (!client)
-                        return;
-                    const reconciled = reconcileAuditEntries(auditDelta.entries);
-                    const changedEntityIds = [
-                        ...reconciled.added.map((e) => e.id),
-                        ...reconciled.modified.map((e) => e.id),
-                        ...reconciled.removed.map((e) => e.id),
-                    ];
-                    const mergedChangedEntityIds = [
-                        ...new Set([...changedEntityIds, ...markerEntityIds]),
-                    ];
-                    const mergedSourceFiles = [...new Set([...sourceFiles, ...markerEntityIds])];
-                    const result = await generateIdleBrief(input.client, workspaceCtx, auditDelta, input.sessionId ?? "unknown", mergedSourceFiles.length > 0
-                        ? {
-                            sourceFiles: mergedSourceFiles,
-                            changedEntityIds: mergedChangedEntityIds,
-                            relationships: markerRelationships,
-                        }
-                        : mergedChangedEntityIds.length > 0
-                            ? {
-                                changedEntityIds: mergedChangedEntityIds,
-                                relationships: markerRelationships,
-                            }
-                            : undefined);
-                    if (result.success) {
-                        const deleteResult = await deletePendingBriefMarkers(markerResult.markerPaths);
-                        for (const issue of deleteResult.issues) {
-                            logger.warn("idle-brief.marker-delete-failed", {
-                                event: "idle_brief_marker_delete_failed",
-                                branch: idleBranch,
-                                filePath: issue.filePath,
-                                reason: issue.reason,
-                            });
-                        }
-                    }
-                    if (result.success && result.envelope) {
-                        const envelope = result.envelope;
-                        // Dedupe by semantic contentHash — persisted envelope is the delivery authority
-                        const dedupeKey = `${idleWorkspaceRoot}:${idleBranch}:tui:${envelope.contentHash}`;
-                        if (!idleBriefDeliveredHashes.has(dedupeKey)) {
-                            idleBriefDeliveredHashes.add(dedupeKey);
-                            const sharedPolicy = { briefs: loadBriefConfig(input.worktree) };
-                            if (client) {
-                                try {
-                                    const announcementResult = await announceBriefTui(makeToastClient(client), envelope, sharedPolicy);
-                                    if (announcementResult.toastDelivered ||
-                                        announcementResult.commandPublished) {
-                                        replayedBriefContentHashes.add(envelope.contentHash);
-                                    }
-                                }
-                                catch (err) {
-                                    logger.error("idle-brief.delivery-failed", {
-                                        event: "idle_brief_delivery_failed",
-                                        error: err instanceof Error ? err.message : String(err),
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        logger.info("idle-brief.no-brief-generated", {
-                            event: "idle_brief_no_brief_generated",
-                            success: result.success,
-                            hasEnvelope: !!result.envelope,
-                        });
-                    }
-                }
-                catch (error) {
-                    logger.error("idle-brief.error", {
-                        event: "idle_brief_error",
-                        error: error instanceof Error ? error.message : String(error),
+                    freshnessStore.recordToolEvidence(scope, toolName);
+                    logger.info("kb-freshness.tool-evidence", {
+                        event: "kb_freshness_tool_evidence",
+                        tool: toolName,
                     });
                 }
-                finally {
-                    idleBriefInFlight = false;
-                    // If trailing rerun was requested, run again
-                    if (idleBriefTrailingRerun) {
-                        idleBriefTrailingRerun = false;
-                        void runIdleBrief();
-                    }
+                catch {
+                    // best-effort, never crash the event handler
                 }
-            };
-            if (idleBriefTimer) {
-                clearTimeout(idleBriefTimer);
             }
-            idleBriefTimer = setTimeout(() => {
-                idleBriefTimer = null;
-                void runIdleBrief();
-            }, resolveIdleBriefDeliveryDelayMs(idleWorkspaceRoot));
-            return;
+            return; // tool events don't need file lifecycle processing
         }
         // Accept file.created, file.edited, and file.deleted lifecycle events
         const isFileLifecycle = event.type === "file.created" ||
@@ -644,10 +384,6 @@ const kibiOpencodePlugin = async (input) => {
             event.type === "file.deleted";
         if (!isFileLifecycle)
             return;
-        if (idleBriefTimer) {
-            clearTimeout(idleBriefTimer);
-            idleBriefTimer = null;
-        }
         const filePath = event
             .properties.file;
         if (!filePath)
@@ -676,7 +412,7 @@ const kibiOpencodePlugin = async (input) => {
                 scopedPathKindCache.set(normalizedFilePath, pathAnalysis.kind);
             }
             else {
-                // Not tracked — classify only for reminder routing, not auto-briefing
+                // Not tracked — classify only for reminder routing.
                 scopedPathKindCache.set(normalizedFilePath, pathAnalysis.kind);
             }
             scopedSessionEditState.recordEventHint(normalizedFilePath, pathAnalysis.kind, Date.now());
@@ -722,8 +458,6 @@ const kibiOpencodePlugin = async (input) => {
         const effectiveRiskClass = riskClass === "safe_docs_only" && precomputedSuggestion
             ? "traceability_candidate"
             : riskClass;
-        const isAutoBriefRisk = effectiveRiskClass === "behavior_candidate" ||
-            effectiveRiskClass === "traceability_candidate";
         lastRiskClass = effectiveRiskClass;
         lastRiskFilePath = normalizedFilePath;
         lastRiskScopeKey = buildRiskPathScopeKey(eventContext, normalizedFilePath);
@@ -825,9 +559,7 @@ const kibiOpencodePlugin = async (input) => {
                 posture: eventContext.posture,
                 posture_state: eventContext.posture,
             });
-            if (!isAutoBriefRisk) {
-                return;
-            }
+            return;
         }
         logger.info("smart-enforcement.cache", {
             event: "smart_enforcement_cache",
@@ -927,7 +659,8 @@ const kibiOpencodePlugin = async (input) => {
             }
             return;
         }
-        if (isAutoBriefRisk) {
+        if (effectiveRiskClass === "behavior_candidate" ||
+            effectiveRiskClass === "traceability_candidate") {
             if (pathAnalysis.kind === "code" &&
                 cfg.guidance.commentDetection.enabled) {
                 const suggestion = precomputedSuggestion;
@@ -952,25 +685,6 @@ const kibiOpencodePlugin = async (input) => {
             else {
                 recentCommentSuggestion = null;
             }
-            if (!focusEdit) {
-                // No surviving edits (all reverted to baseline) — skip auto-brief fetch
-                return;
-            }
-            const sessionSourceFiles = sessionEdits.map((e) => e.filePath);
-            const briefingContext = resolveScopedWorkContext(focusEdit.filePath);
-            const intentResult = computeBriefIntent({
-                riskClass: effectiveRiskClass,
-                posture: briefingContext.posture,
-                maintenanceDegraded: getMaintenanceDegraded(),
-                sourceFiles: sessionSourceFiles,
-                focusFilePath: focusEdit.filePath,
-                worktreeRoot: briefingContext.worktreeRoot,
-                branch: briefingContext.branch,
-            });
-            queueBriefingFetch(intentResult, {
-                workspaceCtx: buildBriefingWorkspaceContext(briefingContext),
-                postureState: briefingContext.posture,
-            });
         }
         return;
     };
@@ -1028,58 +742,7 @@ const kibiOpencodePlugin = async (input) => {
                 if (effectiveRiskClass === null && lastRiskClass !== null) {
                     effectiveRiskClass = lastRiskClass;
                 }
-                const promptSourceFiles = transformSessionEdits.map((entry) => entry.filePath);
                 const promptFocusFilePath = transformFocusEdit?.filePath ?? transformFocusFilePath ?? undefined;
-                const intentResult = effectiveRiskClass
-                    ? computeBriefIntent({
-                        riskClass: effectiveRiskClass,
-                        posture: promptWorkContext.posture,
-                        maintenanceDegraded,
-                        sourceFiles: promptSourceFiles,
-                        worktreeRoot: promptWorkContext.worktreeRoot,
-                        branch: promptWorkContext.branch,
-                        ...(promptFocusFilePath !== undefined
-                            ? {
-                                focusFilePath: promptFocusFilePath,
-                            }
-                            : {}),
-                    })
-                    : null;
-                const autoBriefResult = intentResult
-                    ? autoBriefResults.get(intentResult.fingerprint)
-                    : undefined;
-                const isAutoBriefRisk = effectiveRiskClass === "behavior_candidate" ||
-                    effectiveRiskClass === "traceability_candidate";
-                if (!autoBriefResult && isAutoBriefRisk && intentResult) {
-                    queueBriefingFetch(intentResult, {
-                        skipIfCachedResultExists: true,
-                        workspaceCtx: buildBriefingWorkspaceContext(promptWorkContext),
-                        postureState: promptWorkContext.posture,
-                    });
-                }
-                // Replay latest unread idle brief if available // implements REQ-opencode-kibi-briefing-v4
-                if (input.worktree && currentBranch && input.client) {
-                    const unreadBrief = selectLatestUnreadBrief(input.worktree, currentBranch);
-                    if (unreadBrief &&
-                        !replayedBriefContentHashes.has(unreadBrief.envelope.contentHash) &&
-                        !hasTuiSeenBrief(input.worktree, currentBranch, unreadBrief.envelope.contentHash)) {
-                        const sharedPolicy = { briefs: loadBriefConfig(input.worktree) };
-                        const client = input.client;
-                        try {
-                            const announcementResult = await announceBriefTui(makeToastClient(client), unreadBrief.envelope, sharedPolicy);
-                            if (announcementResult.toastDelivered ||
-                                announcementResult.commandPublished) {
-                                replayedBriefContentHashes.add(unreadBrief.envelope.contentHash);
-                            }
-                        }
-                        catch (err) {
-                            logger.error("idle-brief.replay-failed", {
-                                event: "idle_brief_replay_failed",
-                                error: err instanceof Error ? err.message : String(err),
-                            });
-                        }
-                    }
-                }
                 // Steps 3-4: File-operation reminder selection with suppression // implements REQ-opencode-file-context-guidance-v1
                 let fileOperationReminder;
                 let hardGateBlock;
@@ -1113,8 +776,10 @@ const kibiOpencodePlugin = async (input) => {
                                 focusPathKind,
                                 effectiveRiskClass ?? "safe_docs_only",
                             ]);
-                            if (effectiveMode === "hard" && promptWorkContext.isAuthoritative) {
-                                checkpointRunner = getCheckpointRunnerForContext(promptWorkContext);
+                            if (effectiveMode === "hard" &&
+                                promptWorkContext.isAuthoritative) {
+                                checkpointRunner =
+                                    getCheckpointRunnerForContext(promptWorkContext);
                                 checkpointContext = {
                                     workContext: promptWorkContext,
                                     config: cfg,
@@ -1147,13 +812,18 @@ const kibiOpencodePlugin = async (input) => {
                             if (reminderResult.policyDecision === "hard_block") {
                                 const policyResult = reminderResult.policyResult;
                                 hardGateBlock = {
-                                    shownPaths: "shownPaths" in policyResult ? policyResult.shownPaths : [normalizedFocusPath],
-                                    remainingCount: "remainingCount" in policyResult ? policyResult.remainingCount : 0,
+                                    shownPaths: "shownPaths" in policyResult
+                                        ? policyResult.shownPaths
+                                        : [normalizedFocusPath],
+                                    remainingCount: "remainingCount" in policyResult
+                                        ? policyResult.remainingCount
+                                        : 0,
                                     reason: "checkpoint_required",
                                 };
                                 hardGateConsumedPath = normalizedFocusPath;
                                 hardGateFingerprint = checkpointFingerprint;
-                                hardGateReminderKindsToMark = reminderResult.reminderKindsToMark;
+                                hardGateReminderKindsToMark =
+                                    reminderResult.reminderKindsToMark;
                                 if (checkpointRunner && checkpointContext) {
                                     const checkpointContextWithGuidance = {
                                         ...checkpointContext,
@@ -1195,6 +865,35 @@ const kibiOpencodePlugin = async (input) => {
                         }
                     }
                 }
+                // Build freshness evidence for the current dirty fingerprint
+                let freshnessEval;
+                const freshnessFingerprint = `${promptWorkContext.sessionId ?? ""}-${promptWorkContext.branch}`;
+                const freshnessScope = {
+                    ...(promptWorkContext.sessionId !== undefined
+                        ? { sessionId: promptWorkContext.sessionId }
+                        : {}),
+                    agentIdentity: promptWorkContext.agentIdentity,
+                    worktree: promptWorkContext.worktreeRoot,
+                    branch: promptWorkContext.branch,
+                    fingerprint: freshnessFingerprint,
+                };
+                if (transformFocusFilePath) {
+                    const normalizedFocusPathForFreshness = promptFileOperationState.normalizePath(transformFocusFilePath);
+                    const focusPathKindForFreshness = promptPathKindCache.get(normalizedFocusPathForFreshness) ??
+                        "unknown";
+                    const pendingLifecycleForFreshness = promptFileOperationState.peekPending(normalizedFocusPathForFreshness);
+                    const effectiveRiskClassForFreshness = effectiveRiskClass ?? "safe_docs_only";
+                    const meaningfulChange = classifyMeaningfulChange({
+                        normalizedPath: normalizedFocusPathForFreshness,
+                        pathKind: focusPathKindForFreshness,
+                        lifecycle: pendingLifecycleForFreshness?.lifecycle ?? "edited",
+                        riskClass: effectiveRiskClassForFreshness,
+                    });
+                    if (meaningfulChange === "requires-kb-evidence") {
+                        const freshnessEvidence = freshnessStore.getEvidence(freshnessScope, [normalizedFocusPathForFreshness]);
+                        freshnessEval = evaluateKbFreshness(freshnessEvidence);
+                    }
+                }
                 const guidance = buildPrompt({
                     recentEdits: transformRecentEdits,
                     focusEdit: transformPromptFocusEdit,
@@ -1209,7 +908,6 @@ const kibiOpencodePlugin = async (input) => {
                     maintenanceDegraded,
                     degradedMode: cfg.guidance.smartEnforcement.degradedMode,
                     showDegradedAdvisory,
-                    ...(autoBriefResult !== undefined ? { autoBriefResult } : {}),
                     ...(effectiveRiskClass != null
                         ? { riskClass: effectiveRiskClass }
                         : {}),
@@ -1217,6 +915,14 @@ const kibiOpencodePlugin = async (input) => {
                         ? { fileOperationReminder }
                         : {}),
                     ...(hardGateBlock !== undefined ? { hardGateBlock } : {}),
+                    ...(freshnessEval ? { kbFreshness: freshnessEval } : {}),
+                    ...(freshnessEval && transformSessionEdits.length > 0
+                        ? {
+                            freshnessChangedPaths: [
+                                ...new Set(transformSessionEdits.map((e) => e.filePath)),
+                            ].slice(0, 5),
+                        }
+                        : {}),
                 });
                 logger.info("smart-enforcement.guidance", {
                     event: "smart_enforcement_guidance",
@@ -1263,8 +969,7 @@ const kibiOpencodePlugin = async (input) => {
                     // Mark shown and log only for reminders that were actually emitted
                     if (lifecycleEmitted) {
                         const kind = promptFileOperationState.peekPending(focusPathForConsume)
-                            ?.lifecycle ===
-                            "deleted"
+                            ?.lifecycle === "deleted"
                             ? "kibi_delete"
                             : "kibi_write";
                         promptFileOperationState.markShown(focusPathForConsume, kind);
@@ -1279,8 +984,7 @@ const kibiOpencodePlugin = async (input) => {
                     }
                     if (e2eEmitted) {
                         const kind = promptFileOperationState.peekPending(focusPathForConsume)
-                            ?.lifecycle ===
-                            "deleted"
+                            ?.lifecycle === "deleted"
                             ? "e2e_delete"
                             : "e2e_write";
                         promptFileOperationState.markShown(focusPathForConsume, kind);
@@ -1347,11 +1051,17 @@ const kibiOpencodePlugin = async (input) => {
                 setTimeout(callback, delayMs);
             });
         scheduleStartupNotify(() => {
-            const version = readKibiOpencodePackageVersion();
+            const meta = readKibiPackageVersions();
+            const versions = {};
+            for (const key of ["opencode", "mcp", "cli", "core"]) {
+                if (meta[key] !== "unknown")
+                    versions[key] = meta[key];
+            }
             notifyStartup(makeStartupClient(client), {
                 suppressToast: cfg.ux.toastStartup === false,
                 directory: input.directory,
-                ...(version ? { version } : {}),
+                ...(Object.keys(versions).length > 0 ? { versions } : {}),
+                versionMetadataSource: meta.source,
             });
         }, 2000);
     }