kibi-cli 2.36.0 → 2.39.0

package/dist/public/operations/repair-plan.d.ts

@@ -56,6 +56,27 @@ declare const REPAIR_PHASES: {
         readonly validationRules: readonly ["must-priority-coverage", "no-dangling-refs"];
         readonly writePolicy: "sequential_upsert";
     };
+    readonly dimension_grounding: {
+        readonly order: 64;
+        readonly objective: "Ground each quantified claim (each, every, all, or a cardinality bound) on what varies: an integer count or bound, a set of members, a rule over a variable, or a state machine. If the quantifier ranges over nothing, record a dimension_waiver on the grounding fact for a person to approve, and record their approval in the same pull request.";
+        readonly workflowSteps: readonly ["kb_model_requirement", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["no-dangling-refs"];
+        readonly writePolicy: "sequential_upsert";
+    };
+    readonly case_scenarios: {
+        readonly order: 66;
+        readonly objective: "Cover each uncovered rejection case: add a scenario whose assumes fact states the case's assumption (a value past the bound, a value outside the set), expects rejection or error, is linked with specified_by and is verified by a passing end-to-end test. Each repair lists caseSkeletons, upsert-ready draft scenarios and their assumed facts: fill in the placeholders, verify the scenario by a test, then set its status to active (a draft never covers a case). If a person accepts the cases as covered another way, record a case_waiver on the grounding fact for them to approve, and record their approval in the same pull request.";
+        readonly workflowSteps: readonly ["kb_coverage", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["scenario-outcome-mismatch", "no-dangling-refs"];
+        readonly writePolicy: "sequential_upsert";
+    };
+    readonly negative_scenarios: {
+        readonly order: 65;
+        readonly objective: "Add a scenario that expects rejection or error and assumes a value the requirement forbids (see suggestedNegatives), link it with specified_by and verify it with a passing end-to-end test.";
+        readonly workflowSteps: readonly ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"];
+        readonly validationRules: readonly ["scenario-outcome-mismatch", "no-dangling-refs"];
+        readonly writePolicy: "sequential_upsert";
+    };
     readonly scenario_tests: {
         readonly order: 70;
         readonly objective: "Create or select a test endpoint and link it through the requirement scenario.";
@@ -121,6 +142,31 @@ export type RepairPlanRepair = {
     readonly proofStage: string;
     readonly action: string;
     readonly evidence: Readonly<Record<string, unknown>>;
+    /** Draft scenarios for an uncovered_case repair, one per uncovered case. */
+    readonly caseSkeletons?: readonly CaseSkeleton[];
+};
+type SkeletonEntity = {
+    readonly type: "fact" | "scenario";
+    readonly id: string;
+    readonly properties: Readonly<Record<string, unknown>>;
+    readonly relationships: readonly {
+        readonly type: string;
+        readonly from: string;
+        readonly to: string;
+    }[];
+};
+/**
+ * An upsert-ready draft scenario for one uncovered case: the fact it assumes
+ * (the case's value class) and the scenario that expects the predicted
+ * outcome. Drafts never count as coverage, so writing one changes no gap
+ * until it is verified and made active. placeholder is true when the value
+ * must be chosen by the author (a value outside a set).
+ */
+export type CaseSkeleton = {
+    readonly caseId: string;
+    readonly constraint: string;
+    readonly placeholder: boolean;
+    readonly entities: readonly [SkeletonEntity, SkeletonEntity];
 };
 export type RepairPlanBatch = {
     readonly id: string;

package/dist/public/operations/repair-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repair-plan.d.ts","sourceRoot":"","sources":["../../../src/public/operations/repair-plan.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"repair-plan.d.ts","sourceRoot":"","sources":["../../../src/public/operations/repair-plan.ts"],"names":[],"mappings":"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"}

package/dist/public/operations/repair-plan.js

@@ -87,6 +87,37 @@ const REPAIR_PHASES = {
         validationRules: ["must-priority-coverage", "no-dangling-refs"],
         writePolicy: "sequential_upsert",
     },
+    dimension_grounding: {
+        order: 64,
+        objective: "Ground each quantified claim (each, every, all, or a cardinality bound) on what varies: an integer count or bound, a set of members, a rule over a variable, or a state machine. If the quantifier ranges over nothing, record a dimension_waiver on the grounding fact for a person to approve, and record their approval in the same pull request.",
+        workflowSteps: [
+            "kb_model_requirement",
+            "kb_validate_upsert",
+            "kb_upsert",
+            "kb_check",
+        ],
+        validationRules: ["no-dangling-refs"],
+        writePolicy: "sequential_upsert",
+    },
+    case_scenarios: {
+        order: 66,
+        objective: "Cover each uncovered rejection case: add a scenario whose assumes fact states the case's assumption (a value past the bound, a value outside the set), expects rejection or error, is linked with specified_by and is verified by a passing end-to-end test. Each repair lists caseSkeletons, upsert-ready draft scenarios and their assumed facts: fill in the placeholders, verify the scenario by a test, then set its status to active (a draft never covers a case). If a person accepts the cases as covered another way, record a case_waiver on the grounding fact for them to approve, and record their approval in the same pull request.",
+        workflowSteps: [
+            "kb_coverage",
+            "kb_validate_upsert",
+            "kb_upsert",
+            "kb_check",
+        ],
+        validationRules: ["scenario-outcome-mismatch", "no-dangling-refs"],
+        writePolicy: "sequential_upsert",
+    },
+    negative_scenarios: {
+        order: 65,
+        objective: "Add a scenario that expects rejection or error and assumes a value the requirement forbids (see suggestedNegatives), link it with specified_by and verify it with a passing end-to-end test.",
+        workflowSteps: ["kb_query", "kb_validate_upsert", "kb_upsert", "kb_check"],
+        validationRules: ["scenario-outcome-mismatch", "no-dangling-refs"],
+        writePolicy: "sequential_upsert",
+    },
     scenario_tests: {
         order: 70,
         objective: "Create or select a test endpoint and link it through the requirement scenario.",
@@ -173,6 +204,9 @@ const GAP_PHASE = {
     missing_scenario: "scenario_endpoints",
     infeasible_scenario: "scenario_endpoints",
     unknown_scenario_feasibility: "scenario_endpoints",
+    dimension_unrepresented: "dimension_grounding",
+    happy_path_only: "negative_scenarios",
+    uncovered_case: "case_scenarios",
     missing_scenario_test: "scenario_tests",
     proof_snapshot_unavailable: "snapshot_runtime",
     missing_passing_e2e: "proof_evidence",
@@ -201,6 +235,9 @@ const GAP_STAGE = {
     missing_scenario: "scenarios",
     infeasible_scenario: "scenarios",
     unknown_scenario_feasibility: "scenarios",
+    dimension_unrepresented: "dimension",
+    happy_path_only: "negative_path",
+    uncovered_case: "cases",
     missing_scenario_test: "scenario_tests",
     missing_passing_e2e: "passing_e2e",
     missing_proof_receipt: "passing_e2e",
@@ -220,6 +257,9 @@ const PROOF_STAGE_KEY = {
     contradictions: "contradictions",
     scenarios: "scenarios",
     scenario_tests: "scenarioTests",
+    negative_path: "negativePath",
+    dimension: "dimension",
+    cases: "cases",
     passing_e2e: "passingE2e",
     executable_symbols: "executableSymbols",
     production_symbols: "productionSymbols",
@@ -261,6 +301,71 @@ function stageEvidence(row, proofStage) {
     const stable = stableValue(evidence);
     return isRecord(stable) ? stable : {};
 }
+const VALUE_FIELD = {
+    int: "value_int",
+    number: "value_number",
+    set: "value_set",
+    string: "value_string",
+};
+function caseSkeleton(requirementId, row) {
+    const caseId = typeof row.caseId === "string" ? row.caseId : undefined;
+    const assumption = isRecord(row.assumption) ? row.assumption : undefined;
+    const valueType = typeof assumption?.value_type === "string" ? assumption.value_type : "";
+    const valueField = VALUE_FIELD[valueType];
+    if (caseId === undefined || assumption === undefined || !valueField)
+        return undefined;
+    const constraint = typeof row.constraint === "string" ? row.constraint : "";
+    const property = typeof assumption.property_key === "string" ? assumption.property_key : "";
+    const expects = row.predicted === "rejection" ? "rejection" : "success";
+    const placeholder = JSON.stringify(assumption.value).includes("<");
+    const suffix = caseId.replace(/^CASE-/, "");
+    const factId = `FACT-CASE-${suffix}`;
+    const scenarioId = `SCEN-CASE-${suffix}`;
+    return {
+        caseId,
+        constraint,
+        placeholder,
+        entities: [
+            {
+                type: "fact",
+                id: factId,
+                properties: {
+                    title: `${property} ${constraint}`,
+                    status: "active",
+                    fact_kind: "property_value",
+                    subject_key: assumption.subject_key,
+                    property_key: property,
+                    operator: assumption.operator,
+                    value_type: valueType,
+                    [valueField]: assumption.value,
+                },
+                relationships: [],
+            },
+            {
+                type: "scenario",
+                id: scenarioId,
+                properties: {
+                    title: `${property} ${constraint} is ${expects === "rejection" ? "refused" : "accepted"}`,
+                    status: "draft",
+                    expects,
+                },
+                relationships: [
+                    { type: "assumes", from: scenarioId, to: factId },
+                    { type: "specified_by", from: requirementId, to: scenarioId },
+                ],
+            },
+        ],
+    };
+}
+function caseSkeletons(requirementId, evidence) {
+    const rows = Array.isArray(evidence.uncoveredCases)
+        ? evidence.uncoveredCases.filter(isRecord)
+        : [];
+    return rows.flatMap((row) => {
+        const skeleton = caseSkeleton(requirementId, row);
+        return skeleton === undefined ? [] : [skeleton];
+    });
+}
 function batchId(requirementId, phase) {
     const order = String(REPAIR_PHASES[phase].order).padStart(3, "0");
     const safeRequirementId = requirementId.replace(/[^A-Za-z0-9_-]/g, "-");
@@ -280,13 +385,17 @@ function buildRequirementBatches(row) {
         const proofStage = typeof sourceRepair?.stage === "string"
             ? sourceRepair.stage
             : (GAP_STAGE[gap] ?? "manual_review");
+        const evidence = stageEvidence(row, proofStage);
         const repair = {
             requirementId,
             gap,
             proofPriority: numberField(sourceRepair?.priority, REPAIR_PHASES[phase].order),
             proofStage,
             action: actionForRepair(sourceRepair, phase),
-            evidence: stageEvidence(row, proofStage),
+            evidence,
+            ...(gap === "uncovered_case"
+                ? { caseSkeletons: caseSkeletons(requirementId, evidence) }
+                : {}),
         };
         const phaseRepairs = byPhase.get(phase) ?? [];
         phaseRepairs.push(repair);

package/dist/public/operations/schema6-check-actions.js

@@ -600,7 +600,7 @@ export function schema6ReviewActionsFromCheck(diagnostics) {
             safety: "review",
             invocation: {
                 kind: "review",
-                instruction: `${total} agent-authored requirement(s) have no human approval${total > listed.length ? `; these ${listed.length} come first` : ""}: ${listed.join(", ")}. Have a person read each one; when it states the intended behavior, kb_upsert it with origin.approved_by set to the reviewer (keep kind: agent and the rest of origin). Rerun kb_check for the next page.`,
+                instruction: `${total} agent-authored requirement(s) have no human approval${total > listed.length ? `; these ${listed.length} come first` : ""}: ${listed.join(", ")}. Have a person read each one; when it states the intended behavior, kb_upsert it with origin.approved_by set to the reviewer (keep kind: agent and the rest of origin), in the same change and pull request as the requirement, not a separate one. Rerun kb_check for the next page.`,
             },
             affectedEntityIds: listed,
             affectedFiles: [...new Set(agentRequirementFiles)].sort(),

package/dist/public/operations/source-analysis-cache.d.ts

@@ -0,0 +1,22 @@
+import type { HostSourceAnalysisResultV2 } from "../../plugins/source-analysis-service.js";
+/**
+ * Parser-backed source analyses kept across `kibi check` runs. Parsing every
+ * symbol's source file was the largest client cost of a warm check, and an
+ * analysis is a pure function of the file's path and bytes under one
+ * analyzer set, so an entry is keyed by both and the whole cache by the
+ * analyzer set. The file lives in the branch store, which is never tracked.
+ */
+export declare const SOURCE_ANALYSIS_CACHE_FILE = "source-analysis-cache.json";
+export type SourceAnalysisCache = {
+    get(file: string, content: string): HostSourceAnalysisResultV2 | undefined;
+    set(file: string, content: string, analysis: HostSourceAnalysisResultV2): void;
+    /** Write the entries this run read or added, dropping the rest. */
+    save(): void;
+};
+/**
+ * The cache in `storeDir`, or null when the analyzer set cannot be
+ * fingerprinted or there is no store. Only complete (`ok`) analyses
+ * are kept; anything else is computed again.
+ */
+export declare function openSourceAnalysisCache(storeDir: string | undefined, workspaceRoot: string): SourceAnalysisCache | null;
+//# sourceMappingURL=source-analysis-cache.d.ts.map

package/dist/public/operations/source-analysis-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-analysis-cache.d.ts","sourceRoot":"","sources":["../../../src/public/operations/source-analysis-cache.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AAE3F;;;;;;GAMG;AAEH,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AASvE,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,0BAA0B,GAAG,SAAS,CAAC;IAC3E,GAAG,CACD,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,0BAA0B,GACnC,IAAI,CAAC;IACR,mEAAmE;IACnE,IAAI,IAAI,IAAI,CAAC;CACd,CAAC;AAkFF;;;;GAIG;AAEH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,aAAa,EAAE,MAAM,GACpB,mBAAmB,GAAG,IAAI,CA4C5B"}

package/dist/public/operations/source-analysis-cache.js

@@ -0,0 +1,157 @@
+/*
+ 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/>.
+*/
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fingerprintMaintenanceSourceSet } from "../../plugins/maintenance-source-analysis.js";
+import { readProjectKibiConfig } from "../../plugins/project-config.js";
+/**
+ * Parser-backed source analyses kept across `kibi check` runs. Parsing every
+ * symbol's source file was the largest client cost of a warm check, and an
+ * analysis is a pure function of the file's path and bytes under one
+ * analyzer set, so an entry is keyed by both and the whole cache by the
+ * analyzer set. The file lives in the branch store, which is never tracked.
+ */
+// implements REQ-cli-check
+export const SOURCE_ANALYSIS_CACHE_FILE = "source-analysis-cache.json";
+const SOURCE_ANALYSIS_CACHE_VERSION = 1;
+function entryKey(file, content) {
+    return createHash("sha256")
+        .update(file)
+        .update("\0")
+        .update(content)
+        .digest("hex");
+}
+/**
+ * The builtin analyzer is identified by its package version, which a local
+ * build does not bump; its built files' sizes and times stand in for its
+ * code so a rebuilt analyzer starts a fresh cache.
+ */
+function builtinBuildStamp() {
+    const hash = createHash("sha256");
+    try {
+        const manifest = createRequire(import.meta.url).resolve("kibi-plugin-builtin/package.json");
+        const symbolsDir = path.join(path.dirname(manifest), "dist", "symbols");
+        // rationale: readdir lists this directory in name order on the supported
+        // filesystems, so the sort only guards odd ones and no test can tell.
+        // Stryker disable next-line MethodExpression
+        for (const name of readdirSync(symbolsDir).sort()) {
+            const stat = statSync(path.join(symbolsDir, name));
+            hash.update(`${name}\0${stat.size}\0${stat.mtimeMs}\n`);
+        }
+    }
+    catch {
+        // An unavailable builtin package stamps as no built files.
+    }
+    // rationale: the stamp only feeds the analyzer-set JSON; a Buffer
+    // serializes as deterministically as the hex text it replaces.
+    // Stryker disable next-line StringLiteral
+    return hash.digest("hex");
+}
+function analyzerSetKey(workspaceRoot) {
+    try {
+        const sourceSet = fingerprintMaintenanceSourceSet(workspaceRoot, readProjectKibiConfig(workspaceRoot));
+        return createHash("sha256")
+            .update(JSON.stringify({
+            version: SOURCE_ANALYSIS_CACHE_VERSION,
+            sourceSet,
+            builtin: builtinBuildStamp(),
+        }))
+            .digest("hex");
+    }
+    catch {
+        // An analyzer set Kibi cannot fingerprint is never cached.
+        return null;
+    }
+}
+function readCacheFile(cachePath, analyzers) {
+    const empty = {
+        version: SOURCE_ANALYSIS_CACHE_VERSION,
+        analyzers,
+        entries: {},
+    };
+    try {
+        // A missing or unreadable file, or JSON null, throws and starts empty.
+        const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
+        if (parsed.version !== SOURCE_ANALYSIS_CACHE_VERSION ||
+            parsed.analyzers !== analyzers ||
+            parsed.entries === null ||
+            typeof parsed.entries !== "object") {
+            return empty;
+        }
+        return parsed;
+    }
+    catch {
+        return empty;
+    }
+}
+/**
+ * The cache in `storeDir`, or null when the analyzer set cannot be
+ * fingerprinted or there is no store. Only complete (`ok`) analyses
+ * are kept; anything else is computed again.
+ */
+// implements REQ-cli-check
+export function openSourceAnalysisCache(storeDir, workspaceRoot) {
+    // rationale: an undefined directory does not exist either, so dropping the
+    // first test changes nothing observable.
+    // Stryker disable next-line ConditionalExpression
+    if (storeDir === undefined || !existsSync(storeDir))
+        return null;
+    const analyzers = analyzerSetKey(workspaceRoot);
+    if (analyzers === null)
+        return null;
+    const cachePath = path.join(storeDir, SOURCE_ANALYSIS_CACHE_FILE);
+    const stored = readCacheFile(cachePath, analyzers);
+    const used = {};
+    let changed = false;
+    return {
+        get(file, content) {
+            const key = entryKey(file, content);
+            const entry = stored.entries[key];
+            if (entry === undefined || entry.status !== "ok")
+                return undefined;
+            used[key] = entry;
+            return entry;
+        },
+        set(file, content, analysis) {
+            if (analysis.status !== "ok")
+                return;
+            used[entryKey(file, content)] = analysis;
+            changed = true;
+        },
+        save() {
+            const kept = Object.keys(used).length;
+            if (!changed && kept === Object.keys(stored.entries).length)
+                return;
+            const temporary = `${cachePath}.${process.pid}.tmp`;
+            try {
+                writeFileSync(temporary, JSON.stringify({
+                    version: SOURCE_ANALYSIS_CACHE_VERSION,
+                    analyzers,
+                    entries: used,
+                }));
+                renameSync(temporary, cachePath);
+            }
+            catch {
+                // The cache is an optimization; a failed write only costs a reparse.
+                rmSync(temporary, { force: true });
+            }
+        },
+    };
+}

package/dist/public/operations/specs/check-rules.generated.d.ts

@@ -1,5 +1,5 @@
 /** Every selectable kb_check rule name, registry order. */
 export declare const SELECTABLE_RULE_NAMES: readonly string[];
 /** Comma-separated "Allowed:" fragment for the kb_check rules description. */
-export declare const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers, kb-consistency, kb-consistency-unresolved, evidence-floor, proof-contract-claims";
+export declare const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, scenario-outcome-mismatch, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers, kb-consistency, kb-consistency-unresolved, evidence-floor, proof-contract-claims";
 //# sourceMappingURL=check-rules.generated.d.ts.map

package/dist/public/operations/specs/check-rules.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-rules.generated.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check-rules.generated.ts"],"names":[],"mappings":"AAUA,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EA0DlD,CAAC;AAGF,8EAA8E;AAC9E,eAAO,MAAM,wBAAwB,wwCACkuC,CAAC"}
+{"version":3,"file":"check-rules.generated.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check-rules.generated.ts"],"names":[],"mappings":"AAUA,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EA2DlD,CAAC;AAGF,8EAA8E;AAC9E,eAAO,MAAM,wBAAwB,myCAC6vC,CAAC"}

package/dist/public/operations/specs/check-rules.generated.js

@@ -23,6 +23,7 @@ export const SELECTABLE_RULE_NAMES = [
     "superseded-requirement-open",
     "scenario-feasibility",
     "scenario-feasibility-unknown",
+    "scenario-outcome-mismatch",
     "exception-claim-keys",
     "numeric-string-value",
     "rule-key-arguments-missing",
@@ -69,4 +70,4 @@ export const SELECTABLE_RULE_NAMES = [
 ];
 // implements REQ-006
 /** Comma-separated "Allowed:" fragment for the kb_check rules description. */
-export const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers, kb-consistency, kb-consistency-unresolved, evidence-floor, proof-contract-claims";
+export const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, scenario-outcome-mismatch, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers, kb-consistency, kb-consistency-unresolved, evidence-floor, proof-contract-claims";

package/dist/public/operations/specs/check.d.ts

@@ -12,7 +12,7 @@ export declare const checkSpec: {
                     readonly type: "string";
                     readonly enum: readonly string[];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers, kb-consistency, kb-consistency-unresolved, evidence-floor, proof-contract-claims. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, scenario-outcome-mismatch, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers, kb-consistency, kb-consistency-unresolved, evidence-floor, proof-contract-claims. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
             };
             readonly sourceFiles: {
                 readonly type: "array";

package/dist/public/operations/specs/discovery.d.ts

@@ -100,7 +100,7 @@ export declare const querySpec: {
 export declare const searchSpec: {
     readonly name: "kb_search";
     readonly cliName: "search";
-    readonly description: "Ask the KB a question or search it. Default intent-v1 ranking accepts questions, host-agent semantic facets and changed-code source locations, returns evidence, abstains below its confidence threshold and adds an answer layer: the current requirements that govern the topic, what must stay true (linked facts), why (ADRs) and what verifies it (scenarios, tests). Use before changing behavior, then kb_query for exact follow-up. No mutation side effects.";
+    readonly description: "Ask the KB a question or search it. Default intent-v1 ranking accepts questions, host-agent semantic facets and changed-code source locations, returns evidence, abstains below its confidence threshold and adds an answer layer: the current requirements that govern the topic, what must stay true (linked facts), why (ADRs) and what verifies it (scenarios, tests). A weak answer may add queryAnalysis.hints from a search-hints plugin: requirements the question may mean, to re-ask with. Use before changing behavior, then kb_query for exact follow-up. No mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["query"];
@@ -139,6 +139,11 @@ export declare const searchSpec: {
                 readonly default: true;
                 readonly description: "Intent-v1 only, first page only. When true (default) the result includes an answer layer: current governing requirements with their linked facts, scenarios, tests and ADRs, superseded requirements listed separately, and observation facts labelled as notes. Bounded in size; discovery, not proof.";
             };
+            readonly hints: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Intent-v1 only, first page only. When true (default) and the project activates a kibi.search-hints.v1 plugin, a weak or abstained answer adds queryAnalysis.hints: requirements the question may mean, to re-ask with. Hints never change results or the answer layer.";
+            };
             readonly semanticFacets: {
                 readonly type: "object";
                 readonly additionalProperties: false;
@@ -179,7 +184,7 @@ export declare const searchSpec: {
                         readonly maxItems: 20;
                     };
                 };
-                readonly description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; it does not call a model itself.";
+                readonly description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; ranking never calls a model.";
             };
             readonly sourceLocations: {
                 readonly type: "array";

package/dist/public/operations/specs/discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAiCnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6GsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2GuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;;CAWuC,CAAC"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAiCnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6GsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiHuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;;CAWuC,CAAC"}

package/dist/public/operations/specs/discovery.js

@@ -114,7 +114,7 @@ export const querySpec = {
 export const searchSpec = {
     name: "kb_search",
     cliName: "search",
-    description: "Ask the KB a question or search it. Default intent-v1 ranking accepts questions, host-agent semantic facets and changed-code source locations, returns evidence, abstains below its confidence threshold and adds an answer layer: the current requirements that govern the topic, what must stay true (linked facts), why (ADRs) and what verifies it (scenarios, tests). Use before changing behavior, then kb_query for exact follow-up. No mutation side effects.",
+    description: "Ask the KB a question or search it. Default intent-v1 ranking accepts questions, host-agent semantic facets and changed-code source locations, returns evidence, abstains below its confidence threshold and adds an answer layer: the current requirements that govern the topic, what must stay true (linked facts), why (ADRs) and what verifies it (scenarios, tests). A weak answer may add queryAnalysis.hints from a search-hints plugin: requirements the question may mean, to re-ask with. Use before changing behavior, then kb_query for exact follow-up. No mutation side effects.",
     businessInputSchema: {
         type: "object",
         required: ["query"],
@@ -153,6 +153,11 @@ export const searchSpec = {
                 default: true,
                 description: "Intent-v1 only, first page only. When true (default) the result includes an answer layer: current governing requirements with their linked facts, scenarios, tests and ADRs, superseded requirements listed separately, and observation facts labelled as notes. Bounded in size; discovery, not proof.",
             },
+            hints: {
+                type: "boolean",
+                default: true,
+                description: "Intent-v1 only, first page only. When true (default) and the project activates a kibi.search-hints.v1 plugin, a weak or abstained answer adds queryAnalysis.hints: requirements the question may mean, to re-ask with. Hints never change results or the answer layer.",
+            },
             semanticFacets: {
                 type: "object",
                 additionalProperties: false,
@@ -167,7 +172,7 @@ export const searchSpec = {
                     },
                     aliases: { type: "array", items: { type: "string" }, maxItems: 20 },
                 },
-                description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; it does not call a model itself.",
+                description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; ranking never calls a model.",
             },
             sourceLocations: {
                 type: "array",

package/dist/public/operations/specs/mutation-schemas.d.ts

@@ -118,6 +118,16 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
             readonly minLength: 1;
             readonly description: "Requirement-only. Optional reference to the exception's approval decision record.";
         };
+        readonly failure_side_waiver: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Requirement-only. Why the requirement has no failure side to test (its claims state a capability or output shape). Waives happy_path_only once failure_side_waiver_approved_by is set.";
+        };
+        readonly failure_side_waiver_approved_by: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Requirement-only. The person who accepted failure_side_waiver.";
+        };
         readonly firmness: {
             readonly type: "string";
             readonly enum: readonly ["firm", "default", "exploratory"];
@@ -240,6 +250,11 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                             readonly minLength: 1;
                             readonly description: "The name the domain is exported under in the symbol's source file, when the symbol's title is not that name.";
                         };
+                        readonly field: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly description: "exhaustive: when the export is a list of records, the field of each record that names a domain member (a catalog's name).";
+                        };
                     };
                     readonly additionalProperties: false;
                 };
@@ -267,7 +282,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                 };
                 readonly value_source: {
                     readonly type: "array";
-                    readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base. With measure count the value is the size of a list, set, map or object export, so a count claim reads the collection itself. An entry {source, measure: count} counts the members Kibi reads from a project source (routes, tables, environment variables).";
+                    readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base. With measure count the value is the size of a list, set, map or object export, so a count claim reads the collection itself. A dotted export (POLICY.eventLimit) reads one field of an object export. An entry {source, measure: count} counts the members Kibi reads from a project source (routes, tables, environment variables).";
                     readonly minItems: 1;
                     readonly items: {
                         readonly type: "object";
@@ -815,6 +830,26 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
             readonly type: "string";
             readonly description: "Exact atomic requirement clause represented by this fact, retained for human audit. On a grounding fact Kibi derives claim_key from it; an observation or meta fact quotes the clause it is about without a key.";
         };
+        readonly dimension_waiver: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Fact-only. Why the quantifier word in claim_text ranges over nothing, so the claim needs no count, set or rule. Waives dimension_unrepresented once dimension_waiver_approved_by is set.";
+        };
+        readonly dimension_waiver_approved_by: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Fact-only. The person who accepted dimension_waiver.";
+        };
+        readonly case_waiver: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Fact-only. Why the edge cases derived from this fact are covered some other way or cannot occur. Waives uncovered_case once case_waiver_approved_by is set.";
+        };
+        readonly case_waiver_approved_by: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Fact-only. The person who accepted case_waiver.";
+        };
         readonly predicate_name: {
             readonly type: "string";
             readonly description: "Optional predicate name for ontology predicate facts. Prefer kb_model mode predicates before hand-writing predicate_name.";

package/dist/public/operations/specs/mutation-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY,gFASf,CAAC;AAWX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmZ3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAC"}
+{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY,gFASf,CAAC;AAWX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqb3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAC"}