kibi-opencode 0.15.4 → 0.18.0

package/README.md

@@ -22,6 +22,23 @@ Or via OpenCode's plugin system in `opencode.json`:
 }
 ```
 
+By default, the plugin checks npm on OpenCode startup and refreshes only the
+cached `kibi-opencode` plugin package when a newer version is available. The
+base `kibi-cli`, `kibi-mcp`, and `kibi-core` project dependencies are never
+updated by this plugin updater.
+
+Use an exact semver entry when you want a fixed plugin version:
+
+```json
+{
+  "plugin": ["kibi-opencode@0.15.0"]
+}
+```
+
+Exact semver pins are respected: the updater will notify that a newer plugin is
+available, but it will not replace the pinned version until you change the
+plugin array. Dist-tags such as `kibi-opencode@latest` remain auto-updatable.
+
 Configure the MCP server separately with the project-local `kibi-mcp` binary.
 The plugin may run internal maintenance commands such as `kibi sync` and
 `kibi check`, so the project-local `kibi` CLI should resolve from the OpenCode
@@ -39,7 +56,7 @@ The plugin now uses a posture-aware, low-token smart-enforcement model before em
 - **Start-task risky cue**: authoritative risky edits also add a compact Kibi context cue so agents can start with explicit source-linked guidance before acting, while staying inside the same single prompt block and token budget.
 - **Effective mode gating**: `advisory` (default) never blocks; `strict` escalates checks and reminders for `root_active` and `hybrid_root_plus_vendored` postures when `requireRootKbForStrict` is enabled; `hard` fails closed for authoritative roots and linked git worktrees, injecting a stop-state with MCP recovery steps until the Kibi checkpoint passes. `maintenanceDegraded` overrides everything back to `advisory`.
 - **Low-token prompt policy**: docs-only and test-only edits avoid unnecessary discovery prompts; vendored-only repos suppress operational bootstrap nudges; at most one contextual block is injected per prompt (≤120 words, ≤5 bullets)
-- **Completion reminder**: when `completionReminder` is enabled, risky code edits append a single prompt-visible `kb_check` reminder exactly once per cached context
+- **Completion reminder**: when `completionReminder` is enabled, risky code edits append a single prompt-visible impact-enabled `kb_check` reminder exactly once per cached context
 - **Runtime maintenance overlay**: static `maintenanceDegraded` from posture is merged with a latched runtime overlay (sync disabled/unavailable/failing) so degraded state is consistently reflected in prompts, logs, and mode decisions
 - **Three-mode enforcement**: `advisory` by default keeps guidance non-blocking; opt-in `strict` adds elevated validation cues; `hard` blocks the prompt for authoritative workspaces until the checkpoint cycle succeeds. Git hooks and KB validation checks remain the durable enforcement boundary for all modes.
 - **Structured observability**: posture, risk, cache, degraded-mode, targeted-check, and guidance events flow through structured plugin logs
@@ -58,11 +75,13 @@ modified, the plugin evaluates KB freshness evidence and surfaces a visible
   discovery via `kb_search` or `kb_query(sourceFile=...)` and `kb_check`.
 - **Deferred/Failed**: Do not claim task completion.
 
+For meaningful source edits, the first gate is MCP `kb_check` with impact options, for example `kb_check({sourceFiles:["src/feature.ts"], includeImpactDiagnostics:true, includeWorkingTreeDiff:true})`. These diagnostics guide symbol granularity, requirement ownership, and semantic review of linked requirements/tests; they do not prove source behavior matches prose.
+
 ### Dynamic Contextual Guidance
 
 The plugin provides context-aware prompt guidance based on recent edits and workspace state:
 
-- **Code edits**: Guidance for querying Kibi by sourceFile, preferring Kibi over comments, and adding `// implements REQ-xxx` traceability
+- **Code edits**: Guidance for running impact-enabled `kb_check`, querying Kibi by sourceFile, preferring Kibi over comments, and adding or updating symbol traceability
 - **Requirement edits**: Guidance for maintaining separate REQ/SCEN/TEST artifacts and avoiding embedded scenarios
 - **KB doc edits**: Guidance for proper entity relationships and validation
 - **Bootstrap needed**: Detection and nudges for uninitialized repos
@@ -177,6 +196,7 @@ Config files (project overrides global):
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
 | `enabled` | boolean | `true` | Enable/disable all plugin features |
+| `autoUpdate` | boolean | `true` | Automatically refresh the cached `kibi-opencode` plugin package on OpenCode startup unless the plugin array uses an exact semver pin |
 | `prompt.enabled` | boolean | `true` | Enable prompt guidance injection |
 | `prompt.hookMode` | string | `"auto"` | Hook mode: `auto`, `chat-params`, `system-transform`, `compat` |
 | `sync.enabled` | boolean | `true` | Enable automatic sync |
@@ -187,7 +207,6 @@ Config files (project overrides global):
 | `ux.toastFailures` | boolean | `true` | Show failure toasts for sync/check issues |
 | `ux.toastSuccesses` | boolean | `false` | Show success toasts for sync/check completion |
 | `ux.toastCooldownMs` | number | `10000` | Cooldown between repeated UX toasts |
-PP|| `guidance.dynamic` | boolean | `true` | Enable dynamic contextual guidance |
 | `guidance.dynamic` | boolean | `true` | Enable dynamic contextual guidance |
 | `guidance.warnOnKbEdits` | boolean | `true` | Enable loud warnings for .kb/** edits |
 | `guidance.factFirstDomainRouting` | boolean | `true` | Enable FACT-first domain routing suggestions |

package/dist/auto-update.d.ts

@@ -0,0 +1,31 @@
+export interface KibiOpencodePluginEntry {
+    entry: string;
+    isPinned: boolean;
+    requestedVersion: string | null;
+    configPath: string;
+}
+export type AutoUpdateStatus = "disabled" | "plugin-not-found" | "current-version-unknown" | "latest-version-unknown" | "up-to-date" | "pinned" | "updated" | "install-failed";
+export interface AutoUpdateResult {
+    status: AutoUpdateStatus;
+    currentVersion?: string;
+    latestVersion?: string;
+}
+export interface AutoUpdateInput {
+    directory: string;
+    enabled: boolean;
+}
+export interface AutoUpdateRunnerDeps {
+    getCurrentVersion: () => string | null;
+    getLatestVersion: (channel?: string) => Promise<string | null>;
+    invalidatePackage: () => boolean;
+    runInstall: () => Promise<boolean>;
+    notify: (message: string) => Promise<void>;
+    log: (message: string, metadata?: Record<string, unknown>) => void;
+}
+export declare function findKibiOpencodePluginEntry(directory: string): KibiOpencodePluginEntry | null;
+export declare function getCachedPluginVersion(): string | null;
+export declare function getLatestPluginVersion(channel?: string): Promise<string | null>;
+export declare function invalidateKibiOpencodePackage(): boolean;
+export declare function runBunInstallForOpenCodePlugin(): Promise<boolean>;
+export declare function createAutoUpdateRunner(deps: AutoUpdateRunnerDeps): (input: AutoUpdateInput) => Promise<AutoUpdateResult>;
+export declare const runKibiOpencodeAutoUpdate: (input: AutoUpdateInput) => Promise<AutoUpdateResult>;

package/dist/auto-update.js

@@ -0,0 +1,396 @@
+import { execFile } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as logger from "./logger.js";
+const PACKAGE_NAME = "kibi-opencode";
+const NPM_DIST_TAGS_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+const NPM_FETCH_TIMEOUT_MS = 5000;
+const EXACT_SEMVER_REGEX = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function parseJsonObject(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return null;
+    }
+    catch (err) {
+        logger.info("auto-update: failed to parse JSON", {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return null;
+    }
+}
+function stripJsonComments(raw) {
+    return raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|\s)\/\/.*$/gm, "$1");
+}
+function configPaths(directory) {
+    const home = os.homedir();
+    return [
+        path.join(directory, "opencode.json"),
+        path.join(directory, "opencode.jsonc"),
+        path.join(directory, ".opencode", "opencode.json"),
+        path.join(directory, ".opencode", "opencode.jsonc"),
+        path.join(home, ".config", "opencode", "opencode.json"),
+        path.join(home, ".config", "opencode", "opencode.jsonc"),
+    ];
+}
+export function findKibiOpencodePluginEntry(directory) {
+    for (const configPath of configPaths(directory)) {
+        if (!fs.existsSync(configPath)) {
+            continue;
+        }
+        const parsed = parseJsonObject(stripJsonComments(fs.readFileSync(configPath, "utf8")));
+        const plugins = parsed?.plugin;
+        if (!Array.isArray(plugins)) {
+            continue;
+        }
+        for (const candidate of plugins) {
+            if (typeof candidate !== "string") {
+                continue;
+            }
+            if (candidate === PACKAGE_NAME) {
+                return {
+                    entry: candidate,
+                    isPinned: false,
+                    requestedVersion: null,
+                    configPath,
+                };
+            }
+            if (candidate.startsWith(`${PACKAGE_NAME}@`)) {
+                const requestedVersion = candidate
+                    .slice(PACKAGE_NAME.length + 1)
+                    .trim();
+                return {
+                    entry: candidate,
+                    isPinned: EXACT_SEMVER_REGEX.test(requestedVersion),
+                    requestedVersion,
+                    configPath,
+                };
+            }
+            if (candidate.startsWith("file://") && candidate.includes(PACKAGE_NAME)) {
+                return {
+                    entry: candidate,
+                    isPinned: true,
+                    requestedVersion: null,
+                    configPath,
+                };
+            }
+        }
+    }
+    return null;
+}
+function getOpenCodeConfigDir() {
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+        return path.join(appData, "opencode");
+    }
+    return path.join(os.homedir(), ".config", "opencode");
+}
+function getOpenCodeCacheRoot() {
+    if (process.platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+        return path.join(localAppData, "opencode");
+    }
+    if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Caches", "opencode");
+    }
+    return path.join(process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache"), "opencode");
+}
+function getOpenCodePackagesCacheDir() {
+    return path.join(getOpenCodeCacheRoot(), "packages");
+}
+function parseSemver(version) {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/);
+    if (!match) {
+        return null;
+    }
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    const patch = Number(match[3]);
+    if (!Number.isInteger(major) ||
+        !Number.isInteger(minor) ||
+        !Number.isInteger(patch)) {
+        return null;
+    }
+    return {
+        core: [major, minor, patch],
+        prerelease: match[4]?.split(".") ?? [],
+    };
+}
+function isNumericPrereleaseIdentifier(value) {
+    return /^(0|[1-9]\d*)$/.test(value);
+}
+function comparePrereleaseIdentifiers(left, right) {
+    const leftIsNumeric = isNumericPrereleaseIdentifier(left);
+    const rightIsNumeric = isNumericPrereleaseIdentifier(right);
+    if (leftIsNumeric && rightIsNumeric) {
+        return Number(left) - Number(right);
+    }
+    if (leftIsNumeric) {
+        return -1;
+    }
+    if (rightIsNumeric) {
+        return 1;
+    }
+    return left.localeCompare(right, "en", { sensitivity: "variant" });
+}
+function comparePrerelease(left, right) {
+    if (left.length === 0 && right.length === 0) {
+        return 0;
+    }
+    if (left.length === 0) {
+        return 1;
+    }
+    if (right.length === 0) {
+        return -1;
+    }
+    const maxLength = Math.max(left.length, right.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftPart = left[index];
+        const rightPart = right[index];
+        if (leftPart === undefined) {
+            return -1;
+        }
+        if (rightPart === undefined) {
+            return 1;
+        }
+        const comparison = comparePrereleaseIdentifiers(leftPart, rightPart);
+        if (comparison !== 0) {
+            return comparison;
+        }
+    }
+    return 0;
+}
+function isSemverGreaterThan(candidate, current) {
+    const candidateVersion = parseSemver(candidate);
+    const currentVersion = parseSemver(current);
+    if (!candidateVersion || !currentVersion) {
+        return false;
+    }
+    for (const index of [0, 1, 2]) {
+        if (candidateVersion.core[index] > currentVersion.core[index]) {
+            return true;
+        }
+        if (candidateVersion.core[index] < currentVersion.core[index]) {
+            return false;
+        }
+    }
+    return (comparePrerelease(candidateVersion.prerelease, currentVersion.prerelease) >
+        0);
+}
+function readVersionFromPackageJson(packageJsonPath) {
+    if (!fs.existsSync(packageJsonPath)) {
+        return null;
+    }
+    const parsed = parseJsonObject(fs.readFileSync(packageJsonPath, "utf8"));
+    return typeof parsed?.version === "string" ? parsed.version : null;
+}
+function findPackageJsonUp(startUrl) {
+    let current = path.dirname(fileURLToPath(startUrl));
+    while (true) {
+        const packageJsonPath = path.join(current, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            const parsed = parseJsonObject(fs.readFileSync(packageJsonPath, "utf8"));
+            if (parsed?.name === PACKAGE_NAME) {
+                return packageJsonPath;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+export function getCachedPluginVersion() {
+    const packageJsonCandidates = [
+        path.join(getOpenCodeConfigDir(), "node_modules", PACKAGE_NAME, "package.json"),
+        path.join(getOpenCodeCacheRoot(), "node_modules", PACKAGE_NAME, "package.json"),
+        path.join(getOpenCodePackagesCacheDir(), "node_modules", PACKAGE_NAME, "package.json"),
+    ];
+    for (const candidate of packageJsonCandidates) {
+        const version = readVersionFromPackageJson(candidate);
+        if (version) {
+            return version;
+        }
+    }
+    const runningPackageJson = findPackageJsonUp(import.meta.url);
+    return runningPackageJson
+        ? readVersionFromPackageJson(runningPackageJson)
+        : null;
+}
+export async function getLatestPluginVersion(channel = "latest") {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT_MS);
+    try {
+        const response = await fetch(NPM_DIST_TAGS_URL, {
+            signal: controller.signal,
+            headers: { Accept: "application/json" },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const tags = (await response.json());
+        const selected = tags[channel] ?? tags.latest;
+        return typeof selected === "string" ? selected : null;
+    }
+    catch (err) {
+        logger.info("auto-update: failed to fetch latest version", {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function removePackageDir(dir) {
+    if (!fs.existsSync(dir)) {
+        return false;
+    }
+    fs.rmSync(dir, { recursive: true, force: true });
+    return true;
+}
+function removeSpecifierCacheDirs(cacheDir) {
+    if (!fs.existsSync(cacheDir)) {
+        return false;
+    }
+    let removed = false;
+    for (const entry of fs.readdirSync(cacheDir, { withFileTypes: true })) {
+        if (entry.isDirectory() && entry.name.startsWith(`${PACKAGE_NAME}@`)) {
+            fs.rmSync(path.join(cacheDir, entry.name), {
+                recursive: true,
+                force: true,
+            });
+            removed = true;
+        }
+    }
+    return removed;
+}
+function removeEveryPath(paths) {
+    let removed = false;
+    for (const targetPath of paths) {
+        if (removePackageDir(targetPath)) {
+            removed = true;
+        }
+    }
+    return removed;
+}
+function removeSpecifiersFromEveryDir(dirs) {
+    let removed = false;
+    for (const dir of dirs) {
+        if (removeSpecifierCacheDirs(dir)) {
+            removed = true;
+        }
+    }
+    return removed;
+}
+export function invalidateKibiOpencodePackage() {
+    const configDir = getOpenCodeConfigDir();
+    const cacheRoot = getOpenCodeCacheRoot();
+    const packagesCacheDir = getOpenCodePackagesCacheDir();
+    const removedPackageDirs = removeEveryPath([
+        path.join(configDir, "node_modules", PACKAGE_NAME),
+        path.join(cacheRoot, "node_modules", PACKAGE_NAME),
+        path.join(packagesCacheDir, "node_modules", PACKAGE_NAME),
+    ]);
+    const removedSpecifierDirs = removeSpecifiersFromEveryDir([
+        cacheRoot,
+        packagesCacheDir,
+    ]);
+    const removedLock = removeEveryPath([
+        path.join(cacheRoot, "bun.lock"),
+        path.join(cacheRoot, "bun.lockb"),
+        path.join(packagesCacheDir, "bun.lock"),
+        path.join(packagesCacheDir, "bun.lockb"),
+    ]);
+    return removedPackageDirs || removedSpecifierDirs || removedLock;
+}
+function activeInstallWorkspace() {
+    const configDir = getOpenCodeConfigDir();
+    const cacheRoot = getOpenCodeCacheRoot();
+    const packagesCacheDir = getOpenCodePackagesCacheDir();
+    if (fs.existsSync(path.join(configDir, "node_modules", PACKAGE_NAME, "package.json"))) {
+        return configDir;
+    }
+    if (fs.existsSync(path.join(cacheRoot, "node_modules", PACKAGE_NAME, "package.json"))) {
+        return cacheRoot;
+    }
+    return packagesCacheDir;
+}
+export function runBunInstallForOpenCodePlugin() {
+    return new Promise((resolve) => {
+        const workspace = activeInstallWorkspace();
+        fs.mkdirSync(workspace, { recursive: true });
+        execFile("bun", ["install"], { cwd: workspace }, (error) => {
+            resolve(error === null);
+        });
+    });
+}
+function channelForEntry(entry) {
+    if (!entry.requestedVersion || entry.isPinned) {
+        return "latest";
+    }
+    return entry.requestedVersion;
+}
+export function createAutoUpdateRunner(deps) {
+    return async function runAutoUpdate(input) {
+        if (!input.enabled) {
+            deps.log("auto-update: disabled");
+            return { status: "disabled" };
+        }
+        const pluginEntry = findKibiOpencodePluginEntry(input.directory);
+        if (!pluginEntry) {
+            deps.log("auto-update: kibi-opencode plugin entry not found");
+            return { status: "plugin-not-found" };
+        }
+        const currentVersion = deps.getCurrentVersion() ?? pluginEntry.requestedVersion;
+        if (!currentVersion) {
+            deps.log("auto-update: current version unknown");
+            return { status: "current-version-unknown" };
+        }
+        const latestVersion = await deps.getLatestVersion(channelForEntry(pluginEntry));
+        if (!latestVersion) {
+            deps.log("auto-update: latest version unknown");
+            return { status: "latest-version-unknown", currentVersion };
+        }
+        if (currentVersion === latestVersion ||
+            !isSemverGreaterThan(latestVersion, currentVersion)) {
+            deps.log("auto-update: plugin already up to date", {
+                currentVersion,
+                latestVersion,
+            });
+            return { status: "up-to-date", currentVersion, latestVersion };
+        }
+        if (pluginEntry.isPinned) {
+            await deps.notify(`${PACKAGE_NAME} ${latestVersion} is available; current plugin entry is pinned to ${currentVersion}.`);
+            deps.log("auto-update: exact semver pin detected, skipping install", {
+                currentVersion,
+                latestVersion,
+                entry: pluginEntry.entry,
+            });
+            return { status: "pinned", currentVersion, latestVersion };
+        }
+        deps.invalidatePackage();
+        const installed = await deps.runInstall();
+        if (!installed) {
+            await deps.notify(`${PACKAGE_NAME} ${latestVersion} is available, but automatic install failed.`);
+            return { status: "install-failed", currentVersion, latestVersion };
+        }
+        await deps.notify(`${PACKAGE_NAME} updated from ${currentVersion} to ${latestVersion}. Restart OpenCode to apply.`);
+        return { status: "updated", currentVersion, latestVersion };
+    };
+}
+export const runKibiOpencodeAutoUpdate = createAutoUpdateRunner({
+    getCurrentVersion: getCachedPluginVersion,
+    getLatestVersion: getLatestPluginVersion,
+    invalidatePackage: invalidateKibiOpencodePackage,
+    runInstall: runBunInstallForOpenCodePlugin,
+    notify: async (message) => {
+        logger.info("auto-update.notification", { message });
+    },
+    log: (message, metadata) => logger.info(message, metadata),
+});

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 export interface KibiConfig {
     enabled: boolean;
+    autoUpdate: boolean;
     prompt: {
         enabled: boolean;
         hookMode: "auto" | "chat-params" | "system-transform" | "compat";

package/dist/config.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import * as logger from "./logger.js";
 const DEFAULTS = {
     enabled: true,
+    autoUpdate: true,
     prompt: { enabled: true, hookMode: "auto" },
     sync: { enabled: true, debounceMs: 2000, ignore: [], relevant: [] },
     ux: {
@@ -64,6 +65,8 @@ export function validateAndMerge(obj) {
     const out = { ...DEFAULTS };
     if (typeof src.enabled === "boolean")
         out.enabled = src.enabled;
+    if (typeof src.autoUpdate === "boolean")
+        out.autoUpdate = src.autoUpdate;
     if (src.prompt && typeof src.prompt === "object") {
         const p = src.prompt;
         out.prompt = { ...DEFAULTS.prompt };

package/dist/enforcement-policy.js

@@ -25,6 +25,7 @@ const ADVISORY_EDIT_KINDS = new Set([
     "symbol",
     "kb",
 ]);
+const SOURCE_IMPACT_KINDS = new Set(["code"]);
 function normalizeCheckpointEvidence(evidence) {
     if (typeof evidence === "boolean") {
         return evidence;
@@ -126,6 +127,13 @@ function advisoryText(event) {
         return "- New file detected. Add or update the necessary Kibi entities and traceability before completing this task.";
     }
     if (event.lifecycle === "edited") {
+        if (SOURCE_IMPACT_KINDS.has(event.pathKind)) {
+            const impactCheckCall = `kb_check({sourceFiles:${JSON.stringify([event.normalizedPath])}, includeImpactDiagnostics:true, includeWorkingTreeDiff:true})`;
+            return [
+                `- Edited source file detected. Run \`${impactCheckCall}\` while the edit context is fresh.`,
+                "  Use the impact diagnostics to review symbol granularity, requirement ownership, and semantic review of linked requirements/tests before completing this task.",
+            ].join("\n");
+        }
         return `- Edited file detected. Review Kibi traceability for ${event.normalizedPath} before completing this task.`;
     }
     const ids = event.linkedEntityResult.ids;

package/dist/plugin.js

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { createAutoUpdateRunner, getLatestPluginVersion, invalidateKibiOpencodePackage, runBunInstallForOpenCodePlugin, } from "./auto-update.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";
@@ -20,6 +21,7 @@ import { createSyncScheduler } from "./scheduler.js";
 import { createSessionEditState, } from "./session-edit-state.js";
 import { getSessionTracker } from "./session-tracker.js";
 import { notifyStartup, } from "./startup-notifier.js";
+import { sendToast, } from "./toast.js";
 import { readKibiPackageVersions } from "./version-metadata.js";
 import { resolveWorkContext, } from "./work-context-resolver.js";
 import * as fs from "node:fs";
@@ -1044,7 +1046,7 @@ const kibiOpencodePlugin = async (input) => {
         }
     }
     logger.info("kibi-opencode: setup complete");
-    if (input.client && !maintenanceDegraded) {
+    if (input.client) {
         const client = input.client;
         const scheduleStartupNotify = startupNotifyGlobals.__kibi_test_schedule_startup_notify ??
             ((callback, delayMs) => {
@@ -1057,11 +1059,40 @@ const kibiOpencodePlugin = async (input) => {
                 if (meta[key] !== "unknown")
                     versions[key] = meta[key];
             }
-            notifyStartup(makeStartupClient(client), {
-                suppressToast: cfg.ux.toastStartup === false,
+            if (!maintenanceDegraded) {
+                notifyStartup(makeStartupClient(client), {
+                    suppressToast: cfg.ux.toastStartup === false,
+                    directory: input.directory,
+                    ...(Object.keys(versions).length > 0 ? { versions } : {}),
+                    versionMetadataSource: meta.source,
+                });
+            }
+            const autoUpdateRunner = createAutoUpdateRunner({
+                getCurrentVersion: () => meta.opencode === "unknown" ? null : meta.opencode,
+                getLatestVersion: getLatestPluginVersion,
+                invalidatePackage: invalidateKibiOpencodePackage,
+                runInstall: runBunInstallForOpenCodePlugin,
+                notify: async (message) => {
+                    if (cfg.ux.toastStartup !== false) {
+                        await sendToast(makeToastClient(client), {
+                            variant: "info",
+                            title: "Kibi OpenCode",
+                            message,
+                            duration: 8000,
+                        });
+                    }
+                    logger.info("auto-update.notification", { message });
+                },
+                log: (message, metadata) => logger.info(message, metadata),
+            });
+            const runAutoUpdate = startupNotifyGlobals.__kibi_test_auto_update_runner ?? autoUpdateRunner;
+            void runAutoUpdate({
                 directory: input.directory,
-                ...(Object.keys(versions).length > 0 ? { versions } : {}),
-                versionMetadataSource: meta.source,
+                enabled: cfg.autoUpdate,
+            }).catch((err) => {
+                logger.info("auto-update: background update check failed", {
+                    error: err instanceof Error ? err.message : String(err),
+                });
             });
         }, 2000);
     }

package/dist/scheduler.d.ts

@@ -24,7 +24,9 @@ export type SyncRunnerResult = {
 };
 export type SyncRunner = (worktree: string) => Promise<SyncRunnerResult>;
 export type CheckRunner = (worktree: string, rules: string[]) => Promise<{
-    exitCode: number;
+    readonly exitCode: number;
+    readonly stdout?: string;
+    readonly stderr?: string;
 }>;
 export interface SchedulerOptions {
     worktree: string;

package/dist/scheduler.js

@@ -154,6 +154,7 @@ class WorktreeSyncScheduler {
                 }
                 else {
                     logger.info(`check.succeeded ${JSON.stringify({ rules: checkRules })}`);
+                    logAdvisoryQualityDiagnostics(checkRules, checkResult.stdout, checkResult.stderr);
                 }
             }
         }
@@ -280,11 +281,84 @@ async function runKibiSync(worktree) {
 async function runKibiCheck(worktree, rules) {
     return new Promise((resolve) => {
         const rulesArg = rules.join(",");
-        exec(`kibi check --rules ${rulesArg}`, { cwd: worktree }, (error) => {
-            resolve({ exitCode: error ? (error.code ?? 1) : 0 });
+        exec(`kibi check --rules ${rulesArg} --format json`, { cwd: worktree }, (error, stdout, stderr) => {
+            const truncatedOut = truncateSyncOutput(stdout || undefined);
+            const truncatedErr = truncateSyncOutput(stderr || undefined);
+            resolve({
+                exitCode: error ? (error.code ?? 1) : 0,
+                ...(truncatedOut !== undefined ? { stdout: truncatedOut } : {}),
+                ...(truncatedErr !== undefined ? { stderr: truncatedErr } : {}),
+            });
         });
     });
 }
+function logAdvisoryQualityDiagnostics(rules, stdout, stderr) {
+    const diagnostics = parseQualityDiagnostics(stdout, stderr).filter((diagnostic) => !diagnostic.blocking);
+    if (diagnostics.length === 0)
+        return;
+    const severityCounts = new Map();
+    for (const diagnostic of diagnostics) {
+        severityCounts.set(diagnostic.severity, (severityCounts.get(diagnostic.severity) ?? 0) + 1);
+    }
+    const first = diagnostics[0];
+    if (first === undefined)
+        return;
+    logger.warn(`check.advisory_quality ${JSON.stringify({
+        rules,
+        count: diagnostics.length,
+        ...Object.fromEntries(severityCounts),
+        firstId: first.id,
+        firstMessage: first.message,
+    })}`);
+}
+function parseQualityDiagnostics(stdout, stderr) {
+    for (const output of [stdout, stderr]) {
+        if (output === undefined || output.trim().length === 0)
+            continue;
+        try {
+            const parsed = JSON.parse(output);
+            const candidates = qualityDiagnosticCandidates(parsed);
+            const diagnostics = candidates.flatMap((candidate) => parseQualityDiagnostic(candidate) ?? []);
+            if (diagnostics.length > 0)
+                return diagnostics;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError)
+                continue;
+            throw error;
+        }
+    }
+    return [];
+}
+function qualityDiagnosticCandidates(value) {
+    if (!isRecord(value))
+        return [];
+    const structuredContent = value.structuredContent;
+    if (isRecord(structuredContent)) {
+        const diagnostics = structuredContent.qualityDiagnostics;
+        return Array.isArray(diagnostics) ? diagnostics : [];
+    }
+    const diagnostics = value.qualityDiagnostics;
+    return Array.isArray(diagnostics) ? diagnostics : [];
+}
+function parseQualityDiagnostic(value) {
+    if (!isRecord(value))
+        return null;
+    const id = value.id;
+    const severity = value.severity;
+    const blocking = value.blocking;
+    const message = value.message;
+    if (typeof id !== "string" ||
+        typeof severity !== "string" ||
+        typeof blocking !== "boolean" ||
+        typeof message !== "string") {
+        return null;
+    }
+    return { id, severity, blocking, message };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 // implements REQ-opencode-kibi-plugin-v1
 export function createSyncScheduler(opts) {
     return new WorktreeSyncScheduler(opts);

package/dist/version-metadata.json

@@ -1 +1 @@
-{"opencode":"0.15.4","mcp":"0.15.3","cli":"0.12.3","core":"0.6.0"}
+{"opencode":"0.18.0","mcp":"0.19.0","cli":"0.14.0","core":"0.7.0"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-opencode",
-  "version": "0.15.4",
+  "version": "0.18.0",
   "description": "Kibi OpenCode plugin - thin adapter to integrate Kibi with OpenCode sessions",
   "type": "module",
   "main": "dist/index.js",
@@ -60,7 +60,7 @@
     "@opencode-ai/plugin": "^1.4.7",
     "@opentui/core": "^0.1.99",
     "@opentui/solid": "^0.1.99",
-    "kibi-cli": "^0.12.3"
+    "kibi-cli": "^0.14.0"
   },
   "devDependencies": {
     "@types/node": "latest",