kibi-opencode 0.16.0 → 0.18.0

package/README.md

@@ -56,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
@@ -75,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

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/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.16.0","mcp":"0.16.0","cli":"0.12.4","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.16.0",
+  "version": "0.18.0",
   "description": "Kibi OpenCode plugin - thin adapter to integrate Kibi with OpenCode sessions",
   "type": "module",
   "main": "dist/index.js",
@@ -37,9 +37,7 @@
       "default": "./dist/tui.js"
     }
   },
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "engines": {
     "node": ">=18"
   },
@@ -62,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",