kibi-cli 2.26.3 → 2.28.0

package/dist/public/operations/result-envelope.js

@@ -125,6 +125,8 @@ function extraFailedEffects(declared, data) {
         ];
     });
 }
+/** The envelope error code of a kb_upsert dry run on an invalid payload. */
+export const UPSERT_DRY_RUN_INVALID = "UPSERT_DRY_RUN_INVALID";
 export function resultVersion(spec) {
     return spec.resultVersion ?? `kibi.${spec.name}.v1`;
 }
@@ -141,29 +143,39 @@ export function toKibiResult(spec, data, options = {}) {
     // an error, not a success that needs reconciliation.
     const migrationRefused = row?.version === "kibi.migration-apply-result.v1" &&
         row.outcome === "refused";
+    // implements REQ-kibi-symbol-link-guidance
+    // A kb_upsert dry run that finds the payload invalid reports what the
+    // write would do: refuse it. Its data still carries the errors.
+    const dryRunInvalid = row?.dryRun === true && row.valid === false;
     let status = options.status;
     if (!status) {
         status = "success";
         if (row?.status === "committed_with_repairs")
             status = "committed_with_repairs";
-        if (row?.status === "rejected" || migrationRefused)
+        if (row?.status === "rejected" || migrationRefused || dryRunInvalid)
             status = "error";
     }
-    const terminalError = row?.status === "rejected"
+    const terminalError = dryRunInvalid
         ? {
-            code: "BOOTSTRAP_PLAN_REJECTED",
-            message: "Bootstrap stopped at a deterministic failure. Inspect actionResults for committed actions and re-plan from the current state.",
+            code: UPSERT_DRY_RUN_INVALID,
+            message: `Dry run: kb_upsert would refuse this payload; nothing was written. ${Array.isArray(row.errors) ? row.errors.map(String).join("; ") : ""}`.trim(),
             retryable: false,
         }
-        : migrationRefused
+        : row?.status === "rejected"
             ? {
-                code: MIGRATION_PLAN_REFUSED,
-                message: `Migration plan refused; nothing was changed. ${refusalDetail(row)}`.trim(),
+                code: "BOOTSTRAP_PLAN_REJECTED",
+                message: "Bootstrap stopped at a deterministic failure. Inspect actionResults for committed actions and re-plan from the current state.",
                 retryable: false,
             }
-            : undefined;
+            : migrationRefused
+                ? {
+                    code: MIGRATION_PLAN_REFUSED,
+                    message: `Migration plan refused; nothing was changed. ${refusalDetail(row)}`.trim(),
+                    retryable: false,
+                }
+                : undefined;
     const resultError = options.error ?? terminalError;
-    const outcome = effectOutcome(status, migrationRefused && options.attempted === undefined
+    const outcome = effectOutcome(status, (migrationRefused || dryRunInvalid) && options.attempted === undefined
         ? { ...options, attempted: false }
         : options);
     return {

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

@@ -31,7 +31,7 @@ export declare const checkSpec: {
             };
             readonly includeImpactDiagnostics: {
                 readonly type: "boolean";
-                readonly description: "When true, include changed-file impact diagnostics such as symbol_granularity_violation, symbol_semantic_review_needed and source_file_unowned in structured output.";
+                readonly description: "When true, include changed-file impact diagnostics such as symbol_granularity_violation, symbol_semantic_review_needed, source_file_unowned and requirement_statement_unverified (each current requirement the changed code implements, with its statement and firmness, since the check never compares code with a statement) in structured output.";
             };
             readonly maxDiagnostics: {
                 readonly type: "integer";

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

@@ -30,7 +30,7 @@ export const checkSpec = {
             },
             includeImpactDiagnostics: {
                 type: "boolean",
-                description: "When true, include changed-file impact diagnostics such as symbol_granularity_violation, symbol_semantic_review_needed and source_file_unowned in structured output.",
+                description: "When true, include changed-file impact diagnostics such as symbol_granularity_violation, symbol_semantic_review_needed, source_file_unowned and requirement_statement_unverified (each current requirement the changed code implements, with its statement and firmness, since the check never compares code with a statement) in structured output.",
             },
             maxDiagnostics: {
                 type: "integer",

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

@@ -8,7 +8,7 @@ export { executeCompileIntent } from "../../../operations/planning/compile-inten
 export declare const compileIntentSpec: {
     readonly name: "kb_compile_intent";
     readonly cliName: "compile-intent";
-    readonly description: "Compile complete change intent into a deterministic, snapshot-bound read-only plan. Reuses intent-aware discovery and semantic modeling, accounts for every proposition, reports contradiction witnesses, proposes traceability links, and emits dependency-ordered kb_upsert-style steps only for resolved typed claims. No mutation side effects.";
+    readonly description: "Compile complete change intent into a deterministic, snapshot-bound read-only plan. Reuses intent-aware discovery and semantic modeling, accounts for every proposition, reports contradiction witnesses, proposes traceability links, and emits dependency-ordered kb_upsert-style steps only for resolved typed claims. contradictionAnalysis.outcome is no_conflict only when the check could decide: an unmodeled proposition or a related current requirement without logic leaves it unresolved with reasons and reviewCandidates to compare and judge through conflictReviews. No mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["intent", "mode"];
@@ -234,6 +234,30 @@ export declare const compileIntentSpec: {
                 };
                 readonly description: "Explicit decisions for deterministic traceability proposals. Pending proposals never enter steps.";
             };
+            readonly conflictReviews: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["requirementId", "verdict"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly requirementId: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly verdict: {
+                            readonly type: "string";
+                            readonly enum: readonly ["conflict", "no_conflict"];
+                        };
+                        readonly note: {
+                            readonly type: "string";
+                            readonly maxLength: 2000;
+                        };
+                    };
+                };
+                readonly description: "Your verdict on each contradictionAnalysis.reviewCandidates entry of a previous compile: whether the intent contradicts that current requirement, which Kibi could not compare logically. A conflict verdict blocks the plan; a no_conflict verdict clears that candidate. A verdict may also name a current requirement discovery did not rank.";
+            };
         };
     };
     readonly requiresProlog: true;

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

@@ -1 +1 @@
-{"version":3,"file":"planning.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/planning.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,gBAAgB,EACjB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAGL,oBAAoB,EACrB,MAAM,gDAAgD,CAAC;AAGxD,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,oBAAoB,GACrB,MAAM,gDAAgD,CAAC;AACxD,YAAY,EACV,aAAa,EACb,eAAe,GAChB,MAAM,4CAA4C,CAAC;AACpD,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AAGtF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4KsC,CAAC;AAGrE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DwC,CAAC"}
+{"version":3,"file":"planning.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/planning.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,gBAAgB,EACjB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAGL,oBAAoB,EACrB,MAAM,gDAAgD,CAAC;AAGxD,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,oBAAoB,GACrB,MAAM,gDAAgD,CAAC;AACxD,YAAY,EACV,aAAa,EACb,eAAe,GAChB,MAAM,4CAA4C,CAAC;AACpD,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AAGtF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4LsC,CAAC;AAGrE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DwC,CAAC"}

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

@@ -6,7 +6,7 @@ export { executeCompileIntent } from "../../../operations/planning/compile-inten
 export const compileIntentSpec = {
     name: "kb_compile_intent",
     cliName: "compile-intent",
-    description: "Compile complete change intent into a deterministic, snapshot-bound read-only plan. Reuses intent-aware discovery and semantic modeling, accounts for every proposition, reports contradiction witnesses, proposes traceability links, and emits dependency-ordered kb_upsert-style steps only for resolved typed claims. No mutation side effects.",
+    description: "Compile complete change intent into a deterministic, snapshot-bound read-only plan. Reuses intent-aware discovery and semantic modeling, accounts for every proposition, reports contradiction witnesses, proposes traceability links, and emits dependency-ordered kb_upsert-style steps only for resolved typed claims. contradictionAnalysis.outcome is no_conflict only when the check could decide: an unmodeled proposition or a related current requirement without logic leaves it unresolved with reasons and reviewCandidates to compare and judge through conflictReviews. No mutation side effects.",
     businessInputSchema: {
         type: "object",
         required: ["intent", "mode"],
@@ -154,6 +154,21 @@ export const compileIntentSpec = {
                 },
                 description: "Explicit decisions for deterministic traceability proposals. Pending proposals never enter steps.",
             },
+            conflictReviews: {
+                type: "array",
+                maxItems: 20,
+                items: {
+                    type: "object",
+                    required: ["requirementId", "verdict"],
+                    additionalProperties: false,
+                    properties: {
+                        requirementId: { type: "string", minLength: 1 },
+                        verdict: { type: "string", enum: ["conflict", "no_conflict"] },
+                        note: { type: "string", maxLength: 2000 },
+                    },
+                },
+                description: "Your verdict on each contradictionAnalysis.reviewCandidates entry of a previous compile: whether the intent contradicts that current requirement, which Kibi could not compare logically. A conflict verdict blocks the plan; a no_conflict verdict clears that candidate. A verdict may also name a current requirement discovery did not rank.",
+            },
         },
     },
     requiresProlog: true,

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

@@ -2,7 +2,7 @@
 id: kibi-bootstrap
 name: kibi-bootstrap
 description: "Use for any Kibi bootstrap or onboarding task: seeding a new or thin knowledge base; reviewing a bootstrap or onboarding plan, preview, or evidence; judging approval readiness or coverage; diagnosing a blocked, partial, or failed bootstrap or its repair; applying an approved bootstrap plan; or asking the human which knowledge sources hold intent. Covers kb_status first, source interview, cited intent claims, read-only kb_plan_bootstrap preview, explicit approval, exact-plan kb_apply_plan, and repair-safe close-out."
-version: 3.14.0
+version: 3.16.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -37,7 +37,7 @@ Seed branch-local Kibi knowledge from cited product intent, without creating a p
 3. **Declare** `bootstrapContext`: `projectSummary`; `knowledgeSources` (id, kind, title, locator, authority, optional connector, optional `component`); `intentClaims` (statement, sourceId, reference, `excerpt` required for `intent` and `observation` claims and optional for `open_question`, optional `kind`, default `intent`, optional `component` overriding the source's, optional `rationale` with the reason the source or the human gave, never invented); `conflicts` (`claimReferences` naming two or more declared claims by sourceId and reference, plus a one-sentence `note`). Only intent claims can become requirements, and they are recorded as the people's rules: `origin.kind: import` with `sourceId:reference` as `origin.ref`, and `firmness: firm`, so a later agent asks before changing one (normative lines from repository Markdown get the same, citing `path#Lline`). Observations, open questions (tagged `review:open-question`) and conflicts (tagged `review:conflict`) become cited observation facts. Generated subject keys take the shape `component.aspect`: name the component each source or claim is about (for example `recorder`; set `component` on the knowledge source, or on a claim to override it; repository Markdown takes its file or directory name), because an intent claim whose subject is neither one word nor already dotted, with no component, is reported in the plan diagnostics and left as an authoring follow-up instead of a malformed key. The aspect is the claim's subject, or its constrained property when the subject is the component itself. An aspect over four words or 40 characters is shortened to a noun phrase (words before `when`, `while`, `for`, `and`, ...; `support_inbox.update_in_real_time_when_a_new_ticket_is_assigned...` becomes `support_inbox.update_in_real_time`) and reported as `subject-key-shortened:` with both keys; two different subjects that shorten alike get a third segment (`editor.discard_a_draft.leaving`) and a `subject-key-disambiguated:` diagnostic; claims about one subject share one subject fact, and a `subject-key-shared:` diagnostic names the key and its sources. Show these diagnostics to the human with the plan so they can rename a key before approval. Kibi never contacts these sources. It binds your declaration into the plan hash.
 4. **Preview** with `kb_plan_bootstrap` (or `plan-bootstrap --input`), read-only. On `needs_context`, ask only its bounded questions (four at most), then preview again. When `pluginOffers` is non-empty (for example `kibi-plugin-ui` because UI component files exist), ask the human once whether to enable each offered plugin, naming its evidence files. On yes, install it as a dev dependency and add it to `package.json` `kibi.plugins` with the offered capability in `augment` mode; on no, add its name to `kibi.declinedPlugins` so it is not offered again. Either way the human decides; never enable a plugin unasked. For `kibi-plugin-ui`, step 11 also captures the UI pattern inventory (see `kibi-usage` `resources/ui-requirements.md`).
 5. **Narrow with filters, not caps.** Read the `tldr` and the `Suppressed candidates by reason` diagnostic before individual rows. If the output is too large or mostly tooling or metadata, re-preview with `entityTypes` or declared `sourceOfTruthPaths`. Generic Markdown is off by default once you declare intent claims; set `includeGenericMarkdown: true` only for repository docs the human named. Keep confirmed intent claims: they are never capped and never use `maxCandidates`, which is the separate budget for candidates Kibi discovers (symbols, tests, repository docs). Raise it only when discovered candidates you need are `over_limit`, and never for provenance stubs: a provider entry with no claim (`Source module: …`, repository metadata, layout roots) is planned last as a `meta` fact tagged `bootstrap:provenance-stub`, `discoverySummary.provenanceStubs` counts them apart from `candidatesWithClaims`, and the `over_limit` diagnostic says how many suppressed candidates are stubs; they add no knowledge, so a plan that is mostly stubs needs `entityTypes` or declared sources, not a higher cap. Read the per-source `Knowledge source …` diagnostics: each splits the claims not planned by reason (suppressed by the activation mode, a `suppressedCandidates` row, a `sourceOnlySignals` follow-up). Report them per source and restate them before approval, or carry them to step 11 with their citation.
-6. **Request approval.** Show the complete `structuredContent.plan`, the full hash (never abbreviated), which candidates cite which sources, what was omitted, the open questions and declared conflicts it records for the human to decide, and any claim that contradicts code. If you find an undeclared contradiction now, add it to `conflicts` and preview again rather than resolving it. With no answer, stop as "awaiting approval." If declined, replan and ask again with the new hash.
+6. **Request approval.** Show the complete `structuredContent.plan`, the full hash (never abbreviated), which candidates cite which sources, what was omitted, the open questions and declared conflicts it records for the human to decide, and any claim that contradicts code. If you find an undeclared contradiction now, add it to `conflicts` and preview again rather than resolving it. A `conflict-review:` diagnostic (and `review_against:<id>` evidence on the candidate) names current requirements Kibi could not check a planned claim against because they have no logic: compare each pair yourself and show any contradiction to the human with the plan; they decide whether to drop the claim or keep it and supersede the requirement after apply. A claim left for authoring gets the same diagnostic (and `review_against:<id>` evidence on its follow-up): when you compile it with `kb_compile_intent` in step 11, compare it with the named requirements and send your verdicts in `conflictReviews`. With no answer, stop as "awaiting approval." If declined, replan and ask again with the new hash.
 7. **Pre-apply check.** The plan you send must equal the returned plan: every top-level field, including `suppressedCandidates`, `diagnostics`, `candidates`, `actions`, and `expected`, with every array the same length and order. Never rebuild it from preview fields. If the host cannot pass the exact object, stop and say so.
 8. **Apply once** with `kb_apply_plan`, the exact plan, and `approvedPlanHash`. The operation owns dependency ordering, source-first writes, sequential mutation, and recovery journaling. A plan with hundreds of actions can run for minutes: pass a `progressToken` (Kibi sends progress after each action) with a client that resets its timeout on progress, or pass `async: true` and poll `kb_job_status` when the host has it. If the apply is cut off, call `kb_apply_plan` with only the `recoveryJournalId` from `kb_status` or the error; it resumes an action interrupted mid-write and reclaims a lock left by a dead process. Never edit or delete `.kb/recovery` files; if recovery is refused, stop and report it.
 9. **Read back** with `kb_query` and `kb_search` to confirm writes and citations.

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.19.0
+version: 2.20.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -410,6 +410,16 @@ Conditional clauses ("only when", "only if", "must not ... unless") compile
 into typed `forbid` rules linked by `requires_rule`, not property facts; one
 `kb_model` or `kb_compile_intent` cannot translate stays an `ontology_gap`.
 
+`kb_compile_intent` reports `contradictionAnalysis.outcome: no_conflict` only
+when it could check: Prolog compares only requirements with logic links. When
+the intent is unmodeled or a related current requirement is prose only, the
+outcome is `unresolved` with `reasons` and up to five `reviewCandidates`. Never
+read `unresolved` as consistent. Compare the intent with each candidate's
+`statement`, then compile again with `conflictReviews`
+(`{requirementId, verdict: "conflict" | "no_conflict", note}`). On a conflict
+the plan is `blocked`: ask the human which rule holds (a firm requirement is
+theirs), then supersede or change it, or change the intent.
+
 ## Semantic and proof guardrails
 
 Prolog proves only encoded facts. Keep ambiguity, ontology gaps, incomplete

package/dist/public/symbol-granularity.d.ts

@@ -16,6 +16,11 @@ export declare function isAllowedGranularityReason(value: unknown): value is Gra
 export declare function isCoarseGranularityReason(value: unknown): value is CoarseGranularityReason;
 export declare function getSymbolRole(candidate: GranularSymbolCandidate): SymbolRole;
 export declare function isBehavioralSymbol(candidate: GranularSymbolCandidate): boolean;
+/**
+ * The behavioral candidates' names, the place a coarse link should move to:
+ * functions, methods and accessors first, then properties (behavioral in the
+ * schema, but usually plain fields), each group sorted by name.
+ */
 export declare function getBehavioralSymbolNames(candidates: GranularSymbolCandidate[]): string[];
 /**
  * The candidates that are narrower than a manifest symbol: members of it

package/dist/public/symbol-granularity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-granularity.d.ts","sourceRoot":"","sources":["../../src/public/symbol-granularity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,0BAA0B,EAC1B,wCAAwC,EACxC,gCAAgC,EAChC,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,cAAc,EACd,YAAY,EACZ,KAAK,UAAU,EACf,+BAA+B,EAC/B,KAAK,4BAA4B,EAClC,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,0BAA0B,EAC1B,wCAAwC,EACxC,gCAAgC,EAChC,cAAc,EACd,YAAY,EACZ,+BAA+B,GAChC,CAAC;AACF,YAAY,EACV,uBAAuB,EACvB,iBAAiB,EACjB,UAAU,EACV,4BAA4B,GAC7B,MAAM,mCAAmC,CAAC;AAE3C,MAAM,MAAM,UAAU,GAClB,UAAU,GACV,OAAO,GACP,QAAQ,GACR,UAAU,GACV,UAAU,GACV,WAAW,GACX,MAAM,GACN,UAAU,GACV,MAAM,GACN,SAAS,CAAC;AAEd,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC;AAE1C,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAYD,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAE5D;AAED,eAAO,MAAM,uBAAuB,wBAAkB,CAAC;AAEvD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAIhE;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,4BAA4B,CAIvC;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,iBAAiB,CAE5B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,uBAAuB,CAElC;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,uBAAuB,GAAG,UAAU,CAI5E;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,uBAAuB,GACjC,OAAO,CAET;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,uBAAuB,EAAE,GACpC,MAAM,EAAE,CAMV;AAED;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EACxD,kBAAkB,EAAE,MAAM,EAC1B,UAAU,EAAE,SAAS,CAAC,EAAE,EACxB,aAAa,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,GACzC,CAAC,EAAE,CASL;AAED;;;;;GAKG;AAEH,wBAAgB,yBAAyB,CACvC,kBAAkB,EAAE,MAAM,EAC1B,aAAa,EAAE,SAAS,uBAAuB,EAAE,GAChD,MAAM,EAAE,CAIV;AAED,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,uBAAuB,EAAE,GACpC,MAAM,EAAE,CAQV"}
+{"version":3,"file":"symbol-granularity.d.ts","sourceRoot":"","sources":["../../src/public/symbol-granularity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,0BAA0B,EAC1B,wCAAwC,EACxC,gCAAgC,EAChC,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,cAAc,EACd,YAAY,EACZ,KAAK,UAAU,EACf,+BAA+B,EAC/B,KAAK,4BAA4B,EAClC,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,0BAA0B,EAC1B,wCAAwC,EACxC,gCAAgC,EAChC,cAAc,EACd,YAAY,EACZ,+BAA+B,GAChC,CAAC;AACF,YAAY,EACV,uBAAuB,EACvB,iBAAiB,EACjB,UAAU,EACV,4BAA4B,GAC7B,MAAM,mCAAmC,CAAC;AAE3C,MAAM,MAAM,UAAU,GAClB,UAAU,GACV,OAAO,GACP,QAAQ,GACR,UAAU,GACV,UAAU,GACV,WAAW,GACX,MAAM,GACN,UAAU,GACV,MAAM,GACN,SAAS,CAAC;AAEd,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC;AAE1C,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAYD,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAE5D;AAED,eAAO,MAAM,uBAAuB,wBAAkB,CAAC;AAEvD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAIhE;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,4BAA4B,CAIvC;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,iBAAiB,CAE5B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,uBAAuB,CAElC;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,uBAAuB,GAAG,UAAU,CAI5E;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,uBAAuB,GACjC,OAAO,CAET;AAED;;;;GAIG;AAEH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,uBAAuB,EAAE,GACpC,MAAM,EAAE,CAQV;AAED;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EACxD,kBAAkB,EAAE,MAAM,EAC1B,UAAU,EAAE,SAAS,CAAC,EAAE,EACxB,aAAa,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,GACzC,CAAC,EAAE,CASL;AAED;;;;;GAKG;AAEH,wBAAgB,yBAAyB,CACvC,kBAAkB,EAAE,MAAM,EAC1B,aAAa,EAAE,SAAS,uBAAuB,EAAE,GAChD,MAAM,EAAE,CAIV;AAED,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,uBAAuB,EAAE,GACpC,MAAM,EAAE,CAQV"}

package/dist/public/symbol-granularity.js

@@ -32,10 +32,19 @@ export function getSymbolRole(candidate) {
 export function isBehavioralSymbol(candidate) {
     return getSymbolRole(candidate) === "behavioral";
 }
+/**
+ * The behavioral candidates' names, the place a coarse link should move to:
+ * functions, methods and accessors first, then properties (behavioral in the
+ * schema, but usually plain fields), each group sorted by name.
+ */
+// implements REQ-kibi-symbol-link-guidance
 export function getBehavioralSymbolNames(candidates) {
-    return [
-        ...new Set(candidates.filter(isBehavioralSymbol).map((candidate) => candidate.name)),
-    ].sort();
+    const behavioral = candidates.filter(isBehavioralSymbol);
+    const names = (properties) => behavioral
+        .filter((candidate) => (candidate.kind === "property") === properties)
+        .map((candidate) => candidate.name)
+        .sort();
+    return [...new Set([...names(false), ...names(true)])];
 }
 /**
  * The candidates that are narrower than a manifest symbol: members of it

package/dist/traceability/staged-consistency.d.ts

@@ -20,6 +20,6 @@ export declare function stagesKnowledge(paths: readonly string[]): boolean;
  */
 export declare function collectIntroducedConsistencyViolations(snapshot: SnapshotReader, headKnowledge: ExtractionResult[]): Promise<Violation[]>;
 /** Text lines for introduced consistency violations, in `kibi check` form. */
-export declare function formatConsistencyViolations(violations: readonly Violation[]): string[];
+export declare function formatConsistencyViolations(violations: readonly Violation[], kind?: string): string[];
 export {};
 //# sourceMappingURL=staged-consistency.d.ts.map

package/dist/traceability/staged-consistency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staged-consistency.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-consistency.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAsB1D,KAAK,cAAc,GAAG,QAAQ,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;IACzC,SAAS,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjE,CAAC,CAAC;AAEH;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAMjE;AAkDD;;;;;GAKG;AAEH,wBAAsB,sCAAsC,CAC1D,QAAQ,EAAE,cAAc,EACxB,aAAa,EAAE,gBAAgB,EAAE,GAChC,OAAO,CAAC,SAAS,EAAE,CAAC,CAYtB;AAED,8EAA8E;AAE9E,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,SAAS,SAAS,EAAE,GAC/B,MAAM,EAAE,CAWV"}
+{"version":3,"file":"staged-consistency.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-consistency.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAsB1D,KAAK,cAAc,GAAG,QAAQ,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;IACzC,SAAS,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjE,CAAC,CAAC;AAEH;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAMjE;AAkDD;;;;;GAKG;AAEH,wBAAsB,sCAAsC,CAC1D,QAAQ,EAAE,cAAc,EACxB,aAAa,EAAE,gBAAgB,EAAE,GAChC,OAAO,CAAC,SAAS,EAAE,CAAC,CAYtB;AAED,8EAA8E;AAE9E,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,SAAS,SAAS,EAAE,EAChC,IAAI,SAAgB,GACnB,MAAM,EAAE,CAWV"}

package/dist/traceability/staged-consistency.js

@@ -77,9 +77,9 @@ export async function collectIntroducedConsistencyViolations(snapshot, headKnowl
 }
 /** Text lines for introduced consistency violations, in `kibi check` form. */
 // implements REQ-cli-staged-consistency
-export function formatConsistencyViolations(violations) {
+export function formatConsistencyViolations(violations, kind = "consistency") {
     const lines = [
-        `Found ${violations.length} consistency violation(s) introduced by the staged changes:`,
+        `Found ${violations.length} ${kind} violation(s) introduced by the staged changes:`,
         "",
     ];
     for (const violation of violations) {

package/dist/traceability/staged-diagnostics.d.ts

@@ -1,6 +1,6 @@
 import type { QualityDiagnostic } from "../public/impact/types.js";
 import { type KibiImpactEvidence } from "./evidence-model.js";
-export type KibiImpactDiagnosticId = "kibi_impact_evidence_missing" | "symbols_manifest_stale" | "symbol_granularity_violation" | "symbol_semantic_review_needed" | "source_file_unowned" | "multi_requirement_symbol_review" | "duplicate_symbol_coordinate_review" | "component_mixed_purpose_review" | "broad_requirement_review" | "requirement_status_review" | "strict_fact_modeling_review" | "logical_coverage_review" | "kibi_impact_override_missing_rationale" | "entity_id_style_review";
+export type KibiImpactDiagnosticId = "kibi_impact_evidence_missing" | "symbols_manifest_stale" | "symbol_granularity_violation" | "symbol_semantic_review_needed" | "source_file_unowned" | "requirement_statement_unverified" | "multi_requirement_symbol_review" | "duplicate_symbol_coordinate_review" | "component_mixed_purpose_review" | "broad_requirement_review" | "requirement_status_review" | "strict_fact_modeling_review" | "logical_coverage_review" | "kibi_impact_override_missing_rationale" | "entity_id_style_review";
 export interface KibiImpactDiagnostic extends QualityDiagnostic {
     /** Stable staged-enforcement diagnostic identifier. */
     id: KibiImpactDiagnosticId;

package/dist/traceability/staged-diagnostics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staged-diagnostics.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-diagnostics.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAGL,KAAK,kBAAkB,EAKxB,MAAM,qBAAqB,CAAC;AAQ7B,MAAM,MAAM,sBAAsB,GAC9B,8BAA8B,GAC9B,wBAAwB,GACxB,8BAA8B,GAC9B,+BAA+B,GAC/B,qBAAqB,GACrB,iCAAiC,GACjC,oCAAoC,GACpC,gCAAgC,GAChC,0BAA0B,GAC1B,2BAA2B,GAC3B,6BAA6B,GAC7B,yBAAyB,GACzB,wCAAwC,GACxC,wBAAwB,CAAC;AAE7B,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D,uDAAuD;IACvD,EAAE,EAAE,sBAAsB,CAAC;IAC3B,QAAQ,EAAE,iBAAiB,CAAC,UAAU,CAAC,CAAC;IACxC,iEAAiE;IACjE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,gDAAgD;IAChD,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B;AAsID,wBAAgB,wCAAwC,CACtD,QAAQ,EAAE,kBAAkB,GAC3B,oBAAoB,CAoBtB;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,kBAAkB,EAC5B,mBAAmB,GAAE,MAAmC,GACvD,oBAAoB,EAAE,CAiDxB"}
+{"version":3,"file":"staged-diagnostics.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-diagnostics.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAGL,KAAK,kBAAkB,EAKxB,MAAM,qBAAqB,CAAC;AAQ7B,MAAM,MAAM,sBAAsB,GAC9B,8BAA8B,GAC9B,wBAAwB,GACxB,8BAA8B,GAC9B,+BAA+B,GAC/B,qBAAqB,GACrB,kCAAkC,GAClC,iCAAiC,GACjC,oCAAoC,GACpC,gCAAgC,GAChC,0BAA0B,GAC1B,2BAA2B,GAC3B,6BAA6B,GAC7B,yBAAyB,GACzB,wCAAwC,GACxC,wBAAwB,CAAC;AAE7B,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D,uDAAuD;IACvD,EAAE,EAAE,sBAAsB,CAAC;IAC3B,QAAQ,EAAE,iBAAiB,CAAC,UAAU,CAAC,CAAC;IACxC,iEAAiE;IACjE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,gDAAgD;IAChD,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B;AAsID,wBAAgB,wCAAwC,CACtD,QAAQ,EAAE,kBAAkB,GAC3B,oBAAoB,CAoBtB;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,kBAAkB,EAC5B,mBAAmB,GAAE,MAAmC,GACvD,oBAAoB,EAAE,CAiDxB"}

package/dist/traceability/staged-entity-context.d.ts

@@ -0,0 +1,18 @@
+import type { ExtractionResult } from "../extractors/markdown.js";
+import type { Violation } from "../public/check-types.js";
+type TreeReader = Readonly<{
+    baseTree: string;
+    headTree: string;
+    readGit(args: readonly string[]): Buffer;
+}>;
+/**
+ * entity-context-missing findings on the entity documents a commit stages,
+ * that the same documents did not have at the base tree. The rule reads only
+ * the entity file, so no projection is needed. A document whose entity
+ * already lacked context at the base (legacy debt, or one the migration
+ * acknowledged) does not block the commit; full `kibi check` still reports
+ * it.
+ */
+export declare function collectIntroducedEntityContextViolations(snapshot: TreeReader, stagedPaths: readonly string[], headKnowledge: readonly ExtractionResult[]): Violation[];
+export {};
+//# sourceMappingURL=staged-entity-context.d.ts.map

package/dist/traceability/staged-entity-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staged-entity-context.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-entity-context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAO1D,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;CAC1C,CAAC,CAAC;AA8CH;;;;;;;GAOG;AAEH,wBAAgB,wCAAwC,CACtD,QAAQ,EAAE,UAAU,EACpB,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,aAAa,EAAE,SAAS,gBAAgB,EAAE,GACzC,SAAS,EAAE,CA8Bb"}

package/dist/traceability/staged-entity-context.js

@@ -0,0 +1,66 @@
+import { CONTEXT_REQUIRED_TYPES } from "../entity-body-context.js";
+import { ENTITY_CONTEXT_MISSING_RULE, evaluateEntityContext, readAuthoredEntity, } from "../public/operations/entity-context.js";
+function readTreeFile(snapshot, tree, file) {
+    try {
+        return snapshot.readGit(["show", `${tree}:${file}`]).toString("utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The ids the schema 8 body-context migration acknowledged, from the KB
+ * manifest of one tree: they stay exempt, so a migration commit passes.
+ */
+// implements REQ-cli-staged-entity-context
+function acknowledgedIds(snapshot, tree) {
+    const text = readTreeFile(snapshot, tree, ".kb/manifest.json");
+    if (text === null)
+        return new Set();
+    try {
+        const parsed = JSON.parse(text);
+        return new Set(Array.isArray(parsed.contextAcknowledged)
+            ? parsed.contextAcknowledged.filter((id) => typeof id === "string")
+            : []);
+    }
+    catch {
+        return new Set();
+    }
+}
+/** Ids another entity supersedes in the given compiled knowledge. */
+// implements REQ-cli-staged-entity-context
+function supersededIds(knowledge) {
+    const superseded = new Set();
+    for (const result of knowledge)
+        for (const relationship of result.relationships)
+            if (relationship.type === "supersedes")
+                superseded.add(relationship.to);
+    return superseded;
+}
+/**
+ * entity-context-missing findings on the entity documents a commit stages,
+ * that the same documents did not have at the base tree. The rule reads only
+ * the entity file, so no projection is needed. A document whose entity
+ * already lacked context at the base (legacy debt, or one the migration
+ * acknowledged) does not block the commit; full `kibi check` still reports
+ * it.
+ */
+// implements REQ-cli-staged-entity-context
+export function collectIntroducedEntityContextViolations(snapshot, stagedPaths, headKnowledge) {
+    const rules = new Set([ENTITY_CONTEXT_MISSING_RULE]);
+    const read = (tree) => stagedPaths.flatMap((file) => {
+        const content = readTreeFile(snapshot, tree, file);
+        const entity = content === null ? null : readAuthoredEntity(content, file);
+        return entity !== null &&
+            CONTEXT_REQUIRED_TYPES.includes(entity.type)
+            ? [entity]
+            : [];
+    });
+    const head = evaluateEntityContext(read(snapshot.headTree), supersededIds(headKnowledge), rules, acknowledgedIds(snapshot, snapshot.headTree));
+    if (head.length === 0)
+        return [];
+    // Without the base tree's supersessions the base reports at least what it
+    // had, so a finding the base already carried never blocks.
+    const base = new Set(evaluateEntityContext(read(snapshot.baseTree), new Set(), rules, acknowledgedIds(snapshot, snapshot.baseTree)).map((violation) => violation.entityId));
+    return head.filter((violation) => !base.has(violation.entityId));
+}

package/dist/utils/config.d.ts

@@ -35,6 +35,14 @@ export interface LegacyKbConfig {
     checks?: unknown;
     defaultBranch?: string;
 }
+/**
+ * The first step on a workspace with a legacy `.kb/config.json` and no
+ * manifest. Doctor and kb_status both name it, so they never disagree on
+ * what to run first: `kibi init` would claim the latest schema and skip the
+ * legacy migration steps.
+ */
+export declare const LEGACY_KB_MIGRATION_COMMAND = "kibi migrate --yes";
+export declare const LEGACY_KB_MIGRATION_NOTE = "it creates the manifest from the legacy .kb/config.json; do not run kibi init first";
 /** Whether a legacy `.kb/config.json` exists at the workspace root. */
 export declare function legacyConfigExists(cwd: string): boolean;
 /**

package/dist/utils/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/utils/config.ts"],"names":[],"mappings":"AAoBA,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,eAAe,CAAC;AAEvB;;;;;;GAMG;AAEH,YAAY,EAAE,aAAa,EAAE,CAAC;AAE9B,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB,EAAE,aAAsC,CAAC;AAE1E;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,GAAE,MAAsB,GAAG,aAAa,CAE3E;AAED,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,+EAA+E;AAC/E,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,wDAAwD;IACxD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,uBAAuB,CAAC,EAAE,SAAS,GAAG,WAAW,GAAG,gBAAgB,CAAC;IACrE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAcD,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,GAET;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,cAAc,CAAA;CAAE,CAqE9C;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,cAAc,GAAG,SAAS,GACjC,aAAa,CAwBf"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/utils/config.ts"],"names":[],"mappings":"AAoBA,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,eAAe,CAAC;AAEvB;;;;;;GAMG;AAEH,YAAY,EAAE,aAAa,EAAE,CAAC;AAE9B,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB,EAAE,aAAsC,CAAC;AAE1E;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,GAAE,MAAsB,GAAG,aAAa,CAE3E;AAED,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,+EAA+E;AAC/E,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,wDAAwD;IACxD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,uBAAuB,CAAC,EAAE,SAAS,GAAG,WAAW,GAAG,gBAAgB,CAAC;IACrE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAcD;;;;;GAKG;AAEH,eAAO,MAAM,2BAA2B,uBAAuB,CAAC;AAEhE,eAAO,MAAM,wBAAwB,wFACkD,CAAC;AAExF,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,GAET;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,cAAc,CAAA;CAAE,CAqE9C;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,cAAc,GAAG,SAAS,GACjC,aAAa,CAwBf"}

package/dist/utils/config.js

@@ -34,6 +34,16 @@ function pickLegacyPathValue(paths, key) {
     const value = paths[key];
     return typeof value === "string" ? value : undefined;
 }
+/**
+ * The first step on a workspace with a legacy `.kb/config.json` and no
+ * manifest. Doctor and kb_status both name it, so they never disagree on
+ * what to run first: `kibi init` would claim the latest schema and skip the
+ * legacy migration steps.
+ */
+// implements REQ-legacy-kb-first-step-migrate
+export const LEGACY_KB_MIGRATION_COMMAND = "kibi migrate --yes";
+// implements REQ-legacy-kb-first-step-migrate
+export const LEGACY_KB_MIGRATION_NOTE = "it creates the manifest from the legacy .kb/config.json; do not run kibi init first";
 /** Whether a legacy `.kb/config.json` exists at the workspace root. */
 export function legacyConfigExists(cwd) {
     return existsSync(path.join(cwd, ".kb", "config.json"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.26.3",
+  "version": "2.28.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.22.2",
+    "kibi-core": "^0.22.3",
     "kibi-plugin-builtin": "^0.5.2",
     "kibi-plugin-sdk": "^0.5.0",
     "kibi-swipl": "^1.0.1",

package/src/public/impact/analyzer.ts

@@ -20,6 +20,11 @@ import {
   createImpactManifestLookup,
   readImpactManifestResults,
 } from "./manifest.js";
+import {
+  createRequirementStatementDiagnostics,
+  readWorkspaceRequirement,
+  workspaceFileChanged,
+} from "./requirement-statements.js";
 import { normalizeSourceFile } from "./source-changes.js";
 import { collectSourceChanges, uniqueSorted } from "./source-changes.js";
 import {
@@ -34,6 +39,14 @@ import type {
 } from "./types.js";
 import { createUnownedFileDiagnostics } from "./unowned-files.js";
 
+/** The workspace-relative document a requirement was read from. */
+function requirementSourcePath(requirement: { id: string; source: string }) {
+  const source = requirement.source;
+  return source && !source.includes("://")
+    ? source.replace(/^\.\//, "")
+    : `.kb/requirements/${requirement.id}.md`;
+}
+
 export async function analyzeChangedFileImpact(
   options: ChangedFileImpactOptions,
 ): Promise<ChangedFileImpactResult> {
@@ -88,12 +101,15 @@ export async function analyzeChangedFileImpact(
           .map((file) => file.path)
       : sourceChanges.map((change) => change.file),
   );
-  const manifestResults = snapshot
+  const snapshotKnowledge = snapshot
     ? readSnapshotKnowledge(
         snapshot.readGit,
         snapshot.headTree,
         snapshot.readBlobs,
-      ).filter((result) => result.entity.type === "symbol")
+      )
+    : undefined;
+  const manifestResults = snapshotKnowledge
+    ? snapshotKnowledge.filter((result) => result.entity.type === "symbol")
     : readImpactManifestResults(workspaceRoot);
   const manifestLookup = createImpactManifestLookup(manifestResults);
   const symbolsByFile = new Map<string, ExtractedSymbol[]>();
@@ -161,6 +177,26 @@ export async function analyzeChangedFileImpact(
             requestedFiles: [...filter],
             linkedSourceFiles,
           }),
+          // What the changed code is meant to do, quoted, before the
+          // structural findings: "no violations" never compared it.
+          ...createRequirementStatementDiagnostics({
+            workspaceRoot,
+            symbolsByFile,
+            readRequirement: (id) =>
+              snapshotKnowledge
+                ? snapshotKnowledge.find((result) => result.entity.id === id)
+                    ?.entity
+                : readWorkspaceRequirement(workspaceRoot, id),
+            requirementChanged: (requirement) =>
+              snapshot
+                ? snapshot.inventory.some(
+                    (file) => file.path === requirementSourcePath(requirement),
+                  )
+                : workspaceFileChanged(
+                    workspaceRoot,
+                    requirementSourcePath(requirement),
+                  ),
+          }),
           ...createSymbolGranularityDiagnostics({
             manifestResults: activeManifestResults,
             symbolsByFile,