kibi-cli 0.19.0 → 1.0.1

package/dist/verification/playwright-reporter.js

@@ -0,0 +1,114 @@
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { normalizePlaywrightSourceFile, playwrightCaseId, } from "../public/playwright-case-id.js";
+// implements REQ-kibi-verification-evidence-contract
+export const PLAYWRIGHT_RUN_VERSION = "kibi.playwright-run.v1";
+function envHash() {
+    const lockfile = process.env.KIBI_LOCKFILE_DIGEST ?? "unknown";
+    return createHash("sha256")
+        .update(JSON.stringify({
+        platform: process.platform,
+        arch: process.arch,
+        node: process.version,
+        lockfile,
+        projects: process.env.KIBI_VERIFICATION_PROJECTS ?? "",
+    }))
+        .digest("hex");
+}
+function outputPath(options) {
+    const configured = options.outputPath ?? process.env.KIBI_VERIFICATION_OUTPUT;
+    if (!configured)
+        throw new Error("KIBI_VERIFICATION_OUTPUT is required");
+    return path.resolve(configured);
+}
+function titlePath(test) {
+    const candidate = test;
+    const value = candidate.titlePath?.();
+    return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
+}
+function sourceLocation(test) {
+    const location = test
+        .location;
+    return {
+        file: typeof location?.file === "string" ? location.file : "unknown",
+        line: Number.isInteger(location?.line) ? Number(location?.line) : 1,
+    };
+}
+function projectName(test, result) {
+    const project = test.project?.();
+    if (typeof project?.name === "string" && project.name)
+        return project.name;
+    const resultProject = result.projectName;
+    return typeof resultProject === "string" && resultProject
+        ? resultProject
+        : "default";
+}
+/** Reporter callback surface intentionally uses structural types, no Playwright dependency. */
+export class KibiPlaywrightReporter {
+    options;
+    cases = [];
+    startedAt;
+    constructor(options = {}) {
+        this.options = options;
+        this.startedAt = (options.now ?? (() => new Date()))().toISOString();
+    }
+    // implements REQ-kibi-verification-evidence-contract
+    onBegin() {
+        this.startedAt = (this.options.now ?? (() => new Date()))().toISOString();
+    }
+    // implements REQ-kibi-verification-evidence-contract
+    onTestEnd(test, result) {
+        const resultValue = result;
+        const location = sourceLocation(test);
+        const titles = titlePath(test);
+        const title = titles.join(" > ");
+        const status = resultValue.status;
+        const outcome = status === "passed"
+            ? "passed"
+            : status === "timedOut"
+                ? "timed_out"
+                : status === "skipped"
+                    ? "skipped"
+                    : "failed";
+        const sourceFile = normalizePlaywrightSourceFile(location.file, this.options.workspaceRoot ?? process.cwd());
+        this.cases.push({
+            symbol_id: playwrightCaseId(sourceFile, title),
+            project: projectName(test, result),
+            outcome,
+            retries: Number.isInteger(resultValue.retry)
+                ? Number(resultValue.retry)
+                : 0,
+            duration_ms: Number.isInteger(resultValue.duration)
+                ? Number(resultValue.duration)
+                : 0,
+        });
+    }
+    // implements REQ-kibi-verification-evidence-contract
+    async onEnd(result) {
+        const now = this.options.now ?? (() => new Date());
+        const status = result?.status;
+        const artifact = {
+            version: PLAYWRIGHT_RUN_VERSION,
+            runner: "playwright",
+            command_argv: [
+                ...(this.options.commandArgv ??
+                    (process.env.KIBI_VERIFICATION_COMMAND_ARGV
+                        ? JSON.parse(process.env.KIBI_VERIFICATION_COMMAND_ARGV)
+                        : [])),
+            ],
+            code_snapshot: this.options.codeSnapshot ??
+                process.env.KIBI_VERIFICATION_SNAPSHOT ??
+                "",
+            environment_hash: this.options.environmentHash ?? envHash(),
+            started_at: this.startedAt,
+            finished_at: now().toISOString(),
+            process_exit_code: status === "passed" ? 0 : 1,
+            cases: this.cases,
+        };
+        const target = outputPath(this.options);
+        await mkdir(path.dirname(target), { recursive: true });
+        await writeFile(target, `${JSON.stringify(artifact, null, 2)}\n`, "utf8");
+    }
+}
+export default KibiPlaywrightReporter;

package/package.json

@@ -1,21 +1,30 @@
 {
   "name": "kibi-cli",
-  "version": "0.19.0",
+  "version": "1.0.1",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "main": "./dist/cli.js",
   "bin": {
     "kibi": "bin/kibi"
   },
-  "files": ["dist", "bin", "schema", "src/schemas", "src/public"],
+  "files": [
+    "dist",
+    "bin",
+    "schema",
+    "src/schemas",
+    "src/public",
+    "templates"
+  ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && mkdir -p dist/public/skills && cp -r src/public/skills/. dist/public/skills/",
+    "build": "tsc -p tsconfig.json && rm -rf dist/public/skills && mkdir -p dist/public/skills && cp -r src/public/skills/. dist/public/skills/ && node ../../scripts/generate-entity-schema.mjs --check",
     "test": "node ../../scripts/run-owned-engine-tests.mjs -- bun test --timeout 15000 .",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "prepack": "npm run build"
+    "schema:generate": "tsc -p tsconfig.json && node ../../scripts/generate-entity-schema.mjs",
+    "schema:check": "tsc -p tsconfig.json && node ../../scripts/generate-entity-schema.mjs --check",
+    "prepack": "npm run build && node ../../scripts/verify-package-contract.mjs kibi-cli"
   },
   "exports": {
     ".": {
@@ -38,6 +47,14 @@
       "types": "./dist/public/operations/runtime-types.d.ts",
       "default": "./dist/public/operations/runtime-types.js"
     },
+    "./operations/result-envelope": {
+      "types": "./dist/public/operations/result-envelope.d.ts",
+      "default": "./dist/public/operations/result-envelope.js"
+    },
+    "./runtime/cli-runtime": {
+      "types": "./dist/runtime/cli-runtime.d.ts",
+      "default": "./dist/runtime/cli-runtime.js"
+    },
     "./operations/node-ports": {
       "types": "./dist/public/operations/node-ports.d.ts",
       "default": "./dist/public/operations/node-ports.js"
@@ -62,6 +79,10 @@
       "types": "./dist/public/extractors/symbols-coordinator.d.ts",
       "default": "./dist/public/extractors/symbols-coordinator.js"
     },
+    "./extractors/symbol-coordinates": {
+      "types": "./dist/extractors/symbol-coordinates.d.ts",
+      "default": "./dist/extractors/symbol-coordinates.js"
+    },
     "./extractors/manifest": {
       "types": "./dist/public/extractors/manifest.d.ts",
       "default": "./dist/public/extractors/manifest.js"
@@ -94,6 +115,18 @@
       "types": "./dist/search-ranking.d.ts",
       "default": "./dist/search-ranking.js"
     },
+    "./intent-search": {
+      "types": "./dist/intent-search.d.ts",
+      "default": "./dist/intent-search.js"
+    },
+    "./playwright-reporter": {
+      "types": "./dist/verification/playwright-reporter.d.ts",
+      "default": "./dist/verification/playwright-reporter.js"
+    },
+    "./playwright-case-id": {
+      "types": "./dist/public/playwright-case-id.d.ts",
+      "default": "./dist/public/playwright-case-id.js"
+    },
     "./public/check-types": {
       "types": "./dist/public/check-types.d.ts",
       "default": "./dist/public/check-types.js"
@@ -151,6 +184,10 @@
       "types": "./dist/operations/mutation/symbol-refresh.d.ts",
       "default": "./dist/operations/mutation/symbol-refresh.js"
     },
+    "./operations/mutation/symbol-compiler-lock": {
+      "types": "./dist/operations/mutation/symbol-compiler-lock.d.ts",
+      "default": "./dist/operations/mutation/symbol-compiler-lock.js"
+    },
     "./operations/mutation/types": {
       "types": "./dist/operations/mutation/types.d.ts",
       "default": "./dist/operations/mutation/types.js"
@@ -193,12 +230,14 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.10.0",
+    "kibi-core": "^0.11.0",
     "ts-morph": "^23.0.0",
-    "ignore": "^5.3.0"
+    "ignore": "^5.3.0",
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@types/node": "latest",
+    "semver": "^7.7.4",
     "typescript": "^5.7.0"
   },
   "license": "AGPL-3.0-or-later",

package/schema/config.json

@@ -1,8 +1,8 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://raw.githubusercontent.com/Looted/kibi/master/packages/cli/schema/config.json",
-  "title": "Kibi Configuration",
-  "description": "Configuration schema for Kibi knowledge base",
+  "title": "Kibi Legacy Configuration (deprecated)",
+  "description": "Deprecated leftover .kb/config.json schema kept only so migration tooling can recognize old files. Entity paths and check policy in this document are ignored at runtime. Canonical lifecycle metadata lives in .kb/manifest.json.",
   "type": "object",
   "properties": {
     "$schema": {

package/schema/manifest.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://raw.githubusercontent.com/Looted/kibi/master/packages/cli/schema/manifest.json",
+  "title": "Kibi Lifecycle Manifest",
+  "description": "Kibi-owned lifecycle metadata written to .kb/manifest.json. This is not a user configuration file: entity paths and check enforcement are canonical and cannot be overridden here.",
+  "type": "object",
+  "additionalProperties": true,
+  "required": ["manifestVersion", "schemaVersion"],
+  "properties": {
+    "manifestVersion": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Payload schema for this lifecycle manifest"
+    },
+    "schemaVersion": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "KB entity/relationship schema generation"
+    },
+    "semanticAdvisorBackfill": {
+      "type": "string",
+      "enum": ["pending", "completed", "not_applicable"],
+      "description": "Retroactive semantic-advisor backfill review state"
+    }
+  }
+}

package/src/public/branch-resolver.ts

@@ -1 +1,2 @@
 export * from "../utils/branch-resolver.js";
+export * from "../utils/branch-store-locator.js";

package/src/public/check-types.ts

@@ -1,19 +1,19 @@
 /*
- 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/>.
+ * 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/>.
  */
 
 /**
@@ -21,9 +21,8 @@
  * Import from "kibi-cli/public/check-types" in MCP or external consumers.
  */
 export type {
-  ChecksConfig,
   RuleDefinition,
-  SymbolTraceabilityOptions,
+  RuleEnforcementClass,
   Violation,
 } from "../utils/rule-registry.js";
 export type {
@@ -34,11 +33,15 @@ export type {
 } from "../utils/strict-modeling.js";
 
 export {
-  DEFAULT_CHECKS_CONFIG,
   RULE_NAMES,
   RULES,
+  getCanonicalRules,
+  getDefaultRules,
   getEffectiveRules,
-  mergeChecksConfig,
+  getRuleDefinition,
+  getRuleEnforcementClass,
+  isCanonicalRule,
+  ruleRunsByDefault,
   validateRuleName,
 } from "../utils/rule-registry.js";
 

package/src/public/diagnostic-usage.ts

@@ -22,7 +22,12 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 
 function resultRecord(result: unknown): Record<string, unknown> | undefined {
   if (!isRecord(result)) return undefined;
-  return isRecord(result.structuredContent) ? result.structuredContent : result;
+  if (isRecord(result.structuredContent)) return result.structuredContent;
+  // CLI JSON operations return the same versioned KibiResult envelope as MCP
+  // structuredContent.  Unwrap its data before deriving operation-specific
+  // telemetry fields (coverage/proof fields in particular).
+  if (result.kibiProtocol === 1 && isRecord(result.data)) return result.data;
+  return result;
 }
 
 function stringArray(value: unknown): string[] {
@@ -84,9 +89,54 @@ const RECEIPT_GAP_CODES = new Set([
   "stale_verification_receipt",
   "failed_verification_receipt",
   "invalid_verification_receipt",
+  "verification_contract_mismatch",
   "verification_snapshot_unavailable",
 ]);
 
+const MAX_COVERAGE_RECEIPT_GAPS = 50;
+
+function coverageReceiptGapDetails(rows: readonly Record<string, unknown>[]): {
+  readonly details: readonly Record<string, unknown>[];
+  readonly total: number;
+  readonly truncated: boolean;
+} {
+  const details = rows
+    .flatMap((row) => {
+      const codes = [...new Set(stringArray(row.proofGaps))]
+        .filter((code) => RECEIPT_GAP_CODES.has(code))
+        .sort();
+      if (codes.length === 0) return [];
+      const stages = isRecord(row.proofStages) ? row.proofStages : undefined;
+      const passingE2e = isRecord(stages?.passingE2e)
+        ? stages.passingE2e
+        : undefined;
+      const testIds = [
+        "missingReceiptTests",
+        "staleReceiptTests",
+        "failedReceiptTests",
+        "invalidReceiptTests",
+        "contractMismatchReceiptTests",
+        "snapshotUnavailableTests",
+      ].flatMap((key) => stringArray(passingE2e?.[key]));
+      const requirementId = typeof row.id === "string" ? row.id : "unknown";
+      return [
+        {
+          requirementId,
+          testIds: [...new Set(testIds)].sort(),
+          codes,
+        },
+      ];
+    })
+    .sort((left, right) =>
+      left.requirementId.localeCompare(right.requirementId),
+    );
+  return {
+    details: details.slice(0, MAX_COVERAGE_RECEIPT_GAPS),
+    total: details.length,
+    truncated: details.length > MAX_COVERAGE_RECEIPT_GAPS,
+  };
+}
+
 function appendCoverageFields(
   fields: Record<string, unknown>,
   args: Readonly<Record<string, unknown>>,
@@ -108,6 +158,10 @@ function appendCoverageFields(
   fields.coverage_receipt_gap_count = gapCodes.filter((code) =>
     RECEIPT_GAP_CODES.has(code),
   ).length;
+  const receiptGaps = coverageReceiptGapDetails(rows);
+  fields.coverage_receipt_gaps = receiptGaps.details;
+  fields.coverage_receipt_gap_total = receiptGaps.total;
+  fields.coverage_receipt_gaps_truncated = receiptGaps.truncated;
   if (typeof scope?.complete === "boolean") {
     fields.coverage_scope_complete = scope.complete;
   }
@@ -135,6 +189,30 @@ export function deriveDiagnosticUsageFields(
   }
 
   const structured = resultRecord(result);
+  const envelope =
+    isRecord(structured) && structured.kibiProtocol === 1
+      ? structured
+      : undefined;
+  if (envelope) {
+    fields.protocol_version = envelope.kibiProtocol;
+    fields.result_version =
+      typeof envelope.resultVersion === "string"
+        ? envelope.resultVersion
+        : null;
+    fields.result_status =
+      typeof envelope.status === "string" ? envelope.status : null;
+    fields.effect_failures = Array.isArray(envelope.effects)
+      ? envelope.effects.filter(
+          (effect) => isRecord(effect) && effect.status === "failed",
+        )
+      : [];
+    fields.followed_next_actions = Array.isArray(
+      telemetry?.followed_next_actions,
+    )
+      ? telemetry.followed_next_actions
+      : [];
+    fields.unsafe_original_retry = telemetry?.unsafe_original_retry === true;
+  }
   if (tool === "kb_query" || tool === "kb_search") {
     const resultCount = Number(structured?.count ?? 0);
     fields.result_count = resultCount;

package/src/public/distribution-parity.ts

@@ -20,6 +20,7 @@ export const REQUIREMENT_COMPILER_CAPABILITIES = [
   "conservative_proof",
   "repair_plan",
   "verification_receipts",
+  "verification_contract",
   "telemetry_acceptance",
 ] as const;
 

package/src/public/ignore-policy.ts

@@ -1,15 +1,9 @@
-import {
-  type Dirent,
-  existsSync,
-  readFileSync,
-  readdirSync,
-  statSync,
-} from "node:fs";
+import { type Dirent, existsSync, readFileSync, readdirSync } from "node:fs";
 import * as path from "node:path";
 import ignore from "ignore";
+import { DERIVED_KB_PREFIXES } from "../utils/kb-paths.js";
 
 const HARD_DENYLIST = [
-  ".kb",
   ".git",
   "node_modules",
   "vendor",
@@ -18,6 +12,9 @@ const HARD_DENYLIST = [
   ".opencode",
 ];
 
+/** Derived .kb/ runtime trees. Authored knowledge lanes stay visible. */
+const HARD_DENY_KB_PREFIXES = DERIVED_KB_PREFIXES;
+
 export interface IgnorePolicy {
   isIgnored(inputPath: string): boolean;
   getFastGlobIgnoreGlobs(): string[];
@@ -41,7 +38,7 @@ function toPosix(p: string): string {
   return p.split(path.sep).join("/");
 }
 
-// implements REQ-001
+// implements REQ-cli-canonical-runtime
 export function createRepoIgnorePolicy(workspaceRoot: string): IgnorePolicy {
   const root = path.resolve(workspaceRoot);
 
@@ -69,7 +66,7 @@ export function createRepoIgnorePolicy(workspaceRoot: string): IgnorePolicy {
       if (ent.isDirectory()) {
         // avoid descending into common heavy or control directories
         if (HARD_DENYLIST.includes(name)) continue;
-        // also avoid .git itself to prevent reading internal excludes as nested
+        if (name === ".kb") continue;
         if (name === ".git") continue;
         walk(abs);
       } else if (ent.isFile()) {
@@ -113,6 +110,11 @@ export function createRepoIgnorePolicy(workspaceRoot: string): IgnorePolicy {
 
   function matchesHardDeny(relPosix: string): boolean {
     const segments = relPosix.split("/").filter(Boolean);
+    for (const prefix of HARD_DENY_KB_PREFIXES) {
+      if (relPosix === prefix || relPosix.startsWith(`${prefix}/`)) {
+        return true;
+      }
+    }
     for (const deny of HARD_DENYLIST) {
       if (segments.includes(deny)) return true;
     }
@@ -186,6 +188,10 @@ export function createRepoIgnorePolicy(workspaceRoot: string): IgnorePolicy {
       globs.push(`**/${d}/**`);
       globs.push(`**/${d}`);
     }
+    for (const prefix of HARD_DENY_KB_PREFIXES) {
+      globs.push(`**/${prefix}/**`);
+      globs.push(`**/${prefix}`);
+    }
 
     // Root .gitignore patterns (convert to simple globs)
     for (const p of rootGitPatterns) {

package/src/public/impact/coverage-depth-quality.ts

@@ -153,10 +153,24 @@ function coverageDepthSuggestion(
 
 function createDiagnostic(
   coverage: RequirementCoverage,
+  proofEvidence:
+    | Readonly<{
+        readonly proofStatus?: string;
+        readonly passingE2eStatus?: string;
+        readonly passingE2eTests?: readonly string[];
+        readonly receiptGapCodes?: readonly string[];
+      }>
+    | undefined,
 ): QualityDiagnostic | undefined {
   const coverageDepth = classifyCoverageDepth(coverage);
   if (!isReviewableCoverageDepth(coverageDepth)) return undefined;
 
+  // Structural coverage and conservative proof are separate lanes. A current
+  // scenario-backed E2E receipt is strong execution evidence even when the
+  // requirement remains unresolved for ontology, symbol, or coordinate gaps.
+  // Do not emit a contradictory weak-depth review in that case.
+  if (proofEvidence?.passingE2eStatus === "passed") return undefined;
+
   const allTests = uniqueEntities([
     ...coverage.directTests,
     ...coverage.scenarioTests,
@@ -180,6 +194,18 @@ function createDiagnostic(
       scenarioTests: coverage.scenarioTests.map((test) => test.id),
       testStatuses: uniqueStrings(allTests.map((test) => test.status)),
       verificationScopes: uniqueStrings(allTests.map(testScope)),
+      ...(proofEvidence?.proofStatus !== undefined
+        ? { proofStatus: proofEvidence.proofStatus }
+        : {}),
+      ...(proofEvidence?.passingE2eStatus !== undefined
+        ? { passingE2eStatus: proofEvidence.passingE2eStatus }
+        : {}),
+      ...(proofEvidence?.passingE2eTests !== undefined
+        ? { passingE2eTests: [...proofEvidence.passingE2eTests] }
+        : {}),
+      ...(proofEvidence?.receiptGapCodes !== undefined
+        ? { receiptGapCodes: [...proofEvidence.receiptGapCodes] }
+        : {}),
     },
   };
 }
@@ -252,6 +278,15 @@ function coverageForRequirement(
 
 export function createCoverageDepthQualityDiagnostics(
   manifestResults: readonly ExtractionResult[],
+  proofByRequirement: ReadonlyMap<
+    string,
+    Readonly<{
+      readonly proofStatus?: string;
+      readonly passingE2eStatus?: string;
+      readonly passingE2eTests?: readonly string[];
+      readonly receiptGapCodes?: readonly string[];
+    }>
+  > = new Map(),
 ): readonly QualityDiagnostic[] {
   const entities = entitiesById(manifestResults);
   return manifestResults
@@ -259,6 +294,7 @@ export function createCoverageDepthQualityDiagnostics(
     .flatMap((result) => {
       const diagnostic = createDiagnostic(
         coverageForRequirement(result, manifestResults, entities),
+        proofByRequirement.get(result.entity.id),
       );
       return diagnostic === undefined ? [] : [diagnostic];
     })