kibi-opencode 0.5.4 → 0.6.1

package/dist/index.js

@@ -1,15 +1,44 @@
+import { execSync } from "node:child_process";
 import * as path from "node:path";
 import { analyzeCodeFile, } from "./comment-analysis.js";
 import * as config from "./config.js";
 import * as fileFilter from "./file-filter.js";
+import { getGuidanceCache } from "./guidance-cache.js";
 import * as logger from "./logger.js";
 import { analyzePath } from "./path-kind.js";
-import { buildPrompt, SENTINEL } from "./prompt.js";
+import { SENTINEL, buildPrompt } from "./prompt.js";
+import { detectPosture } from "./repo-posture.js";
 import { isMustPriorityRequirement } from "./requirement-doc.js";
-import { createSyncScheduler } from "./scheduler.js";
+import { classifyRisk } from "./risk-classifier.js";
+import { createSyncScheduler as importedCreateSyncScheduler, } from "./scheduler.js";
 import { getSessionTracker } from "./session-tracker.js";
+import { computeEffectiveMode, } from "./smart-enforcement.js";
 import { checkWorkspaceHealth } from "./workspace-health.js";
 import * as fs from "node:fs";
+function deriveFileBucket(kind) {
+    return kind;
+}
+function resolveCurrentBranch(cwd) {
+    try {
+        return execSync("git rev-parse --abbrev-ref HEAD", {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return "unknown";
+    }
+}
+function readConfigFingerprint(cwd) {
+    try {
+        return fs.readFileSync(path.join(cwd, ".kb", "config.json"), "utf-8");
+    }
+    catch {
+        return "missing";
+    }
+}
+const workspaceCacheState = new Map();
 /**
  * Lint requirement documents for embedded scenarios/tests and oversized content.
  */
@@ -75,6 +104,92 @@ const kibiOpencodePlugin = async (input) => {
             tracker.reset();
         }
     }
+    const posture = detectPosture(input.worktree);
+    const currentBranch = resolveCurrentBranch(input.worktree);
+    const configFingerprint = readConfigFingerprint(input.worktree);
+    const cache = getGuidanceCache(cfg.guidance.smartEnforcement.preflightTtlMs, cfg.guidance.smartEnforcement.idleResetMs);
+    const previousCacheState = workspaceCacheState.get(input.worktree);
+    if (previousCacheState) {
+        if (previousCacheState.branch !== currentBranch) {
+            cache.invalidateForBranch(previousCacheState.branch);
+        }
+        if (previousCacheState.posture !== posture.state ||
+            previousCacheState.configFingerprint !== configFingerprint) {
+            cache.invalidateForWorkspace(input.worktree);
+        }
+    }
+    workspaceCacheState.set(input.worktree, {
+        branch: currentBranch,
+        posture: posture.state,
+        configFingerprint,
+    });
+    // Session-local runtime degraded overlay (latched, never cleared)
+    const runtimeOverlay = {
+        degraded: false,
+        causes: [],
+    };
+    let degradedWarnedOnce = false;
+    function latchRuntimeDegraded(cause) {
+        if (!runtimeOverlay.degraded) {
+            runtimeOverlay.degraded = true;
+            runtimeOverlay.primaryCause = cause;
+            runtimeOverlay.causes.push(cause);
+            logger.info("smart-enforcement.degraded", {
+                event: "smart_enforcement_degraded",
+                overlay_cause: cause,
+                runtime_degraded: true,
+                static_degraded: posture.maintenanceDegraded,
+                merged_degraded: getMaintenanceDegraded(),
+                maintenance_state: getMaintenanceDegraded()
+                    ? "maintenance_degraded"
+                    : "maintenance_available",
+                effective_mode: getEffectiveMode(),
+            });
+        }
+        else if (!runtimeOverlay.causes.includes(cause)) {
+            runtimeOverlay.causes.push(cause);
+        }
+    }
+    function getMaintenanceDegraded() {
+        return posture.maintenanceDegraded || runtimeOverlay.degraded;
+    }
+    function getEffectiveMode() {
+        return computeEffectiveMode({
+            mode: cfg.guidance.smartEnforcement.mode,
+            requireRootKbForStrict: cfg.guidance.smartEnforcement.requireRootKbForStrict,
+            posture: posture.state,
+            maintenanceDegraded: getMaintenanceDegraded(),
+        });
+    }
+    // Compute effective smart-enforcement mode from config + posture + runtime overlay
+    // Latch startup-level runtime degraded causes
+    if (posture.state === "vendored_only" ||
+        posture.state === "root_uninitialized" ||
+        posture.state === "root_partial") {
+        latchRuntimeDegraded("non_authoritative_posture");
+    }
+    if (!cfg.sync.enabled) {
+        latchRuntimeDegraded("sync_disabled");
+    }
+    const maintenanceDegraded = getMaintenanceDegraded();
+    logger.info("smart-enforcement.posture", {
+        event: "smart_enforcement_posture",
+        posture: posture.state,
+        posture_state: posture.state,
+        maintenance_state: maintenanceDegraded
+            ? "maintenance_degraded"
+            : "maintenance_available",
+        needs_bootstrap: workspaceHealth.needsBootstrap,
+        posture_reason: posture.reason,
+        reason_code: posture.reason,
+        smart_enforcement_mode: cfg.guidance.smartEnforcement.mode,
+        effective_mode: getEffectiveMode(),
+        static_degraded: posture.maintenanceDegraded,
+        runtime_degraded: runtimeOverlay.degraded,
+        merged_degraded: maintenanceDegraded,
+        overlay_cause: runtimeOverlay.primaryCause ?? null,
+        branch: currentBranch,
+    });
     logger.info("kibi-opencode: setting up hooks");
     const hooks = {};
     // Plugin instance state (not module globals)
@@ -83,14 +198,30 @@ const kibiOpencodePlugin = async (input) => {
     let hasRecentKbEdit = false;
     let recentCommentSuggestion = null;
     const seenFingerprints = new Set(); // For deduplication
+    let lastRiskClass = null;
+    const createSyncScheduler = globalThis.__kibi_test_scheduler_factory ?? importedCreateSyncScheduler;
     // Create scheduler only if sync is enabled
     let scheduler = null;
     if (cfg.sync.enabled) {
-        const schedulerOpts = {
-            worktree: input.worktree,
-            config: cfg,
-        };
-        scheduler = createSyncScheduler(schedulerOpts);
+        try {
+            const schedulerOpts = {
+                worktree: input.worktree,
+                config: cfg,
+                onRunComplete: (meta) => {
+                    if (meta.exitCode !== 0) {
+                        latchRuntimeDegraded("scheduler_sync_failed");
+                    }
+                    if (meta.checkExitCode !== undefined && meta.checkExitCode !== 0) {
+                        latchRuntimeDegraded("scheduler_check_failed");
+                    }
+                },
+            };
+            scheduler = createSyncScheduler(schedulerOpts);
+        }
+        catch {
+            latchRuntimeDegraded("scheduler_unavailable");
+            scheduler = null;
+        }
     }
     hooks.event = async ({ event }) => {
         if (event.type !== "file.edited")
@@ -100,15 +231,96 @@ const kibiOpencodePlugin = async (input) => {
         if (!filePath)
             return;
         const pathAnalysis = analyzePath(filePath, input.worktree);
-        if (pathAnalysis.isUnderKb && cfg.guidance.warnOnKbEdits) {
-            hasRecentKbEdit = true;
-            logger.warn(`kibi-opencode: .kb edit detected for ${filePath}`);
-            getSessionTracker().recordWarning("kb-edit", filePath, `Manual .kb edit: ${filePath}`);
+        let fileContent = "";
+        try {
+            const resolvedPath = input.worktree && !path.isAbsolute(filePath)
+                ? path.join(input.worktree, filePath)
+                : filePath;
+            fileContent = fs.readFileSync(resolvedPath, "utf-8");
         }
-        if (pathAnalysis.kind === "requirement") {
-            const lintWarnings = lintRequirementDoc(filePath, input.worktree);
-            for (const warning of lintWarnings) {
-                getSessionTracker().recordWarning(warning.category, filePath, warning.message);
+        catch { }
+        const hasMustPriority = pathAnalysis.kind === "requirement"
+            ? isMustPriorityRequirement(filePath, input.worktree)
+            : false;
+        let precomputedSuggestion = null;
+        if (pathAnalysis.kind === "code" && cfg.guidance.commentDetection.enabled) {
+            const resolvedPath = input.worktree && !path.isAbsolute(filePath)
+                ? path.join(input.worktree, filePath)
+                : filePath;
+            precomputedSuggestion = analyzeCodeFile(resolvedPath, {
+                minLines: cfg.guidance.commentDetection.minLines,
+            });
+        }
+        const { riskClass } = classifyRisk({
+            pathKind: pathAnalysis.kind,
+            isUnderKb: pathAnalysis.isUnderKb,
+            hasMustPriority,
+            hasDurableComment: !!precomputedSuggestion,
+            fileContent,
+        });
+        const effectiveRiskClass = riskClass === "safe_docs_only" && precomputedSuggestion
+            ? "traceability_candidate"
+            : riskClass;
+        lastRiskClass = effectiveRiskClass;
+        logger.info("smart-enforcement.risk", {
+            event: "smart_enforcement_risk",
+            file: filePath,
+            path_kind: pathAnalysis.kind,
+            risk_class: effectiveRiskClass,
+            posture_state: posture.state,
+            maintenance_state: getMaintenanceDegraded()
+                ? "maintenance_degraded"
+                : "maintenance_available",
+            under_kb: pathAnalysis.isUnderKb,
+            has_must_priority: hasMustPriority,
+            posture: posture.state,
+            reason_code: effectiveRiskClass,
+            effective_mode: getEffectiveMode(),
+            static_degraded: posture.maintenanceDegraded,
+            runtime_degraded: runtimeOverlay.degraded,
+            merged_degraded: getMaintenanceDegraded(),
+            overlay_cause: runtimeOverlay.primaryCause ?? null,
+        });
+        const targetedChecksBlocked = getMaintenanceDegraded() ||
+            runtimeOverlay.primaryCause === "sync_disabled" ||
+            runtimeOverlay.primaryCause === "scheduler_unavailable" ||
+            runtimeOverlay.primaryCause === "scheduler_sync_failed" ||
+            runtimeOverlay.primaryCause === "scheduler_check_failed";
+        if (!targetedChecksBlocked &&
+            cfg.sync.enabled &&
+            scheduler &&
+            cfg.guidance.targetedChecks.enabled) {
+            const traceabilityRules = effectiveRiskClass === "traceability_candidate"
+                ? ["symbol-traceability"]
+                : null;
+            const kbStructuralRules = effectiveRiskClass === "kb_doc_structural" &&
+                fileFilter.shouldHandleFile(filePath, input.worktree)
+                ? [
+                    "required-fields",
+                    "no-dangling-refs",
+                    ...(pathAnalysis.kind === "fact" ? ["strict-fact-shape"] : []),
+                ]
+                : null;
+            const checkRules = traceabilityRules ?? kbStructuralRules;
+            if (checkRules) {
+                logger.info("smart-enforcement.targeted-checks", {
+                    event: "smart_enforcement_targeted_checks",
+                    file: filePath,
+                    risk_class: effectiveRiskClass,
+                    posture: posture.state,
+                    posture_state: posture.state,
+                    guidance_action: "targeted_checks",
+                    effective_mode: getEffectiveMode(),
+                    rules: checkRules,
+                    static_degraded: posture.maintenanceDegraded,
+                    runtime_degraded: runtimeOverlay.degraded,
+                    merged_degraded: getMaintenanceDegraded(),
+                    overlay_cause: runtimeOverlay.primaryCause ?? null,
+                });
+                logger.info(`kibi-opencode: scheduling sync for ${filePath}`);
+                scheduler.scheduleSync(effectiveRiskClass === "traceability_candidate"
+                    ? "smart-enforcement.traceability"
+                    : "smart-enforcement.kb-doc", filePath, checkRules);
             }
         }
         const now = Date.now();
@@ -120,59 +332,169 @@ const kibiOpencodePlugin = async (input) => {
         if (recentEdits.length > MAX_RECENT_EDITS) {
             recentEdits = recentEdits.slice(-MAX_RECENT_EDITS);
         }
-        if (pathAnalysis.kind === "code" && cfg.guidance.commentDetection.enabled) {
-            const resolvedPath = input.worktree && !path.isAbsolute(filePath)
-                ? path.join(input.worktree, filePath)
-                : filePath;
-            const suggestion = analyzeCodeFile(resolvedPath, {
-                minLines: cfg.guidance.commentDetection.minLines,
-            });
-            if (suggestion) {
-                recentCommentSuggestion = suggestion;
-                const dedupeKey = `${filePath}:${suggestion.suggestionType}:${suggestion.fingerprint}`;
-                if (!seenFingerprints.has(dedupeKey)) {
-                    seenFingerprints.add(dedupeKey);
-                    const warningCategory = suggestion.suggestionType === "fact"
-                        ? "long-comment-missed-fact"
-                        : suggestion.suggestionType === "adr"
-                            ? "long-comment-missed-adr"
-                            : "missing-traceability";
-                    logger.warn(`kibi-opencode: detected durable ${suggestion.suggestionType} knowledge in ${filePath}`);
-                    getSessionTracker().recordWarning(warningCategory, filePath, `Consider routing this ${suggestion.suggestionType} knowledge to Kibi instead of inline comments: ${suggestion.reasoning}`);
-                }
+        if (effectiveRiskClass === "safe_docs_only" ||
+            effectiveRiskClass === "safe_test_only") {
+            recentCommentSuggestion = null;
+            return;
+        }
+        const cacheKey = {
+            workspaceRoot: input.worktree,
+            branch: currentBranch,
+            posture: posture.state,
+            riskClass: effectiveRiskClass,
+            fileBucket: deriveFileBucket(pathAnalysis.kind),
+        };
+        // Always process manual_kb_edit before cache check — this is a critical safety signal
+        if (effectiveRiskClass === "manual_kb_edit") {
+            hasRecentKbEdit = true;
+            if (cfg.guidance.warnOnKbEdits) {
+                logger.warn(`kibi-opencode: .kb edit detected for ${filePath}`);
+                getSessionTracker().recordWarning("kb-edit", filePath, `Manual .kb edit: ${filePath}`);
             }
-            else {
-                recentCommentSuggestion = null;
+            return;
+        }
+        // Always emit requirement lint warnings before cache check — these are safety signals
+        if (effectiveRiskClass === "req_policy_candidate") {
+            const lintWarnings = lintRequirementDoc(filePath, input.worktree);
+            for (const warning of lintWarnings) {
+                getSessionTracker().recordWarning(warning.category, filePath, warning.message);
             }
         }
-        else {
-            recentCommentSuggestion = null;
+        // Cache check: after critical signals have been emitted
+        if (cache.isSatisfied(cacheKey)) {
+            logger.info("smart-enforcement.cache", {
+                event: "smart_enforcement_cache",
+                cache_hit: true,
+                cache_state: "hit",
+                file: filePath,
+                risk_class: effectiveRiskClass,
+                posture: posture.state,
+                posture_state: posture.state,
+            });
+            return;
         }
-        if (!cfg.sync.enabled)
+        logger.info("smart-enforcement.cache", {
+            event: "smart_enforcement_cache",
+            cache_hit: false,
+            cache_state: "miss",
+            file: filePath,
+            risk_class: effectiveRiskClass,
+            posture: posture.state,
+            posture_state: posture.state,
+        });
+        if (effectiveRiskClass === "req_policy_candidate") {
+            if (getMaintenanceDegraded()) {
+                const logFn = cfg.guidance.smartEnforcement.degradedMode === "warn-once"
+                    ? logger.warn
+                    : logger.info;
+                logFn("smart-enforcement.degraded", {
+                    event: "smart_enforcement_degraded",
+                    file: filePath,
+                    risk_class: effectiveRiskClass,
+                    posture: posture.state,
+                    posture_state: posture.state,
+                    maintenance_state: getMaintenanceDegraded()
+                        ? "maintenance_degraded"
+                        : "maintenance_available",
+                    reason: runtimeOverlay.primaryCause ?? "non_authoritative_posture",
+                    reason_code: runtimeOverlay.primaryCause ?? "non_authoritative_posture",
+                    static_degraded: posture.maintenanceDegraded,
+                    runtime_degraded: runtimeOverlay.degraded,
+                    merged_degraded: getMaintenanceDegraded(),
+                    overlay_cause: runtimeOverlay.primaryCause ?? null,
+                    effective_mode: getEffectiveMode(),
+                });
+            }
+            if (!getMaintenanceDegraded() &&
+                cfg.sync.enabled &&
+                scheduler &&
+                fileFilter.shouldHandleFile(filePath, input.worktree)) {
+                let checkRules;
+                if (cfg.guidance.targetedChecks.enabled) {
+                    if (hasMustPriority && getEffectiveMode() === "strict") {
+                        checkRules = [
+                            "required-fields",
+                            "no-dangling-refs",
+                            "must-priority-coverage",
+                        ];
+                        logger.info(`kibi-opencode: must-priority requirement detected, scheduling elevated checks for ${filePath}`);
+                    }
+                    else {
+                        checkRules = ["required-fields", "no-dangling-refs"];
+                    }
+                }
+                logger.info("smart-enforcement.targeted-checks", {
+                    event: "smart_enforcement_targeted_checks",
+                    file: filePath,
+                    risk_class: effectiveRiskClass,
+                    posture: posture.state,
+                    posture_state: posture.state,
+                    guidance_action: "targeted_checks",
+                    effective_mode: getEffectiveMode(),
+                    rules: checkRules ?? [],
+                    static_degraded: posture.maintenanceDegraded,
+                    runtime_degraded: runtimeOverlay.degraded,
+                    merged_degraded: getMaintenanceDegraded(),
+                    overlay_cause: runtimeOverlay.primaryCause ?? null,
+                });
+                scheduler?.scheduleSync("file.edited", filePath, checkRules);
+            }
             return;
-        if (!fileFilter.shouldHandleFile(filePath, input.worktree))
+        }
+        if (effectiveRiskClass === "kb_doc_structural") {
+            if (getMaintenanceDegraded()) {
+                const logFn = cfg.guidance.smartEnforcement.degradedMode === "warn-once"
+                    ? logger.warn
+                    : logger.info;
+                logFn("smart-enforcement.degraded", {
+                    event: "smart_enforcement_degraded",
+                    file: filePath,
+                    risk_class: effectiveRiskClass,
+                    posture: posture.state,
+                    posture_state: posture.state,
+                    maintenance_state: getMaintenanceDegraded()
+                        ? "maintenance_degraded"
+                        : "maintenance_available",
+                    reason: runtimeOverlay.primaryCause ?? "non_authoritative_posture",
+                    reason_code: runtimeOverlay.primaryCause ?? "non_authoritative_posture",
+                    static_degraded: posture.maintenanceDegraded,
+                    runtime_degraded: runtimeOverlay.degraded,
+                    merged_degraded: getMaintenanceDegraded(),
+                    overlay_cause: runtimeOverlay.primaryCause ?? null,
+                    effective_mode: getEffectiveMode(),
+                });
+            }
             return;
-        let checkRules;
-        if (cfg.guidance.targetedChecks.enabled) {
-            if (pathAnalysis.kind === "requirement") {
-                if (isMustPriorityRequirement(filePath, input.worktree)) {
-                    checkRules = [
-                        "required-fields",
-                        "no-dangling-refs",
-                        "must-priority-coverage",
-                    ];
-                    logger.info(`kibi-opencode: must-priority requirement detected, scheduling elevated checks for ${filePath}`);
+        }
+        if (effectiveRiskClass === "behavior_candidate" ||
+            effectiveRiskClass === "traceability_candidate") {
+            if (pathAnalysis.kind === "code" &&
+                cfg.guidance.commentDetection.enabled) {
+                const suggestion = precomputedSuggestion;
+                if (suggestion) {
+                    recentCommentSuggestion = suggestion;
+                    const dedupeKey = `${filePath}:${suggestion.suggestionType}:${suggestion.fingerprint}`;
+                    if (!seenFingerprints.has(dedupeKey)) {
+                        seenFingerprints.add(dedupeKey);
+                        const warningCategory = suggestion.suggestionType === "fact"
+                            ? "long-comment-missed-fact"
+                            : suggestion.suggestionType === "adr"
+                                ? "long-comment-missed-adr"
+                                : "missing-traceability";
+                        logger.warn(`kibi-opencode: detected durable ${suggestion.suggestionType} knowledge in ${filePath}`);
+                        getSessionTracker().recordWarning(warningCategory, filePath, `Consider routing this ${suggestion.suggestionType} knowledge to Kibi instead of inline comments: ${suggestion.reasoning}`);
+                    }
                 }
                 else {
-                    checkRules = ["required-fields", "no-dangling-refs"];
+                    recentCommentSuggestion = null;
                 }
             }
-            else if (["scenario", "test", "adr", "fact"].includes(pathAnalysis.kind)) {
-                checkRules = ["required-fields", "no-dangling-refs"];
+            else {
+                recentCommentSuggestion = null;
             }
+            return;
         }
-        logger.info(`kibi-opencode: scheduling sync for ${filePath}`);
-        scheduler?.scheduleSync("file.edited", filePath, checkRules);
+        return;
     };
     if (cfg.prompt.enabled) {
         const hookMode = cfg.prompt.hookMode;
@@ -182,13 +504,63 @@ const kibiOpencodePlugin = async (input) => {
                 if (output.system.some((entry) => entry.includes(SENTINEL))) {
                     return;
                 }
+                const maintenanceDegraded = getMaintenanceDegraded();
+                const showDegradedAdvisory = maintenanceDegraded &&
+                    cfg.guidance.smartEnforcement.degradedMode === "warn-once" &&
+                    !degradedWarnedOnce;
                 // Build only the guidance block and append it; existing entries are preserved
                 const guidance = buildPrompt({
                     recentEdits,
                     workspaceHealth,
                     hasRecentKbEdit,
                     recentCommentSuggestion,
+                    posture: posture.state,
+                    riskClass: lastRiskClass ?? undefined,
+                    cache,
+                    workspaceRoot: input.worktree,
+                    branch: currentBranch,
+                    completionReminder: cfg.guidance.smartEnforcement.completionReminder,
+                    maintenanceDegraded,
+                    degradedMode: cfg.guidance.smartEnforcement.degradedMode,
+                    showDegradedAdvisory,
+                });
+                logger.info("smart-enforcement.guidance", {
+                    event: "smart_enforcement_guidance",
+                    emitted: guidance.trim() !== "" && guidance.trim() !== SENTINEL,
+                    posture: posture.state,
+                    posture_state: posture.state,
+                    guidance_action: guidance.trim() !== "" && guidance.trim() !== SENTINEL
+                        ? "emit"
+                        : "skip",
+                    risk_class: lastRiskClass,
+                    recent_edits: recentEdits.length,
+                    static_degraded: posture.maintenanceDegraded,
+                    runtime_degraded: runtimeOverlay.degraded,
+                    merged_degraded: maintenanceDegraded,
+                    overlay_cause: runtimeOverlay.primaryCause ?? null,
                 });
+                // Emit completion-reminder log only when prompt-visible reminder text is present
+                const REMINDER_TEXT = "Run `kb_check` before completing this task.";
+                if (cfg.guidance.smartEnforcement.completionReminder &&
+                    !maintenanceDegraded &&
+                    guidance.includes(REMINDER_TEXT)) {
+                    logger.info("smart-enforcement.completion-reminder", {
+                        event: "smart_enforcement_completion_reminder",
+                        risk_class: lastRiskClass,
+                        posture: posture.state,
+                        posture_state: posture.state,
+                        guidance_action: "completion_reminder",
+                        reminder: "kb_check",
+                        static_degraded: posture.maintenanceDegraded,
+                        runtime_degraded: runtimeOverlay.degraded,
+                        merged_degraded: maintenanceDegraded,
+                        overlay_cause: runtimeOverlay.primaryCause ?? null,
+                    });
+                }
+                // Latch degraded advisory warning-once state
+                if (showDegradedAdvisory && guidance.includes("Maintenance degraded")) {
+                    degradedWarnedOnce = true;
+                }
                 const last = output.system.length > 0
                     ? output.system[output.system.length - 1]
                     : undefined;

package/dist/logger.d.ts

@@ -3,8 +3,9 @@ export interface PluginClient {
         log: (payload: Record<string, unknown>) => Promise<void>;
     };
 }
+export type LogMetadata = Record<string, unknown>;
 export declare function setClient(c: PluginClient): void;
 export declare function resetClient(): void;
-export declare function info(msg: string): void;
-export declare function warn(msg: string): void;
-export declare function error(msg: string): void;
+export declare function info(msg: string, metadata?: LogMetadata): void;
+export declare function warn(msg: string, metadata?: LogMetadata): void;
+export declare function error(msg: string, metadata?: LogMetadata): void;

package/dist/logger.js

@@ -8,16 +8,20 @@ export function setClient(c) {
 export function resetClient() {
     client = null;
 }
+function buildBody(level, message, metadata) {
+    return {
+        service: "kibi-opencode",
+        level,
+        message,
+        ...(metadata ?? {}),
+    };
+}
 // implements REQ-opencode-kibi-plugin-v1
-export function info(msg) {
+export function info(msg, metadata) {
     if (client) {
         void client.app
             .log({
-            body: {
-                service: "kibi-opencode",
-                level: "info",
-                message: msg,
-            },
+            body: buildBody("info", msg, metadata),
         })
             .catch(console.error);
         return;
@@ -25,15 +29,11 @@ export function info(msg) {
     // Fallback when no client is available (e.g. during tests or early init)
 }
 // implements REQ-opencode-kibi-plugin-v1
-export function warn(msg) {
+export function warn(msg, metadata) {
     if (client) {
         void client.app
             .log({
-            body: {
-                service: "kibi-opencode",
-                level: "warn",
-                message: msg,
-            },
+            body: buildBody("warn", msg, metadata),
         })
             .catch(console.error);
         return;
@@ -41,18 +41,14 @@ export function warn(msg) {
     // Fallback when no client is available
 }
 // implements REQ-opencode-kibi-plugin-v1
-export function error(msg) {
+export function error(msg, metadata) {
     // Always emit to console for user visibility
     console.error("[kibi-opencode]", msg);
     // Also emit to structured logs if client is available
     if (client) {
         void client.app
             .log({
-            body: {
-                service: "kibi-opencode",
-                level: "error",
-                message: msg,
-            },
+            body: buildBody("error", msg, metadata),
         })
             .catch(console.error);
     }

package/dist/path-kind.d.ts

@@ -1,7 +1,7 @@
-export type PathKind = "code" | "requirement" | "scenario" | "test" | "adr" | "fact" | "kb" | "unknown";
+export type PathKind = "code" | "requirement" | "scenario" | "test" | "adr" | "fact" | "flag" | "event" | "symbol" | "kb" | "unknown";
 export interface PathAnalysis {
     kind: PathKind;
     isUnderKb: boolean;
     isKibiDocRelevant: boolean;
 }
-export declare function analyzePath(filePath: string, cwd: string): PathAnalysis;
+export declare function analyzePath(filePath: string, cwd?: string): PathAnalysis;