kibi-cli 2.22.1 → 2.24.0

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

@@ -2,7 +2,7 @@
 id: kibi-usage
 name: Kibi Usage
 description: Use Kibi's source-first, exact-Git, migration-aware, proof-aware operations safely across MCP or the trusted local CLI, including partial completion repair.
-version: 2.16.1
+version: 2.17.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -92,10 +92,12 @@ it is a pointer to the knowledge, never proof. Each line answers one question:
 - `Kibi knowledge for <path> (symbol manifest):` and the `- REQ-… — <symbol
   titles>` rows: the requirements the file's symbols implement, lead
   requirement first. Read the lead requirement with `kb_query({id})` before
-  changing behavior.
+  changing behavior; add `includeBody: true` to see its authored prose, and
+  fix a stale sentence there with `kb_upsert` `document.body`.
 - `REQ-… must keep true: FACT-…` (edit only): the ground facts the lead
   requirement requires. An edit that breaks one of them is a requirement
-  change: supersede and remodel the requirement, do not code around the fact.
+  change: ask before changing the rule (see Decision firmness), and never
+  code around the fact.
 - `Decision: ADR-…` (edit only): the decision behind the lead requirement.
 - `Covered by: TEST-…` and `Test code for: …`: the tests that prove the
   file's symbols; run or update them with the edit.
@@ -358,24 +360,40 @@ exists in `rationale`, or link the ADR that explains it.
 
 Requirements and ADRs carry `firmness`, which says what you may do with them.
 Search answers, `kb_query` rows and hook snippets show it (snippets label only
-`[firm]` and `[exploratory]`; an unlabeled decision is `default`).
+`[firm: ask before changing]` and `[exploratory]`; an unlabeled decision is
+`default`).
 
 - `firm`: a human stated it as a rule. Follow it; to change it, ask first.
-  `kb_check` blocks a firm decision without `origin.ref` to their words, and
-  a replacement of a firm decision that is not itself firm.
-- `default` (when absent): a delegated or agent choice. Follow it unless the
-  task gives evidence against it; then supersede it in the same change and
-  list it under "Decisions I changed" for review, without asking first.
+  A requirement or ADR with no `firmness` reads as `firm` unless an agent
+  wrote it (`origin.kind: agent`): rules people wrote, imported or carried
+  over from before origins existed are theirs. `kb_check` blocks an explicit
+  `firmness: firm` without `origin.ref` to their words, and a replacement of
+  a firm decision that is not itself firm.
+- `default`: a delegated or agent choice (`firmness: default`, or an
+  agent-written decision without `firmness`). Follow it; supersede it only on
+  evidence that it is wrong (a failing test, a measured cost, a constraint it
+  missed), in the same change, listed under "Decisions I changed".
 - `exploratory`: a flagged guess; revisit it when you touch the area.
 
+**A request that conflicts with a recorded rule is a question, whatever the
+rule's firmness.** The request is not evidence against the rule: it is the
+conflict a person has to decide. Name the rule (id and what it requires) and
+ask whether to change it; do not implement the request and do not supersede
+the rule. Go ahead only when the person has said to change that rule, in this
+task or in reply: then supersede it with `firmness: firm` and `origin.ref` to
+their words, and say in the final answer which rule changed.
+
 Set `firmness` from what a human actually said: only their stated rule is
 `firm` (with `origin.ref`); "do whatever" or your own pick is `default`; a
-guess is `exploratory`. A supersede needs `## Why this changed` in the new
-entity's body (at least 12 words): name the evidence (a failing test, a
-measured cost, a constraint the old decision missed, a new requirement) and
-answer the old decision's reasoning; `kb_check` blocks it otherwise. A
-preference is not evidence: propose it instead of superseding. Kibi checks
-only that a firm decision has a reference; never cite words nobody said.
+guess is `exploratory`. Write it explicitly whenever you record a decision,
+including when importing rules from documents, tests or tickets (a rule a
+person wrote there is `firm`, with `origin.ref` to that document). A
+supersede needs `## Why this changed` in the new entity's body (at least 12
+words): name the evidence (a failing test, a measured cost, a constraint the
+old decision missed, a new requirement, the person's instruction) and answer
+the old decision's reasoning; `kb_check` blocks it otherwise. A preference is
+not evidence: propose it instead of superseding. Kibi checks only that a firm
+decision has a reference; never cite words nobody said.
 
 Conditional clauses ("only when", "only if", "must not ... unless") compile
 into typed `forbid` rules linked by `requires_rule`, not property facts; one
@@ -466,7 +484,9 @@ prose (`mode: "requirement"`, or `kb_upsert` with the extended `semantic_text`
 and the ledger `mode: "analyze"` returns) and call `mode: "predicates"` again.
 Read `decisionConflicts` and its warnings whenever `plan` is null: they name
 the stored decision facts the candidate would contradict and the requirements
-that own them. `provide_argument_bindings` and `record_ontology_gap` mean
+that own them. To ask what a proposed rule would conflict with, call
+`mode: "predicates"` with its text and no `requirementId`; nothing is written.
+`provide_argument_bindings` and `record_ontology_gap` mean
 the same as for an ungrounded claim, and the gap observation is not a grounding
 link, so write it exactly as returned (tags, `claim_text`, `document.body`, no
 `claim_key`, no relationships). Record an ontology gap only when no returned schema fits the

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

@@ -83,7 +83,9 @@ On the first page, intent mode also returns an answer layer in `data.answer`
 
 - `governing` — current requirements matched by the query or linked to a
   matched entity, each with `via` (how it was reached) and its linked `facts`,
-  `scenarios`, `tests`, and `adrs`.
+  `scenarios`, `tests`, and `adrs`. A requirement with more linked facts than
+  the answer lists carries `moreFacts` (`count` and the `kb_query` `ask` that
+  lists them all); never read a short `facts` list as the whole rule.
 - `rationale` — ADRs that explain the decisions.
 - `notGoverning` — superseded or deprecated requirements, with `supersededBy`
   when known. Never read these as current policy; superseded entities are also

package/dist/schemas/entity.schema.json

@@ -521,7 +521,7 @@
                 "default",
                 "exploratory"
             ],
-            "description": "Requirement and ADR only. How firmly the decision was made. firm: a human stated it as a rule; it needs a ref (origin.ref, or approval_ref on a requirement) to their words, and only a human may change it. default (assumed when absent): a delegated or agent choice; a later agent may supersede it with evidence. exploratory: a flagged guess, expected to be revisited."
+            "description": "Requirement and ADR only. How firmly the decision was made. firm: a human stated it as a rule; it needs a ref (origin.ref, or approval_ref on a requirement) to their words, and only a human may change it. default: a delegated or agent choice; a later agent may supersede it with evidence. exploratory: a flagged guess, expected to be revisited. When absent, it reads as default if an agent wrote the entity (origin.kind agent) and as firm otherwise (a person's, imported or migrated decision); set it explicitly when recording a decision."
         },
         "expects": {
             "type": "string",

package/dist/search-answer.d.ts

@@ -93,6 +93,14 @@ export type SearchAnswerRequirement = SearchAnswerEntity & Readonly<{
     score: number;
     via: string;
     facts: readonly SearchAnswerFact[];
+    /**
+     * Linked facts the answer left out (over the per-requirement limit or
+     * cut to fit the byte budget) and the kb_query that lists them all.
+     */
+    moreFacts?: Readonly<{
+        count: number;
+        ask: string;
+    }>;
     scenarios: readonly SearchAnswerEntity[];
     tests: readonly SearchAnswerTest[];
     adrs: readonly SearchAnswerEntity[];
@@ -140,6 +148,12 @@ export declare const SEARCH_ANSWER_LIMITS: {
     readonly seeds: 10;
     readonly governing: 5;
     readonly perRequirement: 4;
+    /**
+     * Linked facts listed per governing requirement. Facts are what an answer
+     * states, so a requirement with several clauses keeps more of them than
+     * of its scenarios or tests.
+     */
+    readonly factsPerRequirement: 8;
     readonly rationale: 3;
     readonly notGoverning: 5;
     readonly observations: 3;

package/dist/search-answer.d.ts.map

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

package/dist/search-answer.js

@@ -43,6 +43,7 @@ const ROW_KEYS = [
     "fact_kind",
     "approved_by",
     "firmness",
+    "origin",
     "source",
     "sourceFile",
     "predicate_namespace",
@@ -64,6 +65,12 @@ export const SEARCH_ANSWER_LIMITS = {
     seeds: 10,
     governing: 5,
     perRequirement: 4,
+    /**
+     * Linked facts listed per governing requirement. Facts are what an answer
+     * states, so a requirement with several clauses keeps more of them than
+     * of its scenarios or tests.
+     */
+    factsPerRequirement: 8,
     rationale: 3,
     notGoverning: 5,
     observations: 3,
@@ -86,7 +93,7 @@ function unique(ids) {
 }
 function brief(entity) {
     const status = text(entity.status);
-    const firmness = effectiveFirmness(entity.type, entity.firmness);
+    const firmness = effectiveFirmness(entity.type, entity.firmness, entity.origin);
     return {
         id: text(entity.id),
         title: text(entity.title),
@@ -758,11 +765,19 @@ export async function buildSearchAnswer(prolog, matches, options = {}) {
             .map((edge) => edge.from);
         const scenarioIds = unique(from("specified_by"));
         const traversed = firstOf(scenarioIds);
+        // A fact the question matched comes first, then the facts that ground a
+        // clause (requires_*) before the subject a requirement constrains: the
+        // subject's key is already part of each grounding fact's claim.
+        const linked = unique(edges
+            .filter((edge) => FACT_LINKS.has(edge.rel) && edge.from === req.id)
+            .sort((left, right) => factRank(left, seedIds) - factRank(right, seedIds))
+            .map((edge) => edge.to));
+        if (linked.length > limits.factsPerRequirement)
+            truncated = true;
         return {
             req,
-            facts: firstOf(edges
-                .filter((edge) => FACT_LINKS.has(edge.rel) && edge.from === req.id)
-                .map((edge) => edge.to)),
+            facts: linked.slice(0, limits.factsPerRequirement),
+            factsOmitted: Math.max(0, linked.length - limits.factsPerRequirement),
             scenarios: traversed,
             directTests: unique([...from("verified_by"), ...into("validates")]),
             related: firstOf([...from("relates_to"), ...into("relates_to")]),
@@ -838,6 +853,9 @@ export async function buildSearchAnswer(prolog, matches, options = {}) {
                 ...brief(fact),
                 ...factDetail(fact, schemas.get(text(fact.id))),
             })),
+            ...(plan.factsOmitted > 0
+                ? { moreFacts: moreFactsOf(req.id, plan.factsOmitted) }
+                : {}),
             scenarios: rowsOf(plan.scenarios).map(brief),
             tests: rowsOf(testIds[index] ?? []).map((row) => ({
                 ...brief(row),
@@ -892,7 +910,14 @@ function answerNote(governingCount, ungoverned) {
     const lead = top === undefined
         ? ""
         : `The top-ranked match ${top.id} (${top.type}) is linked to no requirement${governingCount === 0 ? "" : "; the governing requirements below were reached through lower-ranked matches"}. `;
+    // A fact no requirement links records something seen, not a decision. An
+    // agent comparing it with a governing requirement's fact on the same
+    // tuple must not weigh the two as equals.
+    const ungovernedFact = ungoverned.some((entry) => entry.type === "fact")
+        ? "A fact in ungoverned is linked to no requirement, so it decides nothing: where it disagrees with a governing requirement's fact, the governing fact holds. "
+        : "";
     return (lead +
+        ungovernedFact +
         (governingCount === 0
             ? "No current requirement matched or owns a matched entity. Absence here is not evidence that nothing governs the change; refine the query or pass sourceLocations."
             : "Governing requirements are current requirements matched by the query or linked to a matched entity. Links are discovery, not proof. A verdict lists the contradiction and scenario-feasibility witnesses that name the requirement; none means no check named it, not that it is proven. Use kb_check and kb_coverage for consistency and proof status."));
@@ -924,6 +949,17 @@ const ANSWER_TRIM_ORDER = [
     "ungoverned",
     "rationale",
 ];
+/** Where a linked fact of a governing requirement sorts in its list. */
+function factRank(edge, seedIds) {
+    const matched = seedIds.indexOf(edge.to);
+    if (matched >= 0)
+        return matched;
+    return seedIds.length + (edge.rel === "constrains" ? 1 : 0);
+}
+/** The facts an answer left out of a governing requirement, and the ask. */
+function moreFactsOf(requirementId, count) {
+    return { count, ask: `kb_query(${JSON.stringify({ id: requirementId })})` };
+}
 const REQUIREMENT_TRIM_ORDER = [
     "unknowns",
     "exceptions",
@@ -999,7 +1035,17 @@ export function fitSearchAnswer(answer, maxBytes = SEARCH_ANSWER_LIMITS.maxBytes
         if (own) {
             current = {
                 ...current,
-                governing: [{ ...req, [own]: req[own].slice(0, -1) }],
+                governing: [
+                    {
+                        ...req,
+                        [own]: req[own].slice(0, -1),
+                        ...(own === "facts"
+                            ? {
+                                moreFacts: moreFactsOf(req.id, (req.moreFacts?.count ?? 0) + 1),
+                            }
+                            : {}),
+                    },
+                ],
             };
             continue;
         }

package/dist/traceability/git-change-snapshot.d.ts

@@ -14,7 +14,53 @@ export interface GitChangeSnapshot {
     /** Reject a changed HEAD or index tree after staged analysis. */
     assertUnchanged(): void;
     inventory: StagedPath[];
+    /**
+     * Staged merge commits only: paths whose staged content is taken unchanged
+     * from a merged parent. They are part of `baseTree`, so the inventory
+     * holds only what the merge itself wrote (its conflict resolutions and
+     * edits that differ from every parent).
+     */
+    mergeInherited?: readonly string[];
+    /**
+     * Staged snapshots only: knowledge files the commit moves into the
+     * canonical `.kb/` layout (for example after `kibi migrate`). `baseTree`
+     * holds each source's committed content at its target path, so the
+     * inventory shows only what the commit changed inside those files.
+     */
+    renameResolved?: ReadonlyArray<{
+        from: string;
+        to: string;
+    }>;
 }
+/**
+ * For a staged merge commit, the tree the merge is judged against: HEAD
+ * with every path the merge takes unchanged from a merged parent replaced
+ * by that staged content. Diffing it against the staged tree leaves only
+ * what the merge itself wrote, so debt inherited from the merged branch is
+ * not charged to the merge. Null when no merge is in progress or nothing
+ * is inherited.
+ */
+export declare function mergeResolutionBase(root: string, baseTree: string, headTree: string, parents: readonly string[]): {
+    baseTree: string;
+    inherited: string[];
+} | null;
+/**
+ * For a staged snapshot, the tree a commit that relocates knowledge files
+ * into `.kb/` is judged against: `baseTree` with each relocated file's
+ * committed content placed at its new path and the old path removed.
+ * Diffing it against the staged tree leaves only the edits the commit made
+ * inside those files, so findings that already existed at the old path are
+ * not charged to the move. Every other change, including an edit to a file
+ * that was already canonical, is diffed as before. Null when nothing is
+ * relocated.
+ */
+export declare function renameResolutionBase(root: string, baseTree: string, headTree: string): {
+    baseTree: string;
+    renames: Array<{
+        from: string;
+        to: string;
+    }>;
+} | null;
 /** Capture one immutable tree from the index and inventory only Git objects. */
 export declare function captureStagedSnapshot(workspaceRoot: string): GitChangeSnapshot;
 /**

package/dist/traceability/git-change-snapshot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git-change-snapshot.d.ts","sourceRoot":"","sources":["../../src/traceability/git-change-snapshot.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAIV,UAAU,EAEX,MAAM,iBAAiB,CAAC;AAKzB,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,KAAK,MAAM,CAAC;AAGpE,MAAM,WAAW,iBAAiB;IAChC,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,gEAAgE;IAChE,OAAO,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;IACzC,uEAAuE;IACvE,SAAS,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChE,iEAAiE;IACjE,eAAe,IAAI,IAAI,CAAC;IACxB,SAAS,EAAE,UAAU,EAAE,CAAC;CACzB;AA4cD,gFAAgF;AAEhF,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,GACpB,iBAAiB,CAuBnB;AAED;;;;;GAKG;AAEH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,iBAAiB,CAyBnB"}
+{"version":3,"file":"git-change-snapshot.d.ts","sourceRoot":"","sources":["../../src/traceability/git-change-snapshot.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAIV,UAAU,EAEX,MAAM,iBAAiB,CAAC;AAKzB,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,KAAK,MAAM,CAAC;AAGpE,MAAM,WAAW,iBAAiB;IAChC,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,gEAAgE;IAChE,OAAO,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;IACzC,uEAAuE;IACvE,SAAS,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChE,iEAAiE;IACjE,eAAe,IAAI,IAAI,CAAC;IACxB,SAAS,EAAE,UAAU,EAAE,CAAC;IACxB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC9D;AAueD;;;;;;;GAOG;AAEH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CA6ClD;AAsED;;;;;;;;;GASG;AAEH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,GAAG,IAAI,CAsB3E;AAED,gFAAgF;AAEhF,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,GACpB,iBAAiB,CAuCnB;AAED;;;;;GAKG;AAEH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,iBAAiB,CAyBnB"}

package/dist/traceability/git-change-snapshot.js

@@ -1,5 +1,8 @@
 import { execFileSync, spawnSync } from "node:child_process";
-import { isEntityLanePath, isSymbolsManifestPath } from "../utils/kb-paths.js";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { ENTITY_LANES, isEntityLanePath, isKbKnowledgePath, isSymbolsManifestPath, } from "../utils/kb-paths.js";
 const GIT_EXEC_MAX_BUFFER = 64 * 1024 * 1024;
 function runGit(root, args) {
     try {
@@ -368,12 +371,188 @@ function snapshotFromTrees(root, baseTree, headTree, headCommit, readGit, assert
         inventory: buildInventory(root, baseTree, headTree),
     };
 }
+/** The commits named by MERGE_HEAD while a merge commit is being made. */
+function pendingMergeParents(root) {
+    let mergeHeadPath;
+    try {
+        mergeHeadPath = gitText(root, ["rev-parse", "--git-path", "MERGE_HEAD"]);
+    }
+    catch {
+        return [];
+    }
+    let text;
+    try {
+        text = readFileSync(path.resolve(root, mergeHeadPath), "utf8");
+    }
+    catch {
+        return [];
+    }
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^[a-f0-9]{40,64}$/.test(line));
+}
+function changedPaths(root, from, to) {
+    return runGit(root, ["diff", "--name-only", "-z", "--no-renames", from, to])
+        .toString("utf8")
+        .split("\0")
+        .filter(Boolean);
+}
+/**
+ * For a staged merge commit, the tree the merge is judged against: HEAD
+ * with every path the merge takes unchanged from a merged parent replaced
+ * by that staged content. Diffing it against the staged tree leaves only
+ * what the merge itself wrote, so debt inherited from the merged branch is
+ * not charged to the merge. Null when no merge is in progress or nothing
+ * is inherited.
+ */
+// implements REQ-014
+export function mergeResolutionBase(root, baseTree, headTree, parents) {
+    if (parents.length === 0)
+        return null;
+    const changed = changedPaths(root, baseTree, headTree);
+    if (changed.length === 0)
+        return null;
+    const inherited = new Set();
+    for (const parent of parents) {
+        const parentTree = treeForCommit(root, parent);
+        const differs = new Set(changedPaths(root, parentTree, headTree));
+        for (const file of changed) {
+            if (!differs.has(file))
+                inherited.add(file);
+        }
+    }
+    if (inherited.size === 0)
+        return null;
+    const paths = [...inherited].sort();
+    const listed = runGit(root, [
+        "ls-tree",
+        "-r",
+        "-z",
+        "--full-tree",
+        headTree,
+        "--",
+        ...paths.map(literalPathspec),
+    ])
+        .toString("utf8")
+        .split("\0")
+        .filter(Boolean);
+    const present = new Set();
+    const entries = [];
+    for (const row of listed) {
+        const tab = row.indexOf("\t");
+        if (tab < 0)
+            continue;
+        const [mode, , oid] = row.slice(0, tab).split(" ");
+        const file = row.slice(tab + 1);
+        present.add(file);
+        entries.push(`${mode} ${oid}\t${file}`);
+    }
+    const zero = "0".repeat(baseTree.length);
+    for (const file of paths) {
+        // Deleted on the merged side and absent from the staged tree.
+        if (!present.has(file))
+            entries.push(`0 ${zero}\t${file}`);
+    }
+    return {
+        baseTree: writeTreeWithEntries(root, baseTree, entries, "kibi-merge-base-"),
+        inherited: paths,
+    };
+}
+/** Write `baseTree` with `--index-info` entries applied in a scratch index. */
+function writeTreeWithEntries(root, baseTree, entries, prefix) {
+    const scratch = mkdtempSync(path.join(tmpdir(), prefix));
+    const env = { ...process.env, GIT_INDEX_FILE: path.join(scratch, "index") };
+    try {
+        const git = (args, input) => execFileSync("git", [...args], {
+            cwd: root,
+            env,
+            maxBuffer: GIT_EXEC_MAX_BUFFER,
+            ...(input !== undefined ? { input } : {}),
+            stdio: ["pipe", "pipe", "ignore"],
+        });
+        git(["read-tree", baseTree]);
+        git(["update-index", "-z", "--index-info"], `${entries.join("\0")}\0`);
+        return git(["write-tree"]).toString("utf8").trim();
+    }
+    finally {
+        rmSync(scratch, { recursive: true, force: true });
+    }
+}
+function renamedPaths(root, from, to) {
+    return parseNameStatus(runGit(root, [
+        "diff",
+        "--name-status",
+        "-z",
+        "-M",
+        "--diff-filter=R",
+        from,
+        to,
+    ])).flatMap((row) => row.status === "R" && row.oldPath !== undefined
+        ? [{ from: row.oldPath, to: row.path }]
+        : []);
+}
+/**
+ * True when `from -> to` moves one knowledge file from outside the canonical
+ * layout into the same kind of canonical `.kb/` location: an entity lane
+ * file into the same lane, or a symbols manifest / coordinates file onto the
+ * canonical file of the same name (`.yml` and `.yaml` alike).
+ */
+function isKnowledgeRelocation(from, to) {
+    if (isKbKnowledgePath(from) || !isKbKnowledgePath(to))
+        return false;
+    if (isSymbolsManifestPath(to)) {
+        const stem = (file) => path.posix.basename(file).replace(/\.ya?ml$/, "");
+        return stem(from) === stem(to);
+    }
+    const lane = to.split("/")[1] ?? "";
+    return (ENTITY_LANES.includes(lane) &&
+        `/${from}`.includes(`/${lane}/`));
+}
+/**
+ * For a staged snapshot, the tree a commit that relocates knowledge files
+ * into `.kb/` is judged against: `baseTree` with each relocated file's
+ * committed content placed at its new path and the old path removed.
+ * Diffing it against the staged tree leaves only the edits the commit made
+ * inside those files, so findings that already existed at the old path are
+ * not charged to the move. Every other change, including an edit to a file
+ * that was already canonical, is diffed as before. Null when nothing is
+ * relocated.
+ */
+// implements REQ-014
+export function renameResolutionBase(root, baseTree, headTree) {
+    const zero = "0".repeat(baseTree.length);
+    const renames = [];
+    const entries = [];
+    for (const rename of renamedPaths(root, baseTree, headTree)) {
+        if (!isKnowledgeRelocation(rename.from, rename.to))
+            continue;
+        const source = readTreeEntry(root, baseTree, rename.from);
+        if (source?.type !== "blob")
+            continue;
+        renames.push(rename);
+        entries.push(`0 ${zero}\t${rename.from}`);
+        entries.push(`${source.mode} ${source.oid}\t${rename.to}`);
+    }
+    if (renames.length === 0)
+        return null;
+    return {
+        baseTree: writeTreeWithEntries(root, baseTree, entries, "kibi-rename-base-"),
+        renames: renames.sort((left, right) => left.to.localeCompare(right.to)),
+    };
+}
 /** Capture one immutable tree from the index and inventory only Git objects. */
 // implements REQ-014
 export function captureStagedSnapshot(workspaceRoot) {
     const headCommit = resolveHeadCommit(workspaceRoot);
-    const baseTree = treeForCommit(workspaceRoot, headCommit);
     const headTree = gitText(workspaceRoot, ["write-tree"]);
+    const commitTree = treeForCommit(workspaceRoot, headCommit);
+    const merge = headCommit
+        ? mergeResolutionBase(workspaceRoot, commitTree, headTree, pendingMergeParents(workspaceRoot))
+        : null;
+    const mergeTree = merge?.baseTree ?? commitTree;
+    const relocation = renameResolutionBase(workspaceRoot, mergeTree, headTree);
+    const baseTree = relocation?.baseTree ?? mergeTree;
     const readGit = (args) => translateReadGit(workspaceRoot, args, baseTree, headTree, headCommit);
     const assertUnchanged = () => {
         const currentHead = resolveHeadCommit(workspaceRoot);
@@ -382,7 +561,12 @@ export function captureStagedSnapshot(workspaceRoot) {
             throw new Error("Git index or HEAD changed during staged analysis; retry the operation");
         }
     };
-    return snapshotFromTrees(workspaceRoot, baseTree, headTree, headCommit, readGit, assertUnchanged);
+    const snapshot = snapshotFromTrees(workspaceRoot, baseTree, headTree, headCommit, readGit, assertUnchanged);
+    return {
+        ...snapshot,
+        ...(merge ? { mergeInherited: merge.inherited } : {}),
+        ...(relocation ? { renameResolved: relocation.renames } : {}),
+    };
 }
 /**
  * Capture changes between explicit revisions. The caller chooses `base`; for

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,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;AAwID,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,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-diagnostics.js

@@ -8,13 +8,12 @@ function deriveCoordinatesPath(symbolsManifestPath) {
 function formatFileList(paths) {
     return paths.join(", ");
 }
-/** Max symbol names rendered per detail line before "+N more". */
-const MAX_DETAIL_NAMES = 6;
+/**
+ * Every name, in order: the gate output is the list a person works through,
+ * so it is never cut short.
+ */
 function formatNameList(names) {
-    const shown = names.slice(0, MAX_DETAIL_NAMES);
-    const overflow = names.length - shown.length;
-    const rendered = shown.join(", ");
-    return overflow > 0 ? `${rendered} … and ${overflow} more` : rendered;
+    return names.join(", ");
 }
 function symbolsManifestFileDetails(evidence, paths) {
     const pathSet = new Set(paths);

package/dist/traceability/staged-inventory-drift.d.ts

@@ -0,0 +1,24 @@
+import type { ExtractionResult } from "../extractors/markdown.js";
+/** A staged requirement whose semantic inventory no longer matches its prose. */
+export declare const STAGED_INVENTORY_DRIFT_RULE = "semantic-inventory-drift";
+export type StagedInventoryDriftViolation = Readonly<{
+    rule: typeof STAGED_INVENTORY_DRIFT_RULE;
+    entityId: string;
+    source: string;
+    message: string;
+    errors: readonly string[];
+}>;
+/**
+ * The staged requirements that declare a semantic inventory contract (now
+ * or in the base tree) whose inventory no longer matches their prose. The
+ * next `kibi sync` refuses them under the proposition-complete boundary;
+ * the gate applies the same test, so drift is caught at the commit that
+ * introduces it instead of after a later merge. Requirements without a
+ * contract are left to sync, which decides from its own baseline.
+ */
+export declare function stagedInventoryDriftViolations(input: {
+    stagedPaths: ReadonlySet<string>;
+    snapshotEntities: readonly ExtractionResult[];
+    readBase: (path: string) => string | null;
+}): StagedInventoryDriftViolation[];
+//# sourceMappingURL=staged-inventory-drift.d.ts.map

package/dist/traceability/staged-inventory-drift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staged-inventory-drift.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-inventory-drift.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAKlE,iFAAiF;AAEjF,eAAO,MAAM,2BAA2B,6BAA6B,CAAC;AAGtE,MAAM,MAAM,6BAA6B,GAAG,QAAQ,CAAC;IACnD,IAAI,EAAE,OAAO,2BAA2B,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B,CAAC,CAAC;AAgCH;;;;;;;GAOG;AAEH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE;IACpD,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACjC,gBAAgB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC9C,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;CAC3C,GAAG,6BAA6B,EAAE,CA8BlC"}