kibi-opencode 0.19.4 → 2.0.0

package/dist/smart-enforcement-events.js

@@ -0,0 +1,414 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import { analyzeCodeFile } from "./comment-analysis.js";
+import { analyzePath } from "./path-kind.js";
+import { isMustPriorityRequirement } from "./requirement-doc.js";
+import { classifyRisk } from "./risk-classifier.js";
+const TOOL_EVENT_TYPES = new Set([
+    "tool.execute.after",
+    "tool.executed",
+    "tool.call.completed",
+    "tool.Execute.after",
+    "tool.Call.completed",
+]);
+// implements REQ-opencode-kibi-plugin-v1
+export function isKbToolEventType(eventType) {
+    return TOOL_EVENT_TYPES.has(eventType);
+}
+// implements REQ-opencode-kibi-plugin-v1
+export function handleKbToolEvent(env, event, sessionId) {
+    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 = {
+            ...(sessionId !== undefined ? { sessionId } : {}),
+            agentIdentity: env.input.agentIdentity ?? "unknown",
+            worktree: env.input.worktree,
+            branch: env.rootWorkContext.branch,
+            fingerprint: `${env.input.sessionId ?? ""}-${env.rootWorkContext.branch}`,
+        };
+        try {
+            env.freshnessStore.recordToolEvidence(scope, toolName);
+            env.log.info("kb-freshness.tool-evidence", {
+                event: "kb_freshness_tool_evidence",
+                tool: toolName,
+            });
+        }
+        catch {
+            // best-effort, never crash the event handler
+        }
+    }
+}
+function resolveFileEvent(env, event) {
+    const filePath = event
+        .properties.file;
+    if (!filePath)
+        return null;
+    const eventContext = env.resolveScopedWorkContext(filePath);
+    const scopedSessionEditState = env.getSessionEditState(eventContext);
+    const scopedFileOperationState = env.getFileOperationState(eventContext);
+    const scopedPathKindCache = env.getPathKindCache(eventContext);
+    const scopedScheduler = env.getSchedulerForContext(eventContext);
+    const normalizedFilePath = env.normalizeSessionPath(filePath, eventContext.worktreeRoot);
+    const lifecycle = event.type === "file.created"
+        ? "created"
+        : event.type === "file.deleted"
+            ? "deleted"
+            : "edited";
+    return {
+        eventContext,
+        scopedSessionEditState,
+        scopedFileOperationState,
+        scopedPathKindCache,
+        scopedScheduler,
+        normalizedFilePath,
+        lifecycle,
+        focusEdit: undefined,
+    };
+}
+// implements REQ-opencode-file-context-guidance-v1
+// implements REQ-opencode-kibi-plugin-v1
+export function handleFileLifecycleEvent(env, event) {
+    const resolution = resolveFileEvent(env, event);
+    if (!resolution)
+        return;
+    const { eventContext, scopedSessionEditState, scopedFileOperationState, scopedPathKindCache, scopedScheduler, normalizedFilePath, lifecycle, } = resolution;
+    scopedFileOperationState.recordLifecycle(filePathOf(resolution), resolution.lifecycle, Date.now());
+    scopedFileOperationState.normalizePath(filePathOf(resolution));
+    const pathAnalysis = analyzePath(normalizedFilePath, eventContext.worktreeRoot);
+    if (lifecycle === "deleted") {
+        handleDeletedFile(env, {
+            eventContext,
+            scopedSessionEditState,
+            scopedPathKindCache,
+            scopedScheduler,
+            normalizedFilePath,
+            pathKind: pathAnalysis.kind,
+        });
+        return;
+    }
+    scopedSessionEditState.recordEventHint(normalizedFilePath, pathAnalysis.kind, Date.now());
+    scopedSessionEditState.reconcilePath(normalizedFilePath);
+    scopedPathKindCache.set(normalizedFilePath, pathAnalysis.kind);
+    const sessionEdits = scopedSessionEditState.getSessionEdits();
+    const focusEdit = scopedSessionEditState.getFocusEdit();
+    if (env.cfg.sync.enabled &&
+        scopedScheduler &&
+        env.fileFilter.shouldHandleFile(normalizedFilePath, eventContext.worktreeRoot)) {
+        scopedScheduler.scheduleSync(lifecycle === "created" ? "file.created" : "file.edited", normalizedFilePath);
+    }
+    const fileContent = env.readFileContent(normalizedFilePath, eventContext.worktreeRoot);
+    const hasMustPriority = pathAnalysis.kind === "requirement"
+        ? isMustPriorityRequirement(normalizedFilePath, eventContext.worktreeRoot)
+        : false;
+    let precomputedSuggestion = null;
+    if (pathAnalysis.kind === "code" &&
+        env.cfg.guidance.commentDetection.enabled) {
+        precomputedSuggestion = analyzeCodeFile(env.resolveWorktreePath(normalizedFilePath, eventContext.worktreeRoot), {
+            minLines: env.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;
+    env.state.lastRiskClass = effectiveRiskClass;
+    env.state.lastRiskFilePath = normalizedFilePath;
+    env.state.lastRiskScopeKey = env.buildRiskPathScopeKey(eventContext, normalizedFilePath);
+    env.log.info("smart-enforcement.risk", {
+        event: "smart_enforcement_risk",
+        file: normalizedFilePath,
+        path_kind: pathAnalysis.kind,
+        risk_class: effectiveRiskClass,
+        posture_state: eventContext.posture,
+        maintenance_state: env.getMaintenanceDegraded()
+            ? "maintenance_degraded"
+            : "maintenance_available",
+        under_kb: pathAnalysis.isUnderKb,
+        has_must_priority: hasMustPriority,
+        posture: eventContext.posture,
+        reason_code: effectiveRiskClass,
+        effective_mode: env.getEffectiveMode(),
+        static_degraded: env.posture.maintenanceDegraded,
+        runtime_degraded: env.runtimeOverlay.degraded,
+        merged_degraded: env.getMaintenanceDegraded(),
+        overlay_cause: env.runtimeOverlay.primaryCause ?? null,
+    });
+    const targetedChecksBlocked = env.getMaintenanceDegraded() ||
+        env.runtimeOverlay.primaryCause === "sync_disabled" ||
+        env.runtimeOverlay.primaryCause === "scheduler_unavailable" ||
+        env.runtimeOverlay.primaryCause === "scheduler_sync_failed" ||
+        env.runtimeOverlay.primaryCause === "scheduler_check_failed";
+    scheduleTargetedChecksForRisk(env, {
+        eventContext,
+        scopedScheduler,
+        normalizedFilePath,
+        pathKind: pathAnalysis.kind,
+        effectiveRiskClass,
+        targetedChecksBlocked,
+    });
+    env.updateRecentEditsFromSession(sessionEdits, scopedPathKindCache);
+    if (effectiveRiskClass === "safe_docs_only" ||
+        effectiveRiskClass === "safe_test_only") {
+        env.state.recentCommentSuggestion = null;
+        return;
+    }
+    const cacheKey = env.buildScopedCacheKey(eventContext, effectiveRiskClass, fileBucketOf(pathAnalysis.kind), [normalizedFilePath, pathAnalysis.kind, effectiveRiskClass]);
+    // Always process manual_kb_edit before cache check — critical safety signal
+    if (effectiveRiskClass === "manual_kb_edit") {
+        handleManualKbEdit(env, normalizedFilePath);
+        return;
+    }
+    // Always emit requirement lint warnings before cache check — safety signals
+    if (effectiveRiskClass === "req_policy_candidate") {
+        const lintWarnings = env.lintRequirementDoc(normalizedFilePath, eventContext.worktreeRoot);
+        for (const warning of lintWarnings) {
+            env.recordWarning(warning.category, normalizedFilePath, warning.message);
+        }
+    }
+    if (env.cache.isSatisfied(cacheKey)) {
+        env.log.info("smart-enforcement.cache", {
+            event: "smart_enforcement_cache",
+            cache_hit: true,
+            cache_state: "hit",
+            file: normalizedFilePath,
+            risk_class: effectiveRiskClass,
+            posture: eventContext.posture,
+            posture_state: eventContext.posture,
+        });
+        return;
+    }
+    env.log.info("smart-enforcement.cache", {
+        event: "smart_enforcement_cache",
+        cache_hit: false,
+        cache_state: "miss",
+        file: normalizedFilePath,
+        risk_class: effectiveRiskClass,
+        posture: eventContext.posture,
+        posture_state: eventContext.posture,
+    });
+    if (effectiveRiskClass === "req_policy_candidate") {
+        handleReqPolicyCandidate(env, {
+            eventContext,
+            scopedScheduler,
+            normalizedFilePath,
+            hasMustPriority,
+        });
+        return;
+    }
+    if (effectiveRiskClass === "kb_doc_structural") {
+        warnDegradedFor(env, "kb_doc_structural", normalizedFilePath, eventContext.posture);
+        return;
+    }
+    if (effectiveRiskClass === "behavior_candidate" ||
+        effectiveRiskClass === "traceability_candidate") {
+        emitBehaviorSuggestions(env, {
+            eventContext,
+            normalizedFilePath,
+            pathKind: pathAnalysis.kind,
+            commentDetectionEnabled: env.cfg.guidance.commentDetection.enabled,
+            precomputedSuggestion,
+        });
+    }
+}
+function filePathOf(resolution) {
+    return resolution.normalizedFilePath;
+}
+function fileBucketOf(kind) {
+    return kind;
+}
+function handleDeletedFile(env, args) {
+    const { eventContext, scopedSessionEditState, scopedPathKindCache, scopedScheduler, normalizedFilePath, pathKind, } = args;
+    // Preserve last known semantic risk if path was already tracked during session
+    const lastKnownKind = scopedPathKindCache.get(normalizedFilePath);
+    if (lastKnownKind) {
+        // Path was tracked — preserve last known semantic risk for reminder routing
+        scopedPathKindCache.set(normalizedFilePath, pathKind);
+    }
+    else {
+        // Not tracked — classify only for reminder routing.
+        scopedPathKindCache.set(normalizedFilePath, pathKind);
+    }
+    scopedSessionEditState.recordEventHint(normalizedFilePath, pathKind, Date.now());
+    scopedSessionEditState.reconcilePath(normalizedFilePath);
+    const sessionEdits = scopedSessionEditState.getSessionEdits();
+    env.updateRecentEditsFromSession(sessionEdits, scopedPathKindCache);
+    // Schedule background sync for deleted files that pass shouldHandleFile
+    if (env.cfg.sync.enabled &&
+        scopedScheduler &&
+        env.fileFilter.shouldHandleFile(normalizedFilePath, eventContext.worktreeRoot)) {
+        scopedScheduler.scheduleSync("file.deleted", normalizedFilePath);
+    }
+}
+function scheduleTargetedChecksForRisk(env, args) {
+    const { eventContext, scopedScheduler, normalizedFilePath, pathKind, effectiveRiskClass, targetedChecksBlocked, } = args;
+    if (!targetedChecksBlocked &&
+        env.cfg.sync.enabled &&
+        scopedScheduler &&
+        env.cfg.guidance.targetedChecks.enabled) {
+        const traceabilityRules = effectiveRiskClass === "traceability_candidate"
+            ? ["symbol-traceability"]
+            : null;
+        const kbStructuralRules = effectiveRiskClass === "kb_doc_structural" &&
+            env.fileFilter.shouldHandleFile(normalizedFilePath, eventContext.worktreeRoot)
+            ? [
+                "required-fields",
+                "no-dangling-refs",
+                ...(pathKind === "fact" ? ["strict-fact-shape"] : []),
+                ...(pathKind === "requirement" ? ["strict-req-fact-pairing"] : []),
+            ]
+            : null;
+        const checkRules = traceabilityRules ?? kbStructuralRules;
+        if (checkRules) {
+            env.log.info("smart-enforcement.targeted-checks", {
+                event: "smart_enforcement_targeted_checks",
+                file: normalizedFilePath,
+                risk_class: effectiveRiskClass,
+                posture: eventContext.posture,
+                posture_state: eventContext.posture,
+                guidance_action: "targeted_checks",
+                effective_mode: env.getEffectiveMode(),
+                rules: checkRules,
+                static_degraded: env.posture.maintenanceDegraded,
+                runtime_degraded: env.runtimeOverlay.degraded,
+                merged_degraded: env.getMaintenanceDegraded(),
+                overlay_cause: env.runtimeOverlay.primaryCause ?? null,
+            });
+            env.log.info(`kibi-opencode: scheduling sync for ${normalizedFilePath}`);
+            scopedScheduler.scheduleSync(effectiveRiskClass === "traceability_candidate"
+                ? "smart-enforcement.traceability"
+                : "smart-enforcement.kb-doc", normalizedFilePath, checkRules);
+        }
+    }
+}
+function handleManualKbEdit(env, normalizedFilePath) {
+    env.state.hasRecentKbEdit = true;
+    if (env.cfg.guidance.warnOnKbEdits) {
+        env.log.warn(`kibi-opencode: .kb edit detected for ${normalizedFilePath}`);
+        env.recordWarning("kb-edit", normalizedFilePath, `Manual .kb edit: ${normalizedFilePath}`);
+    }
+}
+function lintRequirementPolicy(env, normalizedFilePath, worktreeRoot) {
+    const lintWarnings = env.lintRequirementDoc(normalizedFilePath, worktreeRoot);
+    for (const warning of lintWarnings) {
+        env.recordWarning(warning.category, normalizedFilePath, warning.message);
+    }
+}
+function warnDegradedFor(env, riskClass, normalizedFilePath, posture) {
+    if (!env.getMaintenanceDegraded())
+        return;
+    const logFn = env.cfg.guidance.smartEnforcement.degradedMode === "warn-once"
+        ? env.log.warn
+        : env.log.info;
+    logFn("smart-enforcement.degraded", {
+        event: "smart_enforcement_degraded",
+        file: normalizedFilePath,
+        risk_class: riskClass,
+        posture,
+        posture_state: posture,
+        maintenance_state: env.getMaintenanceDegraded()
+            ? "maintenance_degraded"
+            : "maintenance_available",
+        reason: env.runtimeOverlay.primaryCause ?? "non_authoritative_posture",
+        reason_code: env.runtimeOverlay.primaryCause ?? "non_authoritative_posture",
+        static_degraded: false,
+        runtime_degraded: env.runtimeOverlay.degraded,
+        merged_degraded: env.getMaintenanceDegraded(),
+        overlay_cause: env.runtimeOverlay.primaryCause ?? null,
+        effective_mode: env.getEffectiveMode(),
+    });
+}
+function handleReqPolicyCandidate(env, args) {
+    const { eventContext, scopedScheduler, normalizedFilePath, hasMustPriority } = args;
+    warnDegradedFor(env, "req_policy_candidate", normalizedFilePath, {
+        posture: eventContext.posture,
+    });
+    if (!env.getMaintenanceDegraded() &&
+        env.cfg.sync.enabled &&
+        scopedScheduler &&
+        env.fileFilter.shouldHandleFile(normalizedFilePath, eventContext.worktreeRoot)) {
+        let checkRules;
+        if (env.cfg.guidance.targetedChecks.enabled) {
+            if (hasMustPriority && env.getEffectiveMode() === "strict") {
+                checkRules = [
+                    "required-fields",
+                    "no-dangling-refs",
+                    "must-priority-coverage",
+                    "strict-req-fact-pairing",
+                ];
+                env.log.info(`kibi-opencode: must-priority requirement detected, scheduling elevated checks for ${normalizedFilePath}`);
+            }
+            else {
+                checkRules = [
+                    "required-fields",
+                    "no-dangling-refs",
+                    "strict-req-fact-pairing",
+                ];
+            }
+        }
+        env.log.info("smart-enforcement.targeted-checks", {
+            event: "smart_enforcement_targeted_checks",
+            file: normalizedFilePath,
+            risk_class: "req_policy_candidate",
+            posture: eventContext.posture,
+            posture_state: eventContext.posture,
+            guidance_action: "targeted_checks",
+            effective_mode: env.getEffectiveMode(),
+            rules: checkRules ?? [],
+            static_degraded: env.posture.maintenanceDegraded,
+            runtime_degraded: env.runtimeOverlay.degraded,
+            merged_degraded: env.getMaintenanceDegraded(),
+            overlay_cause: env.runtimeOverlay.primaryCause ?? null,
+        });
+        scopedScheduler.scheduleSync("file.edited", normalizedFilePath, checkRules);
+    }
+}
+function emitBehaviorSuggestions(env, args) {
+    const { eventContext, normalizedFilePath, pathKind, precomputedSuggestion } = args;
+    const inspectingCodeComments = pathKind === "code" && env.cfg.guidance.commentDetection.enabled;
+    const suggestion = nextRecentCommentSuggestion(inspectingCodeComments, precomputedSuggestion);
+    env.state.recentCommentSuggestion = suggestion;
+    if (suggestion) {
+        const dedupeKey = `${env.buildRiskPathScopeKey(eventContext, normalizedFilePath)}:${suggestion.suggestionType}:${suggestion.fingerprint}`;
+        if (!env.state.seenFingerprints.has(dedupeKey)) {
+            env.state.seenFingerprints.add(dedupeKey);
+            const warningCategory = suggestion.suggestionType === "fact"
+                ? "long-comment-missed-fact"
+                : suggestion.suggestionType === "adr"
+                    ? "long-comment-missed-adr"
+                    : "missing-traceability";
+            env.log.warn(`kibi-opencode: detected durable ${suggestion.suggestionType} knowledge in ${normalizedFilePath}`);
+            env.recordWarning(warningCategory, normalizedFilePath, `Consider routing this ${suggestion.suggestionType} knowledge to Kibi instead of inline comments: ${suggestion.reasoning}`);
+        }
+    }
+}
+function nextRecentCommentSuggestion(inspectingCodeComments, suggestion) {
+    if (inspectingCodeComments && suggestion)
+        return suggestion;
+    return null;
+}

package/dist/version-metadata.json

@@ -1 +1 @@
-{"opencode":"0.19.4","mcp":"0.22.0","cli":"0.19.0","core":"0.10.0"}
+{"opencode":"2.0.0","mcp":"2.0.0","cli":"2.0.0","core":"0.12.0"}

package/dist/work-context-resolver.d.ts

@@ -17,5 +17,15 @@ export interface WorkContext {
     sessionId: string | undefined;
     agentIdentity: string;
 }
+export interface GitMetadata {
+    worktreeRoot: string;
+    gitDir: string;
+    commonGitDir: string;
+    isLinkedWorktree: boolean;
+}
+export declare function nextAncestorDirectory(current: string): string | undefined;
+export declare function authorityRootFromLinkedGitDir(gitDir: string): string | null;
+export declare function ancestorKbRoots(start: string): string[];
+export declare function resolveBranch(git: GitMetadata | null): string;
 declare const resolveWorkContext: (input: ResolveWorkContextInput) => WorkContext;
 export { resolveWorkContext };

package/dist/work-context-resolver.js

@@ -46,10 +46,14 @@ function directorySearchStart(candidatePath) {
     const stats = safeStat(resolved);
     return stats?.isDirectory() ? resolved : dirname(resolved);
 }
+export function nextAncestorDirectory(current) {
+    const parent = dirname(current);
+    return parent === current ? undefined : parent;
+}
 function findGitMetadata(candidatePath, searchBoundary) {
     let current = directorySearchStart(candidatePath);
     const boundary = searchBoundary ? resolve(searchBoundary) : null;
-    while (true) {
+    while (current !== undefined) {
         const dotGitPath = join(current, ".git");
         const dotGitStats = safeStat(dotGitPath);
         if (dotGitStats?.isFile()) {
@@ -74,15 +78,12 @@ function findGitMetadata(candidatePath, searchBoundary) {
         if (boundary !== null && current === boundary) {
             return null;
         }
-        const parent = dirname(current);
-        if (parent === current) {
-            return null;
-        }
-        current = parent;
+        current = nextAncestorDirectory(current);
     }
+    return null;
 }
 function hasRootKbConfig(root) {
-    return existsSync(join(root, ".kb", "config.json"));
+    return existsSync(join(root, ".kb", "manifest.json"));
 }
 function uniqueResolved(paths) {
     const seen = new Set();
@@ -103,7 +104,7 @@ function uniqueResolved(paths) {
 function authorityRootFromCommonGitDir(commonGitDir) {
     return basename(commonGitDir) === ".git" ? dirname(commonGitDir) : null;
 }
-function authorityRootFromLinkedGitDir(gitDir) {
+export function authorityRootFromLinkedGitDir(gitDir) {
     const normalizedGitDir = resolve(gitDir);
     const marker = `${sep}.git${sep}worktrees${sep}`;
     const markerIndex = normalizedGitDir.indexOf(marker);
@@ -112,19 +113,16 @@ function authorityRootFromLinkedGitDir(gitDir) {
     }
     return normalizedGitDir.slice(0, markerIndex);
 }
-function ancestorKbRoots(start) {
+export function ancestorKbRoots(start) {
     const roots = [];
     let current = resolve(start);
-    while (true) {
+    while (current !== undefined) {
         if (hasRootKbConfig(current)) {
             roots.push(current);
         }
-        const parent = dirname(current);
-        if (parent === current) {
-            return roots;
-        }
-        current = parent;
+        current = nextAncestorDirectory(current);
     }
+    return roots;
 }
 function resolveAuthorityRoot(git, inputDirectory) {
     if (!git.isLinkedWorktree) {
@@ -141,7 +139,7 @@ function resolveAuthorityRoot(git, inputDirectory) {
         candidates[0] ??
         git.worktreeRoot);
 }
-function resolveBranch(git) {
+export function resolveBranch(git) {
     if (!git) {
         return "unknown";
     }
@@ -157,7 +155,7 @@ function resolveBranch(git) {
         return "HEAD";
     }
     const branch = ref.slice("refs/heads/".length);
-    return branch === "master" ? "main" : branch;
+    return branch;
 }
 function normalizeRepoRelativePath(fromRoot, targetPath) {
     const rawRelativePath = relative(fromRoot, targetPath);

package/dist/workspace-health.js

@@ -3,18 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { getKbExistenceTargets } from "./file-filter.js";
 import { detectPosture } from "./repo-posture.js";
-const KB_CONFIG_FILE = ".kb/config.json";
-// Fallback defaults used when .kb/config.json does not exist
-const KIBI_DOC_DIRS = [
-    "documentation/requirements",
-    "documentation/scenarios",
-    "documentation/tests",
-    "documentation/adr",
-    "documentation/flags",
-    "documentation/events",
-    "documentation/facts",
-    "documentation/symbols.yaml",
-];
+const KB_MANIFEST_FILE = ".kb/manifest.json";
 // implements REQ-opencode-kibi-plugin-v1
 /**
  * Analyze workspace health for Kibi bootstrap and initialization.
@@ -22,56 +11,19 @@ const KIBI_DOC_DIRS = [
  * bootstrap-needs to the posture result.
  */
 export function checkWorkspaceHealth(cwd) {
-    // Use posture detection for root-scoped classification
     const posture = detectPosture(cwd);
-    const configPath = path.join(cwd, KB_CONFIG_FILE);
-    const missingConfig = !fs.existsSync(configPath);
+    const manifestPath = path.join(cwd, KB_MANIFEST_FILE);
+    const missingConfig = !fs.existsSync(manifestPath);
     const missingDocDirs = [];
-    if (missingConfig) {
-        // No config file: fall back to hardcoded defaults
-        for (const docDir of KIBI_DOC_DIRS) {
-            const fullPath = path.resolve(cwd, docDir);
-            if (!fs.existsSync(fullPath)) {
-                missingDocDirs.push(docDir);
-            }
+    const targets = getKbExistenceTargets(cwd);
+    for (const target of targets) {
+        const fullPath = path.resolve(cwd, target.relativePath);
+        if (!fs.existsSync(fullPath)) {
+            missingDocDirs.push(target.relativePath);
         }
     }
-    else {
-        // Config exists: check if user specified custom paths
-        let hasUserPaths = false;
-        try {
-            const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
-            hasUserPaths = Boolean(raw?.paths);
-        }
-        catch {
-            hasUserPaths = false;
-        }
-        if (hasUserPaths) {
-            // User has custom paths: resolve targets dynamically
-            const targets = getKbExistenceTargets(cwd);
-            for (const target of targets) {
-                const fullPath = path.resolve(cwd, target.relativePath);
-                if (!fs.existsSync(fullPath)) {
-                    missingDocDirs.push(target.relativePath);
-                }
-            }
-        }
-        else {
-            // Config exists but no custom paths: use hardcoded defaults
-            for (const docDir of KIBI_DOC_DIRS) {
-                const fullPath = path.resolve(cwd, docDir);
-                if (!fs.existsSync(fullPath)) {
-                    missingDocDirs.push(docDir);
-                }
-            }
-        }
-    }
-    // Check for any evidence of Kibi usage
     const kbDir = path.join(cwd, ".kb");
     const hasKbEvidence = fs.existsSync(kbDir) && fs.readdirSync(kbDir).length > 0;
-    // Restore lenient threshold for repos that have a config but are missing a few dirs.
-    // Uninitialized repos always need bootstrap; partial repos fall back to the legacy
-    // >2 missing dirs threshold so small gaps (e.g. unused flags/events) do not nag.
     const needsBootstrap = posture.state === "root_uninitialized" ||
         (posture.state === "root_partial" && missingDocDirs.length > 2);
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-opencode",
-  "version": "0.19.4",
+  "version": "2.0.0",
   "description": "Kibi OpenCode plugin - thin adapter to integrate Kibi with OpenCode sessions",
   "type": "module",
   "main": "dist/index.js",
@@ -37,9 +37,11 @@
       "default": "./dist/tui.js"
     }
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "license": "AGPL-3.0-or-later",
   "repository": {
@@ -60,7 +62,7 @@
     "@opencode-ai/plugin": "^1.4.7",
     "@opentui/core": "^0.1.99",
     "@opentui/solid": "^0.1.99",
-    "kibi-cli": "^0.19.0"
+    "kibi-runtime": "^2.0.0"
   },
   "devDependencies": {
     "@types/node": "latest",

package/dist/init-kibi-alias.d.ts

@@ -1,14 +0,0 @@
-/**
- * Builds the canonical native alias for the Kibi MCP bootstrap workflow.
- * This is a thin wrapper over the MCP-defined workflow, preserving all
- * semantic markers while removing namespacing and keeping text concise.
- *
- * Markers (MUST PRESERVE):
- * - "at most 4 bounded questions"
- * - "kb_autopilot_generate"
- * - "preview" or "approval"
- * - "kb_upsert"
- * - "kb_check"
- * - "sequential" or similar ordering language
- */
-export declare function buildInitKibiAlias(): string;