kibi-opencode 0.19.3 → 1.0.0

package/dist/prompt.js

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import { isPluginEnabled } from "./config.js";
-import { getInitKibiCommandCapability, } from "./init-kibi-capability.js";
+import { getKibiBootstrapCommandCapability, } from "./kibi-bootstrap-capability.js";
 import { getSourceLinkedRequirementIds } from "./source-linked-guidance.js";
 const SENTINEL = "<!-- kibi-opencode -->";
 // ── Token budget enforcement ───────────────────────────────────────────
@@ -56,17 +56,17 @@ function deriveFileBucket(pathKind) {
 function getFocusEdit(context) {
     return (context.focusEdit ?? context.recentEdits[context.recentEdits.length - 1]);
 }
-function buildInitKibiBootstrapReference(capability = getInitKibiCommandCapability()) {
+function buildKibiBootstrapReference(capability = getKibiBootstrapCommandCapability()) {
     if (capability.supported) {
-        return "Bootstrap existing repos: when the Kibi OpenCode plugin is active and native injection is supported, `/init-kibi` is the canonical short alias; `/kibi:init-kibi:mcp` remains the namespaced MCP fallback for the retroactive initialization (`kb_autopilot_generate`) workflow.";
+        return "Bootstrap existing repositories with `/kibi-bootstrap`; the canonical `kibi-bootstrap` skill owns planner, approval, apply, and repair semantics.";
     }
-    return "Bootstrap existing repos: this host does not support native `/init-kibi` injection, so Kibi must fail closed and does not register a fake native alias; use `/kibi:init-kibi:mcp` for the retroactive initialization (`kb_autopilot_generate`) workflow.";
+    return "This host cannot inject native `/kibi-bootstrap`; use `/kibi:kibi-bootstrap:mcp` to route to the canonical `kibi-bootstrap` skill.";
 }
-function buildBootstrapRequiredBody(capability = getInitKibiCommandCapability()) {
-    const commandBullet = capability.supported
-        ? "- When the Kibi OpenCode plugin is active and native injection is supported, use `/init-kibi` as the canonical short alias; `/kibi:init-kibi:mcp` remains the namespaced MCP fallback."
-        : "- This host does not support native `/init-kibi` injection. Kibi must fail closed and does not register a fake native alias; use `/kibi:init-kibi:mcp` instead.";
-    return `Kibi capability selection (MCP tools and the trusted project-local CLI are peer surfaces over the same 18 operations):\n1. If Kibi MCP tools are visible and approved, use MCP.\n2. Otherwise, in a trusted workspace, use the project-local CLI's dedicated JSON routes with \`--input <file|->\`.\n3. If neither interface is available, Kibi operation is blocked; tell the operator.\nDo not infer MCP availability from config file existence. Do not read or edit \`.kb/\` files directly. Query before mutate. Run \`kb_upsert\` sequentially. Run \`kb_check\` before completion.\n\nThis repository does not appear to have Kibi initialized. Agents should:\n${commandBullet}\n- The workflow uses \`kb_autopilot_generate\` for read-only synthesis; always preview and get approval before writes.\n- Ask the operator to handle setup or repair if bootstrap is insufficient.\n- Load \`kibi-usage\` with \`kb_skills_load\` for comprehensive guidance.`;
+function buildBootstrapRequiredBody(capability = getKibiBootstrapCommandCapability()) {
+    const command = capability.supported
+        ? "Use `/kibi-bootstrap`."
+        : "Use `/kibi:kibi-bootstrap:mcp`; this host does not support native command injection.";
+    return `Kibi infrastructure is not initialized. Run \`kibi init\`, then inspect \`kb_status.bootstrap.nextAction\` and route the explicit bootstrap request to the canonical \`kibi-bootstrap\` skill. ${command}`;
 }
 function buildHardGateBlock(block) {
     const pathLines = block.shownPaths.map((path) => `- \`${path}\``);
@@ -80,18 +80,7 @@ function buildHardGateBlock(block) {
         reasonLine,
         "Affected files:",
         ...pathLines,
-        "Capability-based recovery steps:",
-        "- MCP tools and the trusted project-local CLI are peer surfaces over the same 18 operations; choose by what is visible and approved here.",
-        "- If Kibi MCP tools are visible and approved, use MCP.",
-        "- Otherwise, in a trusted workspace, use the project-local CLI's dedicated JSON routes with `--input <file|->`.",
-        "- If neither interface is available, Kibi operation is blocked; tell the operator to enable MCP or the trusted project-local CLI.",
-        "- Do not infer MCP availability from config file existence. Do not read or edit `.kb/` files directly.",
-        "- Query before mutate. Run `kb_upsert` sequentially. Run `kb_check` before completion.",
-        "- Run `kb_search` for impacted requirements, tests, ADRs, and facts.",
-        "- Run `kb_query` with `sourceFile` for each affected file.",
-        "- Run `kb_status` if branch or snapshot freshness matters.",
-        "- Run `kb_upsert` for required traceability, relationship, or fact updates.",
-        "- Run `kb_check` before continuing.",
+        "Inspect typed Kibi status `nextActions`, then route to the canonical kibi-usage, kibi-freshness, or kibi-traceability skill. Use the host-visible approved peer surface and never read or edit `.kb` directly.",
     ]
         .filter((line) => line !== null)
         .join("\n");
@@ -123,17 +112,13 @@ Production code: use \`implements\` (symbol→req) for requirement ownership. Te
 - \`covered_by\` is coverage evidence only
 - Prefer scenario-first: req→scenario→test when scenarios exist
 - Route durable knowledge comments to KB entities, not inline comments
-- documentation/symbols.yaml refresh is required when extraction output changes; do not revert as scope creep`,
+- .kb/symbols.yaml refresh is required when extraction output changes; do not revert as scope creep`,
     manual_kb_edit: `⚠️  **WARNING: Direct .kb/ edits bypass validation**
 
-The Kibi knowledge base is managed through visible MCP tools or the trusted project-local CLI — peer surfaces over the same 18 operations. Do not read or edit \`.kb/\` files directly.
-- Query before mutate and run kb_upsert sequentially
-- Use kb_upsert to create/update entities
-- Use kb_delete to remove entities
-- Use kb_check to validate consistency`,
+Do not read or edit \`.kb/\` directly. Follow typed Kibi status \`nextActions\` and route durable changes through the canonical kibi-usage, kibi-freshness, or kibi-traceability skill.`,
 };
 // ── Posture overrides ──────────────────────────────────────────────────
-export function postureGuidance(posture, capability = getInitKibiCommandCapability()) {
+export function postureGuidance(posture, capability = getKibiBootstrapCommandCapability()) {
     // implements REQ-opencode-prompt-injection
     switch (posture) {
         case "vendored_only":
@@ -146,7 +131,7 @@ ${buildBootstrapRequiredBody(capability)}`;
         case "root_partial":
             return `⚠️  **Partial KB setup detected**
 
-Root .kb/config.json exists but some configured KB targets are missing. Guidance remains advisory until the user/operator restores the configured KB targets.`;
+Root .kb/manifest.json exists but some canonical KB targets under .kb/ are missing. Guidance remains advisory until the user/operator restores the canonical layout.`;
         default:
             return null;
     }
@@ -155,7 +140,7 @@ Root .kb/config.json exists but some configured KB targets are missing. Guidance
 /**
  * Build prompt guidance block based on posture, risk class, and cache state.
  */
-function buildContextualGuidance(context, capability = getInitKibiCommandCapability()) {
+function buildContextualGuidance(context, capability = getKibiBootstrapCommandCapability()) {
     if (context.hardGateBlock) {
         return `${SENTINEL}\n\n${buildHardGateBlock(context.hardGateBlock)}`;
     }
@@ -437,7 +422,7 @@ function buildCommentSuggestionGuidance(suggestion) {
 Your recent code edit contains a comment that looks like a **strict domain fact** (invariants, properties, limits, defaults, or cardinality constraints).
 
 **Action**: Route to a FACT entity in the strict fact lane:
-- Create \`documentation/facts/FACT-xxx.md\` with the invariant (use \`constrains\` + \`requires_property\` for contradiction-safe reasoning)
+- Create \`.kb/facts/FACT-xxx.md\` with the invariant (use \`constrains\` + \`requires_property\` for contradiction-safe reasoning)
 - Bug/workaround notes: use \`fact_kind: observation\` or \`meta\` instead — these are non-blocking and excluded from contradiction inference
 - Link it to relevant requirements
 
@@ -448,7 +433,7 @@ This keeps domain truths centralized, searchable, and contradiction-safe.`;
 Your recent code edit contains a comment that looks like a **technical decision** (tradeoffs, rationale, or architecture choices).
 
 **Action**: Instead of inline comments, route this to an ADR entity:
-- Create \`documentation/adr/ADR-xxx.md\` documenting the decision
+- Create \`.kb/adr/ADR-xxx.md\` documenting the decision
 - Include context, options considered, and the chosen approach
 - Link to constrained code symbols
 
@@ -459,7 +444,7 @@ This preserves decision context for future maintainers.`;
 Your recent code edit contains a comment that looks like **behavior intent** (system capabilities or user-facing requirements).
 
 **Action**: Instead of inline comments, route this to a REQ entity:
-- Create \`documentation/requirements/REQ-xxx.md\` with the behavior description
+- Create \`.kb/requirements/REQ-xxx.md\` with the behavior description
 - Add SCEN and TEST entities for specification and verification
 - Link code: production uses \`implements\` (symbol→req) for ownership; test code uses \`executable_for\`; \`covered_by\` is coverage evidence only
 
@@ -478,41 +463,20 @@ Before implementing or explaining code:
 /**
  * Build the static guidance block (original behavior).
  */
-function buildBaseGuidance(capability = getInitKibiCommandCapability()) {
+function buildBaseGuidance(capability = getKibiBootstrapCommandCapability()) {
     return `${SENTINEL}
-This project uses Kibi through capability-selected MCP or CLI JSON routes. Prefer storing durable knowledge in Kibi over code comments.
+Use typed Kibi status and its \`nextActions\` as the workflow contract. Route general work to \`kibi-usage\`, freshness decisions to \`kibi-freshness\`, source proof to \`kibi-traceability\`, and an explicit bootstrap request to \`kibi-bootstrap\`. Use the host-visible approved Kibi peer surface; if it is unavailable, report the blocked capability. Never read or edit \`.kb/\` directly.
 
-Before changing behavior: use kb_search for discovery, then kb_query by sourceFile, id, type, or tags for exact follow-up; do not rely on undocumented tools.
-
-Keep changed symbols traceable: production code uses \`implements\` (symbol→req) for ownership; test code uses \`executable_for\`; \`covered_by\` is coverage evidence only. Inline \`// implements REQ-xxx\` comments remain backward-compatible.
-
-Kibi capability selection (MCP tools and the trusted project-local CLI are peer surfaces over the same 18 operations):
-1. If Kibi MCP tools are visible and approved, use MCP.
-2. Otherwise, in a trusted workspace, use the project-local CLI's dedicated JSON routes with \`--input <file|->\`.
-3. If neither interface is available, Kibi operation is blocked; tell the operator to enable MCP or the trusted project-local CLI.
-Do not infer MCP availability from config file existence. Do not read or edit \`.kb/\` files directly. Query before mutate. Run \`kb_upsert\` sequentially. Run \`kb_check\` before completion.
+Keep changed symbols traceable: production code uses \`implements\` (symbol→req) for ownership; test code uses \`executable_for\`; \`covered_by\` is coverage evidence only.
 
 Dogfood note for this repo: OpenCode here uses local built \`kibi-mcp\` and \`kibi-opencode\` artifacts. If you change package versions or local package wiring, run \`bun run build\` before relying on OpenCode in this workspace.
 
-**Kibi-first workflow:**
-1. **Discover**: Run kb_search for REQ, ADR, TEST, FACT. Decompose broad queries (e.g., "Apple Sign-In").
-2. **Confirm**: Run kb_query with sourceFile, id, type, or tags once you know the exact follow-up target.
-3. **Inspect freshness**: Run kb_status when branch or stale-state confidence matters.
-4. **Document intent**: If you are about to explain code, STOP. Route that explanation to kb_upsert instead of inline comments.
-5. **Link during work**: When creating KB entities, include relationship rows: specified_by (req→scenario), implements (symbol→req for ownership), covered_by (symbol→test for coverage), executable_for (test code→test).
-6. **Validate**: Run kb_check after KB mutations to catch violations early.
-7. **Before completion/commit**: Kibi impact evidence is required before completion/commit. If extraction output changes, refresh documentation/symbols.yaml and do not revert that update as scope creep.
-
-MCP and CLI expose the same 18 Kibi operations. Use the exact MCP tool or dedicated CLI route; do not invent a generic runner.
-
-For comprehensive Kibi usage guidance (relationships, fact lanes, workflows), use \`kb_skills_load\` with skill id \`kibi-usage\`.
-
-${buildInitKibiBootstrapReference(capability)}`;
+${buildKibiBootstrapReference(capability)}`;
 }
 /**
  * Build prompt with contextual guidance based on posture, risk class, and cache state.
  */
-export function buildPrompt(context, capability = getInitKibiCommandCapability()) {
+export function buildPrompt(context, capability = getKibiBootstrapCommandCapability()) {
     if (!context) {
         return buildBaseGuidance(capability).trim();
     }
@@ -521,7 +485,7 @@ export function buildPrompt(context, capability = getInitKibiCommandCapability()
 /**
  * Inject prompt guidance if not already present.
  */
-export function injectPrompt(current, config, context, capability = getInitKibiCommandCapability()) {
+export function injectPrompt(current, config, context, capability = getKibiBootstrapCommandCapability()) {
     if (!config.prompt.enabled || !isPluginEnabled(config)) {
         return current;
     }

package/dist/repo-posture.js

@@ -1,16 +1,16 @@
 // implements REQ-opencode-smart-enforcement-v1, REQ-opencode-kibi-plugin-v1
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
-// Default sync paths — must stay in sync with file-filter.ts DEFAULT_SYNC_PATHS
-const DEFAULT_SYNC_PATHS = {
-    requirements: "documentation/requirements/**/*.md",
-    scenarios: "documentation/scenarios/**/*.md",
-    tests: "documentation/tests/**/*.md",
-    adr: "documentation/adr/**/*.md",
-    flags: "documentation/flags/**/*.md",
-    events: "documentation/events/**/*.md",
-    facts: "documentation/facts/**/*.md",
-    symbols: "documentation/symbols.yaml",
+// Canonical Kibi knowledge targets — must stay in sync with kb-paths.ts.
+const CANONICAL_KB_TARGETS = {
+    requirements: ".kb/requirements",
+    scenarios: ".kb/scenarios",
+    tests: ".kb/tests",
+    adr: ".kb/adr",
+    flags: ".kb/flags",
+    events: ".kb/events",
+    facts: ".kb/facts",
+    symbols: ".kb/symbols.yaml",
 };
 // ── helpers ────────────────────────────────────────────────────────────
 function findVendoredTrees(cwd) {
@@ -19,7 +19,7 @@ function findVendoredTrees(cwd) {
         ["kibi", "opencode.json"],
         ["kibi", "package.json"],
         ["kibi", "packages", "mcp"],
-        ["kibi", "documentation"],
+        ["kibi", ".kb"],
     ];
     for (const marker of vendoredMarkers) {
         const markerPath = join(cwd, ...marker);
@@ -37,63 +37,22 @@ function findVendoredTrees(cwd) {
     }
     return [...new Set(results)];
 }
-/** Check if .kb/config.json exists at root. */
-function rootKbConfigExists(cwd) {
-    return existsSync(join(cwd, ".kb", "config.json"));
+/** Check if `.kb/manifest.json` exists at root. */
+function rootKbManifestExists(cwd) {
+    return existsSync(join(cwd, ".kb", "manifest.json"));
 }
-/** Read and parse .kb/config.json. Returns null on failure. */
-function readRootConfig(cwd) {
-    try {
-        return (JSON.parse(readFileSync(join(cwd, ".kb", "config.json"), "utf8")) || null);
-    }
-    catch {
-        return null;
-    }
-}
-/** Check if all configured KB targets resolve (directories / files exist). */
+/** Check if all canonical KB targets resolve (directories / files exist). */
 function rootTargetsAllResolve(cwd) {
-    const configPath = join(cwd, ".kb", "config.json");
-    let config = {};
-    try {
-        config = JSON.parse(readFileSync(configPath, "utf8")) || {};
-    }
-    catch {
-        return false;
-    }
-    const paths = config.paths;
-    const defaultKeys = [
-        "requirements",
-        "scenarios",
-        "tests",
-        "adr",
-        "flags",
-        "events",
-        "facts",
-        "symbols",
-    ];
-    for (const key of defaultKeys) {
-        const raw = paths?.[key] ?? DEFAULT_SYNC_PATHS[key];
+    for (const raw of Object.values(CANONICAL_KB_TARGETS)) {
         if (!raw)
             return false;
-        // Normalize: strip trailing slashes and glob patterns to get the root dir/file path
-        const normalized = raw.replace(/\/+$/, "");
-        const isFile = normalized.endsWith(".yaml") || normalized.endsWith(".yml");
+        const isFile = raw.endsWith(".yaml") || raw.endsWith(".yml");
         if (isFile) {
-            if (!existsSync(resolve(cwd, normalized)))
+            if (!existsSync(resolve(cwd, raw)))
                 return false;
         }
-        else {
-            // Strip first glob segment
-            const segments = normalized.split("/");
-            const rootSegments = [];
-            for (const seg of segments) {
-                if (seg.includes("*") || seg.includes("?") || seg.includes("["))
-                    break;
-                rootSegments.push(seg);
-            }
-            const dirPath = rootSegments.join("/") || ".";
-            if (!existsSync(resolve(cwd, dirPath)))
-                return false;
+        else if (!existsSync(resolve(cwd, raw))) {
+            return false;
         }
     }
     return true;
@@ -134,54 +93,42 @@ function hasRootKibiIntent(cwd) {
 }
 // ── main classifier ────────────────────────────────────────────────────
 export function detectPosture(cwd) {
-    const hasRootConfig = rootKbConfigExists(cwd);
+    const hasRootManifest = rootKbManifestExists(cwd);
     const vendoredTrees = findVendoredTrees(cwd);
-    // 1. hybrid_root_plus_vendored — root config AND vendored subtrees
-    if (hasRootConfig && vendoredTrees.length > 0) {
+    // 1. hybrid_root_plus_vendored — root manifest AND vendored subtrees
+    if (hasRootManifest && vendoredTrees.length > 0) {
         return {
             state: "hybrid_root_plus_vendored",
             needsBootstrap: false,
-            reason: `Root .kb/config.json exists alongside vendored tree(s): ${vendoredTrees.join(", ")}`,
+            reason: `Root .kb/manifest.json exists alongside vendored tree(s): ${vendoredTrees.join(", ")}`,
             maintenanceDegraded: false,
         };
     }
-    // 2-3. root config exists (check maintenance mode and target resolution)
-    if (hasRootConfig) {
-        const config = readRootConfig(cwd);
-        const maint = config?.maintenance;
-        const maintenanceDisabled = maint !== undefined && maint.enabled === false;
-        // maintenance_degraded overlay: maintenance explicitly disabled → root_active
-        if (maintenanceDisabled) {
-            return {
-                state: "root_active",
-                needsBootstrap: false,
-                reason: "Root .kb/config.json exists; maintenance mode explicitly disabled",
-                maintenanceDegraded: true,
-            };
-        }
+    // 2-3. root manifest exists (check target resolution)
+    if (hasRootManifest) {
         const allResolve = rootTargetsAllResolve(cwd);
         if (allResolve) {
             return {
                 state: "root_active",
                 needsBootstrap: false,
-                reason: "Root .kb/config.json exists and all configured KB targets resolve",
+                reason: "Root .kb/manifest.json exists and all canonical KB targets resolve",
                 maintenanceDegraded: false,
             };
         }
-        // 3. root_partial — root config exists but targets are missing
+        // 3. root_partial — manifest exists but targets are missing
         return {
             state: "root_partial",
             needsBootstrap: true,
-            reason: "Root .kb/config.json exists but some configured KB targets are missing",
+            reason: "Root .kb/manifest.json exists but some canonical KB targets are missing",
             maintenanceDegraded: false,
         };
     }
-    // 4. vendored_only — no root config, but vendored markers found
+    // 4. vendored_only — no root manifest, but vendored markers found
     if (vendoredTrees.length > 0) {
         return {
             state: "vendored_only",
             needsBootstrap: false,
-            reason: `No root .kb/config.json, but vendored Kibi tree(s) detected: ${vendoredTrees.join(", ")}`,
+            reason: `No root .kb/manifest.json, but vendored Kibi tree(s) detected: ${vendoredTrees.join(", ")}`,
             maintenanceDegraded: false,
         };
     }

package/dist/risk-classifier.d.ts

@@ -27,10 +27,10 @@ export interface RiskClassification {
  * Classify a file edit into a deterministic risk class.
  *
  * Classification order (first match wins):
- * 1. manual_kb_edit        — file is under .kb/
+ * 1. manual_kb_edit        — opaque/derived `.kb/` files (pathKind "kb")
  * 2. safe_test_only        — pathKind is "test"
- * 3. req_policy_candidate  — pathKind is "requirement"
- * 4. kb_doc_structural     — pathKind is "scenario", "adr", or "fact"
+ * 3. req_policy_candidate  — pathKind is "requirement" (including `.kb/requirements`)
+ * 4. kb_doc_structural     — pathKind is "scenario", "adr", "fact", "flag", "event", or "symbol"
  * 5. safe_docs_only        — pathKind is "unknown" (markdown/config/etc.)
  * 6. traceability_candidate — code with exports AND (hasDurableComment OR missing traceability)
  * 7. behavior_candidate    — code with exports, already has traceability, no durable comment

package/dist/risk-classifier.js

@@ -11,10 +11,10 @@ const TRACEABILITY_PATTERN = /implements\s+REQ-[A-Za-z0-9_-]+/i;
  * Classify a file edit into a deterministic risk class.
  *
  * Classification order (first match wins):
- * 1. manual_kb_edit        — file is under .kb/
+ * 1. manual_kb_edit        — opaque/derived `.kb/` files (pathKind "kb")
  * 2. safe_test_only        — pathKind is "test"
- * 3. req_policy_candidate  — pathKind is "requirement"
- * 4. kb_doc_structural     — pathKind is "scenario", "adr", or "fact"
+ * 3. req_policy_candidate  — pathKind is "requirement" (including `.kb/requirements`)
+ * 4. kb_doc_structural     — pathKind is "scenario", "adr", "fact", "flag", "event", or "symbol"
  * 5. safe_docs_only        — pathKind is "unknown" (markdown/config/etc.)
  * 6. traceability_candidate — code with exports AND (hasDurableComment OR missing traceability)
  * 7. behavior_candidate    — code with exports, already has traceability, no durable comment
@@ -22,11 +22,14 @@ const TRACEABILITY_PATTERN = /implements\s+REQ-[A-Za-z0-9_-]+/i;
  */
 export function classifyRisk(params) {
     const { pathKind, isUnderKb, hasMustPriority, hasDurableComment, fileContent, } = params;
-    // 1. manual_kb_edit — direct KB manipulation is always risky
-    if (isUnderKb) {
+    // 1. manual_kb_edit — derived/runtime `.kb/` files, not canonical lanes.
+    // Entity lanes under `.kb/` keep their typed pathKind (requirement, symbol, …).
+    if (isUnderKb && pathKind === "kb") {
         return {
             riskClass: "manual_kb_edit",
-            reasons: ["File is under .kb/ — manual edits bypass KB validation"],
+            reasons: [
+                "File is opaque or derived `.kb/` runtime state — manual edits bypass KB validation",
+            ],
         };
     }
     // 2. safe_test_only — test files are low-risk

package/dist/scheduler.js

@@ -256,7 +256,7 @@ async function runKibiSync(worktree) {
                         ? `${error.message}${signal}`
                         : signal || undefined;
                     resolve({
-                        exitCode: error.code ?? 1,
+                        exitCode: typeof error.code === "number" ? error.code : 1,
                         syncCommand: "kibi sync",
                         ...(truncatedOut !== undefined ? { syncStdout: truncatedOut } : {}),
                         ...(truncatedErr !== undefined ? { syncStderr: truncatedErr } : {}),
@@ -285,7 +285,7 @@ async function runKibiCheck(worktree, rules) {
             const truncatedOut = truncateSyncOutput(stdout || undefined);
             const truncatedErr = truncateSyncOutput(stderr || undefined);
             resolve({
-                exitCode: error ? (error.code ?? 1) : 0,
+                exitCode: error && typeof error.code === "number" ? error.code : 0,
                 ...(truncatedOut !== undefined ? { stdout: truncatedOut } : {}),
                 ...(truncatedErr !== undefined ? { stderr: truncatedErr } : {}),
             });

package/dist/version-metadata.json

@@ -1 +1 @@
-{"opencode":"0.19.3","mcp":"0.21.1","cli":"0.18.1","core":"0.9.1"}
+{"opencode":"1.0.0","mcp":"1.0.0","cli":"1.0.1","core":"0.11.0"}

package/dist/work-context-resolver.js

@@ -82,7 +82,7 @@ function findGitMetadata(candidatePath, searchBoundary) {
     }
 }
 function hasRootKbConfig(root) {
-    return existsSync(join(root, ".kb", "config.json"));
+    return existsSync(join(root, ".kb", "manifest.json"));
 }
 function uniqueResolved(paths) {
     const seen = new Set();
@@ -157,7 +157,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.3",
+  "version": "1.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.18.0"
+    "kibi-runtime": "^1.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;

package/dist/init-kibi-alias.js

@@ -1,43 +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 function buildInitKibiAlias() {
-    const lines = [
-        "# /init-kibi: Interactive Activation",
-        "",
-        "Use this workflow to onboard a new or empty repository into Kibi through interactive discovery.",
-        "",
-        "## 1. Gather Declared Context",
-        "Ask at most 4 bounded questions to gather intent: Project Summary, Source of Truth, Priority Root, and Verification Anchors.",
-        "",
-        "## 2. Synthesize Candidates",
-        "Call `kb_autopilot_generate` with the gathered context to synthesize candidate entities. This tool is **read-only**.",
-        "In OpenCode, Kibi MCP tools are host-prefixed: canonical `kb_autopilot_generate`, `kb_upsert`, and `kb_check` may appear as `kibi_kb_autopilot_generate`, `kibi_kb_upsert`, and `kibi_kb_check`.",
-        "OpenCode prefixes Kibi MCP tools with `kibi_`; use the visible prefixed name when the host requires exact tool identifiers.",
-        "",
-        "## 3. Preview and Approval",
-        "Present the `promptBlock`, a summary of synthesized `candidates`, and the exact `applyPlan` payloads to the user. **Wait for explicit approval** before proceeding to writes.",
-        "",
-        "## 4. Apply Approved Candidates",
-        "Apply approved candidates sequentially using `kb_upsert` (following ascending phase order). Confirm success of each write before moving to the next. Run `kb_check` after the batch to verify KB integrity.",
-        "",
-        "## Rules",
-        "- Never apply changes without a user-facing preview and approval.",
-        "- MCP tools and the trusted project-local CLI are peer surfaces; choose by what is visible and approved here.",
-        "- If Kibi MCP tools are visible and approved, use MCP.",
-        "- Otherwise, in a trusted workspace, use the project-local CLI's dedicated JSON routes with `--input <file|->`. If neither interface is available, stop and tell the operator.",
-        "- Do not infer MCP availability from config file existence. Do not read or edit `.kb/` files directly.",
-        "- Query before mutate. Run `kb_upsert` sequentially. Run `kb_check` before completion.",
-    ];
-    return lines.join("\n");
-}