kibi-cli 2.16.0 → 2.18.0

package/dist/public/skills/kibi-usage/SKILL.md

@@ -2,7 +2,7 @@
 id: kibi-usage
 name: Kibi Usage
 description: Use Kibi's source-first, exact-Git, migration-aware, proof-aware operations safely across MCP or the trusted local CLI, including partial completion repair.
-version: 2.12.0
+version: 2.14.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -148,7 +148,13 @@ error `BOOTSTRAP_PLAN_REJECTED` can follow earlier committed actions: inspect
 `data.actionResults` and `data.applied`, then re-plan from the current state.
 Its journal is terminal; never recover or replay it. `BOOTSTRAP_PLAN_INVALID`
 fails preflight before bootstrap writes or a new journal; obtain a corrected
-plan. If the status is
+plan. A migration plan whose actions were refused before changing anything
+returns `status: error`, `MIGRATION_PLAN_REFUSED` and `data.outcome:
+refused`: nothing changed, so read the action `detail` and get a new plan.
+`data.outcome: reconciliation_required` (status success) means an action
+failed mid-way: inspect its effect before retrying. `kb_delete` of an
+authored entity returns status success with `deleted: 0`; its `errors` say
+why nothing was deleted. If the status is
 `committed_with_repairs`, the mutation already committed: inspect failed effects,
 execute each required repair action in order, and never retry the original
 operation. Record effect failures, followed actions, and unsafe retries in
@@ -231,7 +237,11 @@ authored. Each one is the order the write path accepts.
    fact, `requires_predicate` to `relationshipTarget` and `specified_by` to
    its scenario: `specified_by` (req → scenario) is sent in the
    requirement's write, never in the scenario's, so create the scenario
-   first. A
+   first, with `assumes` links (scenario → `property_value` fact, sent in
+   the scenario's own write) to the values its outcome relies on. Set
+   `expects` only on a scenario that has `assumes` links; `expects: success`
+   without them only yields `scenario-feasibility-unknown` ("assumes
+   nothing"). A
    `modeled` entry and its grounding link must arrive in the same write
    (`modeled semantic_inventory entries (n) must equal logical grounding
    relationships (m)`); a clause not grounded yet stays `status: missing`
@@ -243,7 +253,12 @@ authored. Each one is the order the write path accepts.
    claim_keys must match logical grounding target claim_keys exactly`.
    Prefer supersession for a change of meaning: analyze the new prose,
    write its facts, write the new requirement (`-v2`) with `supersedes` to
-   the old one, then set the old one to `status: closed`. For a wording fix
+   the old one, then set the old one to `status: closed`. Its scenario
+   follows the same rule as in recipe 1: create the new scenario (with
+   `assumes` to the `property_value` facts it relies on, and `expects` only
+   when it has them) before the `-v2` write that sends `specified_by`, then
+   re-point the old scenario (its `assumes` go in its own write) or close
+   it. For a wording fix
    that keeps the meaning, re-ground in place: analyze the new prose,
    `kb_upsert` each grounding fact with the new `claim_key`/`claim_text`
    (same fact id), then `kb_upsert` the requirement with the new ledger,

package/dist/public/skills/kibi-usage/resources/fact-lanes.md

@@ -61,16 +61,16 @@ A schema can close an argument with `argument_constants` (allowed values keyed b
 
 ### Deny predicate
 
-Claim: “Suspended users must not publish articles.” When `permission_rule` fits, preserve its positive schema name and encode prohibition as polarity:
+Claim: “Suspended users must not publish articles.” When `permission_rule` fits, preserve its positive schema name and encode prohibition as polarity. `kb_model` (`mode: "predicates"`) plans this fact for the claim; the built-in schema's fourth argument, `decision`, repeats the polarity:
 
 ```yaml
 id: FACT-SUSPENDED-PUBLISH-DENIED
 status: active
 fact_kind: predicate
 predicate_name: permission_rule
-predicate_args: [suspended_user, publish, article]
+predicate_args: [suspended_user, publish, articles, deny]
 polarity: deny
-canonical_key: permission_rule(suspended_user,publish,article)
+canonical_key: permission_rule(suspended_user,publish,articles,deny)
 claim_key: <advisor-issued key for this exact clause>
 claim_text: Suspended users must not publish articles.
 relationship: { type: requires_predicate, from: REQ-SUSPENDED-PUBLISH-DENIED, to: FACT-SUSPENDED-PUBLISH-DENIED }

package/dist/public/skills/kibi-usage/resources/proof.md

@@ -51,6 +51,15 @@ proof_bindings:                 # optional provenance metadata
 
 Provenance lives in `proof_bindings`; the contract stays semantic.
 
+- Every `required_proofs[].symbol_id` must name an existing `symbol` entity,
+  or `kb_check` reports `proof-contract-symbols`. Create the symbols first
+  (`kb_upsert`, narrow method-level granularity, never a `type-shape`
+  symbol): a production symbol `implements` the requirement and is
+  `covered_by` the test; an executable test symbol is `executable_for` it.
+- `proof_bindings[].source_file`, when set, must equal the named symbol's
+  `sourceFile`: for a production symbol that is the production file, not the
+  spec file that exercises it. Omit it when unsure.
+
 ## Integration configuration
 
 `.kb/proof/integrations.json` (`kibi.proof-integration.v1`) is tracked,
@@ -62,12 +71,21 @@ returns `integrationPlan`, a hash-bound `kibi.migration-plan.v2`, plus the
 proposal to the human, then apply the plan with `kb_apply_plan` (or
 `kibi apply-plan --input -`) passing `plan`, `approvedPlanHash` (the plan's
 `planHash`) and `approvedActionIds`. Once the file exists, a create plan is
-refused; `kibi proof inspect --update <id> --json` plans adding or replacing
-one named integration.
+refused (`status: error`, `MIGRATION_PLAN_REFUSED`, `data.outcome: refused`;
+nothing is written); `kibi proof inspect --update <id> --json` plans adding or
+replacing one named integration.
 
 - `producer: command` — Kibi synthesizes the envelope from the process
   outcome; obligations are bound with `aggregate_run` provenance and the
-  single process invocation counts as the known first attempt.
+  single process invocation counts as the known first attempt. The run is
+  judged as a whole: any failing test in it fails every obligation of every
+  test that names the integration, so a suite with unrelated failures proves
+  nothing. Narrow the command to the proof-bearing tests with
+  `kibi proof inspect --update <id> --command "<command>" --json` (without
+  `--command` the proposal is the `package.json` `test` script or the
+  detected runner again), or make the run attributable per test: have the
+  command write a `kibi.proof-test-report.v1` to the path in
+  `KIBI_PROOF_TEST_REPORT` so each test is judged by its own steps.
 - `producer: playwright` (or custom) — the child emits `kibi.proof-run.v1`
   itself (bundled reporter: `kibi-cli/playwright-reporter`).
 - `producer: junit` / `tap` — Kibi converts the native report at `artifact`
@@ -79,6 +97,29 @@ Cosmetic edits (descriptions, labels) never stale proof. Execution-relevant
 edits (command, artifact, targets, options, bindings, contract) change the
 effective fingerprint and do.
 
+## What counts toward proofProven
+
+A requirement is proven only by its scenarios' tests, and a scenario test
+counts only when it is an **end-to-end** test with a valid, fresh, passing
+receipt for the current snapshot.
+
+- The scope comes from the test entity's `verification_scope`
+  (`end_to_end`, `integration`, `unit`), never from the integration id or the
+  producer. Without `verification_scope`, a test tagged `e2e` (or whose
+  `source` path contains `e2e`) counts as end-to-end; anything else is
+  `unknown` scope.
+- A `unit` or `integration` receipt is still recorded on the test entity, but
+  it does not move `proofProven` for a behavioural requirement: the
+  requirement keeps the `missing_passing_e2e` gap in `proofGaps`. The one
+  exception is a scenario whose specifying requirements are all grounded only
+  in component-scope UI predicates (`ui_pattern`, `same_pattern`,
+  `pattern_marker`); a unit or integration test that renders the component
+  may prove it.
+- `coverage_depth` (`kb_coverage`, `kb_find_gaps`) follows the test's
+  authored `status` (`passing`) and scope, not its receipts: a passing
+  receipt does not change it, and a `passing` status without a fresh receipt
+  proves nothing.
+
 ## Attempt semantics (factual, never optimistic)
 
 - `attempts: {status: "complete", entries: [...]}` — known history; the

package/dist/utils/branch-store.d.ts

@@ -21,6 +21,14 @@ export declare function inspectBranchStore(workspaceRoot: string, branch: string
  * auto-heal; the reason exists so operators see the state before it bites.
  */
 export declare function storeLockJournalReason(storePath: string): Record<string, unknown> | null;
+/**
+ * An informational notice that this branch store's lock was taken over from
+ * a dead holder. The takeover itself is safe and automatic; it is reported
+ * because it means an engine or prove run crashed or was killed while it
+ * held the store, which nothing else shows once the new holder rewrites the
+ * ownership journal. Visible for STORE_LOCK_TAKEOVER_VISIBLE_MS.
+ */
+export declare function storeLockTakeoverReason(storePath: string, now?: Date): Record<string, unknown> | null;
 export declare function branchStoreReason(inspection: BranchStoreInspection): Record<string, unknown> | null;
 /**
  * The number of authored source files under `.kb/`: entity Markdown in the

package/dist/utils/branch-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"branch-store.d.ts","sourceRoot":"","sources":["../../src/utils/branch-store.ts"],"names":[],"mappings":"AAwBA,mEAAmE;AACnE,eAAO,MAAM,yBAAyB,8BAA8B,CAAC;AACrE,yCAAyC;AACzC,eAAO,MAAM,8BAA8B,8BAA8B,CAAC;AAE1E,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,SAAS,GACT,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC,CAAC;AAEH;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GACb,qBAAqB,CA0GvB;AAED;;;;GAIG;AAEH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAiBhC;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,qBAAqB,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAWhC;AA6BD;;;;GAIG;AAEH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC,CAAC;AAEH;;;;;;GAMG;AAEH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,qBAAqB,GAChC,sBAAsB,CAwBxB;AAkBD;;;;;;GAMG;AAEH,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,qBAAqB,EACjC,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAwBhC"}
+{"version":3,"file":"branch-store.d.ts","sourceRoot":"","sources":["../../src/utils/branch-store.ts"],"names":[],"mappings":"AA0BA,mEAAmE;AACnE,eAAO,MAAM,yBAAyB,8BAA8B,CAAC;AACrE,yCAAyC;AACzC,eAAO,MAAM,8BAA8B,8BAA8B,CAAC;AAE1E,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,SAAS,GACT,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC,CAAC;AAEH;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GACb,qBAAqB,CA0GvB;AAED;;;;GAIG;AAEH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAiBhC;AAED;;;;;;GAMG;AAEH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,IAAiB,GACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAehC;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,qBAAqB,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAWhC;AA6BD;;;;GAIG;AAEH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC,CAAC;AAEH;;;;;;GAMG;AAEH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,qBAAqB,GAChC,sBAAsB,CAwBxB;AAkBD;;;;;;GAMG;AAEH,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,qBAAqB,EACjC,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAwBhC"}

package/dist/utils/branch-store.js

@@ -4,7 +4,7 @@
 */
 import { existsSync, readFileSync, readdirSync, statSync, } from "node:fs";
 import * as path from "node:path";
-import { classifyStoreLockHolder, readStoreLockOwner, } from "../prolog/store-lock.js";
+import { STORE_LOCK_TAKEOVER_VISIBLE_MS, classifyStoreLockHolder, readStoreLockOwner, readStoreLockTakeover, } from "../prolog/store-lock.js";
 import { branchStoreManifestMatches, branchStorePath, legacyBranchStorePath, } from "./branch-store-locator.js";
 import { ENTITY_LANES, KB_ROOT } from "./kb-paths.js";
 /** Stale-reason code of a branch store that was never compiled. */
@@ -147,6 +147,32 @@ export function storeLockJournalReason(storePath) {
         },
     };
 }
+/**
+ * An informational notice that this branch store's lock was taken over from
+ * a dead holder. The takeover itself is safe and automatic; it is reported
+ * because it means an engine or prove run crashed or was killed while it
+ * held the store, which nothing else shows once the new holder rewrites the
+ * ownership journal. Visible for STORE_LOCK_TAKEOVER_VISIBLE_MS.
+ */
+// implements REQ-core-journaled-engine-persistence
+export function storeLockTakeoverReason(storePath, now = new Date()) {
+    const record = readStoreLockTakeover(storePath);
+    if (record === null)
+        return null;
+    const age = now.getTime() - Date.parse(record.at);
+    if (age < 0 || age > STORE_LOCK_TAKEOVER_VISIBLE_MS)
+        return null;
+    return {
+        code: "store_lock_taken_over",
+        path: record.path,
+        entityIds: [],
+        blocking: false,
+        brokenPid: record.brokenPid,
+        reason: record.reason,
+        at: record.at,
+        detail: `Kibi broke a stale branch-store lock at ${record.at} (${record.reason || "holder no longer running"}) and reattached. Nothing needs repair; a holder that died while it held the store usually means an engine or kibi prove run crashed or was killed.`,
+    };
+}
 export function branchStoreReason(inspection) {
     if (inspection.state === "healthy")
         return null;

package/dist/utils/content-freshness.d.ts

@@ -0,0 +1,13 @@
+/** Stale-reason codes that compare file times only. */
+export declare const MTIME_SOURCE_REASON_CODES: ReadonlySet<string>;
+type Reason = Readonly<Record<string, unknown>>;
+/**
+ * Drop mtime-only stale reasons whose file content provably matches what the
+ * store compiled. Reasons without such evidence are kept.
+ */
+export declare function confirmSourceNewerReasons(workspaceRoot: string, storePath: string, reasons: readonly Reason[]): {
+    kept: Reason[];
+    dropped: Reason[];
+};
+export {};
+//# sourceMappingURL=content-freshness.d.ts.map

package/dist/utils/content-freshness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-freshness.d.ts","sourceRoot":"","sources":["../../src/utils/content-freshness.ts"],"names":[],"mappings":"AAYA,uDAAuD;AACvD,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CAIxD,CAAC;AAEH,KAAK,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AA6IhD;;;GAGG;AAEH,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAkBvC"}

package/dist/utils/content-freshness.js

@@ -0,0 +1,161 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+*/
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+import { load as parseYAML } from "js-yaml";
+import { hashManifestWithCoordinates } from "../commands/sync/cache.js";
+import { isSymbolsManifestPath } from "./kb-paths.js";
+/** Stale-reason codes that compare file times only. */
+export const MTIME_SOURCE_REASON_CODES = new Set([
+    "indexed_source_newer",
+    "knowledge_source_newer",
+    "documentation_source_newer",
+]);
+function sha256(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function readJson(file) {
+    try {
+        return JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+/**
+ * Content evidence recorded by the last compilation: the store's sync-cache
+ * source hashes, and the per-symbol `sourceHash` of the generated coordinate
+ * artifact. A file whose bytes match that evidence has not changed since it
+ * was compiled, however new its mtime (a fresh clone, a checkout, a touch).
+ */
+class CompiledContentEvidence {
+    workspaceRoot;
+    hashes;
+    coordinateHashes = null;
+    manifestState = new Map();
+    constructor(workspaceRoot, storePath) {
+        this.workspaceRoot = workspaceRoot;
+        const cache = record(readJson(path.join(storePath, "sync-cache.json")));
+        const hashes = record(cache?.hashes) ?? {};
+        this.hashes = Object.fromEntries(Object.entries(hashes).filter((entry) => typeof entry[1] === "string"));
+    }
+    fileHash(relative) {
+        try {
+            return sha256(readFileSync(path.resolve(this.workspaceRoot, relative)));
+        }
+        catch {
+            return null;
+        }
+    }
+    manifest(key) {
+        const cached = this.manifestState.get(key);
+        if (cached)
+            return cached;
+        const absolute = path.resolve(this.workspaceRoot, key);
+        let state = { matches: false, sources: new Set() };
+        try {
+            const matches = hashManifestWithCoordinates(this.workspaceRoot, absolute, path.join(path.dirname(absolute), "symbol-coordinates.yaml")) === this.hashes[key];
+            const parsed = record(parseYAML(readFileSync(absolute, "utf8")));
+            const sources = new Set();
+            for (const symbol of Array.isArray(parsed?.symbols)
+                ? parsed.symbols
+                : []) {
+                const row = record(symbol);
+                const source = row?.sourceFile ?? row?.source;
+                if (typeof source === "string" && source.length > 0)
+                    sources.add(source.replaceAll("\\", "/"));
+            }
+            state = { matches, sources };
+        }
+        catch {
+            // An unreadable manifest proves nothing; keep the reason.
+        }
+        this.manifestState.set(key, state);
+        return state;
+    }
+    coordinates() {
+        if (this.coordinateHashes)
+            return this.coordinateHashes;
+        const byFile = new Map();
+        for (const key of Object.keys(this.hashes)) {
+            if (!isSymbolsManifestPath(key) || !key.endsWith("symbols.yaml"))
+                continue;
+            const artifact = path.resolve(this.workspaceRoot, path.dirname(key), "symbol-coordinates.yaml");
+            if (!existsSync(artifact))
+                continue;
+            try {
+                const parsed = record(parseYAML(readFileSync(artifact, "utf8")));
+                for (const value of Object.values(record(parsed?.coordinates) ?? {})) {
+                    const row = record(value);
+                    if (typeof row?.sourceFile !== "string" ||
+                        typeof row.sourceHash !== "string")
+                        continue;
+                    const hashes = byFile.get(row.sourceFile) ?? new Set();
+                    hashes.add(row.sourceHash);
+                    byFile.set(row.sourceFile, hashes);
+                }
+            }
+            catch {
+                // A malformed artifact proves nothing.
+            }
+        }
+        this.coordinateHashes = byFile;
+        return byFile;
+    }
+    /** True only when recorded evidence proves the file's bytes are unchanged. */
+    unchanged(relative) {
+        const key = relative.replaceAll("\\", "/");
+        if (isSymbolsManifestPath(key) && this.hashes[key] !== undefined)
+            return this.manifest(key).matches;
+        const current = this.fileHash(key);
+        if (current === null)
+            return false;
+        const cached = this.hashes[key];
+        if (cached !== undefined)
+            return cached === current;
+        const coordinate = this.coordinates().get(key);
+        if (coordinate !== undefined && coordinate.size > 0)
+            return [...coordinate].every((hash) => hash === current);
+        // A code file that is only referenced from a symbol manifest is covered
+        // by that manifest's composite hash, which includes every referenced
+        // source's bytes.
+        return Object.keys(this.hashes).some((manifestKey) => {
+            if (!isSymbolsManifestPath(manifestKey))
+                return false;
+            const manifest = this.manifest(manifestKey);
+            return manifest.sources.has(key) && manifest.matches;
+        });
+    }
+}
+/**
+ * Drop mtime-only stale reasons whose file content provably matches what the
+ * store compiled. Reasons without such evidence are kept.
+ */
+// implements REQ-cli-status-pre-first-sync
+export function confirmSourceNewerReasons(workspaceRoot, storePath, reasons) {
+    const kept = [];
+    const dropped = [];
+    let evidence = null;
+    for (const reason of reasons) {
+        if (typeof reason.code !== "string" ||
+            !MTIME_SOURCE_REASON_CODES.has(reason.code) ||
+            typeof reason.path !== "string") {
+            kept.push(reason);
+            continue;
+        }
+        evidence ??= new CompiledContentEvidence(workspaceRoot, storePath);
+        if (evidence.unchanged(reason.path))
+            dropped.push(reason);
+        else
+            kept.push(reason);
+    }
+    return { kept, dropped };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.16.0",
+  "version": "2.18.0",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -235,7 +235,7 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.18.1",
+    "kibi-core": "^0.19.0",
     "kibi-plugin-builtin": "^0.5.0",
     "kibi-plugin-sdk": "^0.5.0",
     "kibi-swipl": "^1.0.1",

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

@@ -276,6 +276,46 @@ function coverageForRequirement(
   };
 }
 
+/**
+ * Requirement statuses that keep a requirement in the coverage-depth review.
+ * `closed` is reviewed only when tagged `implemented` (the documented
+ * "done, with evidence" shape); a plain closed, deprecated or superseded
+ * requirement is retired history, not a coverage gap.
+ */
+const REVIEWED_REQUIREMENT_STATUSES = new Set([
+  "open",
+  "in_progress",
+  "active",
+  "approved",
+]);
+
+function supersededRequirementIds(
+  manifestResults: readonly ExtractionResult[],
+): ReadonlySet<string> {
+  return new Set(
+    manifestResults.flatMap((result) =>
+      result.entity.type === "req"
+        ? result.relationships.flatMap((relationship) =>
+            relationship.type === "supersedes" ? [relationship.to] : [],
+          )
+        : [],
+    ),
+  );
+}
+
+// implements REQ-audit-quality-diagnostics-v1
+function isReviewableRequirement(
+  requirement: ExtractedEntity,
+  superseded: ReadonlySet<string>,
+): boolean {
+  if (superseded.has(requirement.id)) return false;
+  const status = requirement.status.trim().toLowerCase();
+  if (REVIEWED_REQUIREMENT_STATUSES.has(status)) return true;
+  return (
+    status === "closed" && (requirement.tags ?? []).includes("implemented")
+  );
+}
+
 export function createCoverageDepthQualityDiagnostics(
   manifestResults: readonly ExtractionResult[],
   proofByRequirement: ReadonlyMap<
@@ -289,8 +329,13 @@ export function createCoverageDepthQualityDiagnostics(
   > = new Map(),
 ): readonly QualityDiagnostic[] {
   const entities = entitiesById(manifestResults);
+  const superseded = supersededRequirementIds(manifestResults);
   return manifestResults
-    .filter((result) => result.entity.type === "req")
+    .filter(
+      (result) =>
+        result.entity.type === "req" &&
+        isReviewableRequirement(result.entity, superseded),
+    )
     .flatMap((result) => {
       const diagnostic = createDiagnostic(
         coverageForRequirement(result, manifestResults, entities),

package/src/public/operations/contracts.ts

@@ -452,6 +452,8 @@ const BASE_DATA_SCHEMAS: Readonly<
       truncated: booleanValue,
       queryAnalysis: recordValue,
       answer: recordValue,
+      branch: { type: ["string", "null"] },
+      branchStore: recordValue,
     },
     ["results", "count"],
   ),
@@ -476,6 +478,7 @@ const BASE_DATA_SCHEMAS: Readonly<
     staleReasons: recordArray,
     staleReasonCount: integerValue,
     staleReasonsTruncated: booleanValue,
+    notices: recordArray,
     branchAttachment: recordValue,
     proofSnapshotChanges: recordArray,
     proofSnapshotChangeCount: integerValue,