kibi-cli 2.3.0 → 2.5.0

package/dist/operations/migration/kb-sources.js

@@ -0,0 +1,233 @@
+/*
+ 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 { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { load as loadYaml } from "js-yaml";
+import { ENTITY_LANES, KB_PATHS, } from "../../utils/kb-paths.js";
+function walkMarkdown(directory, files) {
+    let entries;
+    try {
+        entries = readdirSync(directory, { withFileTypes: true, encoding: "utf8" });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const absolute = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            walkMarkdown(absolute, files);
+        }
+        else if (entry.isFile() &&
+            entry.name.endsWith(".md") &&
+            entry.name !== "README.md") {
+            files.push(absolute);
+        }
+    }
+}
+/** Every authored Markdown entity file in the canonical lanes, sorted. */
+// implements REQ-cli-schema-migration
+export function listLaneMarkdownFiles(workspaceRoot, lanes = ENTITY_LANES) {
+    const result = [];
+    for (const lane of lanes) {
+        const files = [];
+        const laneRoot = path.join(workspaceRoot, KB_PATHS.lanes[lane]);
+        if (!existsSync(laneRoot))
+            continue;
+        walkMarkdown(laneRoot, files);
+        for (const absolutePath of files.sort()) {
+            result.push({
+                lane,
+                absolutePath,
+                relativePath: path
+                    .relative(workspaceRoot, absolutePath)
+                    .replaceAll(path.sep, "/"),
+            });
+        }
+    }
+    return result;
+}
+/**
+ * Split a document the way the Markdown extractor reads it: the frontmatter
+ * ends at the next `---` after the opening delimiter. Returns null when that
+ * `---` is not at the start of a line, because an edit there could not be
+ * read back.
+ */
+// implements REQ-cli-schema-migration
+export function sliceFrontmatter(content) {
+    const leading = content.length - content.trimStart().length;
+    if (!content.startsWith("---", leading))
+        return null;
+    const openEnd = content.indexOf("\n", leading + 3);
+    if (openEnd < 0)
+        return null;
+    const close = content.indexOf("---", leading + 3);
+    if (close <= openEnd || content[close - 1] !== "\n")
+        return null;
+    const text = content.slice(openEnd + 1, close);
+    return {
+        prefix: content.slice(0, openEnd + 1),
+        text,
+        suffix: content.slice(close),
+        eol: text.includes("\r\n") || content[openEnd - 1] === "\r" ? "\r\n" : "\n",
+    };
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function topLevelFieldPattern(key) {
+    return new RegExp(`^${key}[ \\t]*:[^\\r\\n]*`, "m");
+}
+/**
+ * The value of one top-level frontmatter key, read from its own line without
+ * parsing the whole document (test files carry large receipt histories).
+ * Falls back to a full parse when the value spans several lines. Returns
+ * `undefined` when the key is absent or the frontmatter does not parse.
+ */
+// implements REQ-cli-schema-migration
+export function readTopLevelField(frontmatter, key) {
+    const match = topLevelFieldPattern(key).exec(frontmatter);
+    if (match === null)
+        return undefined;
+    const after = frontmatter.slice(match.index + match[0].length);
+    const continues = /^\r?\n[ \t]+\S/.test(after);
+    try {
+        if (!continues) {
+            const parsed = loadYaml(match[0]);
+            if (isRecord(parsed))
+                return parsed[key];
+        }
+        const parsed = loadYaml(frontmatter);
+        return isRecord(parsed) ? parsed[key] : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function scalarLine(key, value, previous) {
+    const raw = previous.slice(previous.indexOf(":") + 1).trim();
+    if (raw.startsWith('"'))
+        return `${key}: ${JSON.stringify(value)}`;
+    if (raw.startsWith("'"))
+        return `${key}: '${value.replaceAll("'", "''")}'`;
+    try {
+        const plain = loadYaml(`${key}: ${value}`);
+        if (isRecord(plain) && plain[key] === value)
+            return `${key}: ${value}`;
+    }
+    catch {
+        // Fall through to a quoted scalar.
+    }
+    return `${key}: ${JSON.stringify(value)}`;
+}
+/**
+ * Set one top-level scalar frontmatter key, leaving every other byte of the
+ * document unchanged: the key's line is replaced in place, or appended as the
+ * last frontmatter key when absent. Returns null when the key spans several
+ * lines or the edit would not read back as exactly that change.
+ */
+// implements REQ-cli-schema-migration
+export function withTopLevelField(content, key, value) {
+    const slice = sliceFrontmatter(content);
+    if (slice === null)
+        return null;
+    const match = topLevelFieldPattern(key).exec(slice.text);
+    let text;
+    if (match === null) {
+        text = `${slice.text}${scalarLine(key, value, "")}${slice.eol}`;
+    }
+    else {
+        const after = slice.text.slice(match.index + match[0].length);
+        if (/^\r?\n[ \t]+\S/.test(after))
+            return null;
+        text = `${slice.text.slice(0, match.index)}${scalarLine(key, value, match[0])}${after}`;
+    }
+    try {
+        const before = loadYaml(slice.text);
+        const next = loadYaml(text);
+        if (!isRecord(before) || !isRecord(next) || next[key] !== value) {
+            return null;
+        }
+        const { [key]: _beforeValue, ...beforeRest } = before;
+        const { [key]: _nextValue, ...nextRest } = next;
+        if (!isDeepStrictEqual(beforeRest, nextRest))
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return `${slice.prefix}${text}${slice.suffix}`;
+}
+function frontmatterRecord(text) {
+    const parsed = loadYaml(text);
+    if (parsed === undefined || parsed === null)
+        return {};
+    return isRecord(parsed) ? parsed : null;
+}
+/**
+ * Remove one top-level scalar frontmatter key, leaving every other byte of
+ * the document unchanged: only the key's line and its line break go. Returns
+ * the content unchanged when the key is absent. Returns null when the key
+ * spans several lines or the edit would not read back as exactly that
+ * change (the key gone, every other key parsing identically).
+ */
+// implements REQ-kibi-schema6-migration
+export function withoutTopLevelField(content, key) {
+    const slice = sliceFrontmatter(content);
+    if (slice === null)
+        return null;
+    const match = topLevelFieldPattern(key).exec(slice.text);
+    let text = slice.text;
+    if (match !== null) {
+        const after = slice.text.slice(match.index + match[0].length);
+        if (/^\r?\n[ \t]+\S/.test(after))
+            return null;
+        text = `${slice.text.slice(0, match.index)}${after.replace(/^\r?\n/, "")}`;
+    }
+    try {
+        const before = frontmatterRecord(slice.text);
+        const next = frontmatterRecord(text);
+        if (before === null || next === null || Object.hasOwn(next, key)) {
+            return null;
+        }
+        const { [key]: _beforeValue, ...beforeRest } = before;
+        if (!isDeepStrictEqual(beforeRest, next))
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return match === null ? content : `${slice.prefix}${text}${slice.suffix}`;
+}
+/** Replace a file's bytes atomically. */
+// implements REQ-cli-schema-migration
+export function writeFileAtomically(filePath, content) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.kibi-migrate-${process.pid}-${Date.now()}`;
+    writeFileSync(tempPath, content, "utf8");
+    renameSync(tempPath, filePath);
+}
+// implements REQ-cli-schema-migration
+export function readText(filePath) {
+    try {
+        return readFileSync(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}

package/dist/operations/migration/origin-backfill.d.ts

@@ -0,0 +1,39 @@
+import { type EntityOrigin } from "../../public/entity-origin.js";
+/** One authored entity the v5 -> v6 migration stamps with an origin. */
+export type OriginBackfillTarget = Readonly<{
+    id: string;
+    type: string;
+    path: string;
+}>;
+export type OriginBackfillSkip = Readonly<{
+    path: string;
+    reason: string;
+}>;
+export type OriginBackfillPlan = Readonly<{
+    targets: readonly OriginBackfillTarget[];
+    /** Files Kibi cannot stamp safely; sync reports most of them anyway. */
+    skipped: readonly OriginBackfillSkip[];
+}>;
+/** Authored Markdown entities that carry no origin yet. Read-only. */
+export declare function planOriginBackfill(workspaceRoot: string): OriginBackfillPlan;
+/** The origin recorded on entities the v5 -> v6 migration backfills. */
+export declare function migrationOrigin(recordedAt: string): EntityOrigin;
+/**
+ * Append `origin` as the last frontmatter key of one document, leaving every
+ * other byte unchanged, and confirm the frontmatter reads back with the same
+ * fields plus that origin. Returns null when the edit would not read back.
+ */
+export declare function withBackfilledOrigin(content: string, origin: EntityOrigin): string | null;
+export type OriginBackfillResult = Readonly<{
+    written: readonly OriginBackfillTarget[];
+    skipped: readonly OriginBackfillSkip[];
+    /** Entities an earlier run (or plan action) already stamped. */
+    previouslyStamped: number;
+}>;
+/**
+ * Stamp `origin: {kind: migration, ref, recorded_at}` on every authored
+ * Markdown entity without an origin. Idempotent: entities that already carry
+ * an origin, including ones stamped by an earlier run, are left alone.
+ */
+export declare function applyOriginBackfill(workspaceRoot: string, recordedAt: string): OriginBackfillResult;
+//# sourceMappingURL=origin-backfill.d.ts.map

package/dist/operations/migration/origin-backfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"origin-backfill.d.ts","sourceRoot":"","sources":["../../../src/operations/migration/origin-backfill.ts"],"names":[],"mappings":"AAsBA,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,+BAA+B,CAAC;AAQvC,wEAAwE;AAExE,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAAC;AAGH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAG5E,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,OAAO,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACzC,wEAAwE;IACxE,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACxC,CAAC,CAAC;AAkEH,sEAAsE;AAEtE,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,kBAAkB,CAa5E;AAED,wEAAwE;AAExE,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAMhE;AAED;;;;GAIG;AAEH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,GACnB,MAAM,GAAG,IAAI,CAwBf;AAGD,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,OAAO,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACzC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACvC,gEAAgE;IAChE,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC,CAAC;AAEH;;;;GAIG;AAEH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,GACjB,oBAAoB,CA+BtB"}

package/dist/operations/migration/origin-backfill.js

@@ -0,0 +1,164 @@
+/*
+ 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 path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { dump as dumpYaml, load as loadYaml } from "js-yaml";
+import { inferTypeFromPath } from "../../extractors/markdown.js";
+import { SCHEMA6_MIGRATION_ORIGIN_REF, normalizeEntityOrigin, } from "../../public/entity-origin.js";
+import { listLaneMarkdownFiles, readText, sliceFrontmatter, writeFileAtomically, } from "./kb-sources.js";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function inspect(workspaceRoot, absolutePath, relativePath) {
+    const content = readText(absolutePath);
+    if (content === null) {
+        return { kind: "skip", skip: { path: relativePath, reason: "unreadable" } };
+    }
+    const slice = sliceFrontmatter(content);
+    if (slice === null) {
+        return {
+            kind: "skip",
+            skip: { path: relativePath, reason: "no closed YAML frontmatter" },
+        };
+    }
+    let data;
+    try {
+        data = loadYaml(slice.text);
+    }
+    catch (error) {
+        return {
+            kind: "skip",
+            skip: {
+                path: relativePath,
+                reason: `frontmatter does not parse: ${error instanceof Error ? error.message : String(error)}`,
+            },
+        };
+    }
+    if (!isRecord(data) || typeof data.title !== "string") {
+        return {
+            kind: "skip",
+            skip: { path: relativePath, reason: "frontmatter has no title" },
+        };
+    }
+    if (data.origin !== undefined) {
+        const origin = normalizeEntityOrigin(data.origin);
+        return {
+            kind: "has_origin",
+            migrated: "origin" in origin &&
+                origin.origin.kind === "migration" &&
+                origin.origin.ref === SCHEMA6_MIGRATION_ORIGIN_REF,
+        };
+    }
+    const id = typeof data.id === "string" && data.id.trim() !== ""
+        ? data.id.trim()
+        : path.basename(relativePath, ".md");
+    const type = typeof data.type === "string"
+        ? data.type
+        : (inferTypeFromPath(path.join(workspaceRoot, relativePath)) ?? "");
+    return { kind: "target", target: { id, type, path: relativePath }, content };
+}
+/** Authored Markdown entities that carry no origin yet. Read-only. */
+// implements REQ-cli-schema-migration, REQ-004
+export function planOriginBackfill(workspaceRoot) {
+    const targets = [];
+    const skipped = [];
+    for (const file of listLaneMarkdownFiles(workspaceRoot)) {
+        const candidate = inspect(workspaceRoot, file.absolutePath, file.relativePath);
+        if (candidate.kind === "target")
+            targets.push(candidate.target);
+        else if (candidate.kind === "skip")
+            skipped.push(candidate.skip);
+    }
+    return { targets, skipped };
+}
+/** The origin recorded on entities the v5 -> v6 migration backfills. */
+// implements REQ-kibi-entity-origin, REQ-cli-schema-migration
+export function migrationOrigin(recordedAt) {
+    return {
+        kind: "migration",
+        ref: SCHEMA6_MIGRATION_ORIGIN_REF,
+        recorded_at: recordedAt,
+    };
+}
+/**
+ * Append `origin` as the last frontmatter key of one document, leaving every
+ * other byte unchanged, and confirm the frontmatter reads back with the same
+ * fields plus that origin. Returns null when the edit would not read back.
+ */
+// implements REQ-cli-schema-migration
+export function withBackfilledOrigin(content, origin) {
+    const slice = sliceFrontmatter(content);
+    if (slice === null)
+        return null;
+    const block = dumpYaml({ origin }, { lineWidth: -1, noRefs: true })
+        .split("\n")
+        .join(slice.eol);
+    const text = `${slice.text}${block}`;
+    try {
+        const before = loadYaml(slice.text);
+        const after = loadYaml(text);
+        if (!isRecord(before) || !isRecord(after))
+            return null;
+        const { origin: readBack, ...rest } = after;
+        const normalized = normalizeEntityOrigin(readBack);
+        if (!("origin" in normalized) ||
+            !isDeepStrictEqual(normalized.origin, origin) ||
+            !isDeepStrictEqual(rest, before)) {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    return `${slice.prefix}${text}${slice.suffix}`;
+}
+/**
+ * Stamp `origin: {kind: migration, ref, recorded_at}` on every authored
+ * Markdown entity without an origin. Idempotent: entities that already carry
+ * an origin, including ones stamped by an earlier run, are left alone.
+ */
+// implements REQ-cli-schema-migration, REQ-004
+export function applyOriginBackfill(workspaceRoot, recordedAt) {
+    const origin = migrationOrigin(recordedAt);
+    const written = [];
+    const skipped = [];
+    let previouslyStamped = 0;
+    for (const file of listLaneMarkdownFiles(workspaceRoot)) {
+        const candidate = inspect(workspaceRoot, file.absolutePath, file.relativePath);
+        if (candidate.kind === "has_origin") {
+            if (candidate.migrated)
+                previouslyStamped += 1;
+            continue;
+        }
+        if (candidate.kind === "skip") {
+            skipped.push(candidate.skip);
+            continue;
+        }
+        const next = withBackfilledOrigin(candidate.content, origin);
+        if (next === null) {
+            skipped.push({
+                path: file.relativePath,
+                reason: "origin could not be appended without changing other fields",
+            });
+            continue;
+        }
+        writeFileAtomically(file.absolutePath, next);
+        written.push(candidate.target);
+    }
+    return { written, skipped, previouslyStamped };
+}

package/dist/operations/migration/polarity-values.d.ts

@@ -0,0 +1,10 @@
+export declare const POLARITY_VALUE_BACKFILL_CODE = "polarity_value_backfill";
+/** Only polarity-only legacy claims have an unambiguous boolean encoding. */
+export declare function planPolarityValueBackfill(workspaceRoot: string): readonly {
+    id: string;
+    path: string;
+    before: string;
+    after: string;
+}[];
+export declare function applyPolarityValueBackfill(workspaceRoot: string): number;
+//# sourceMappingURL=polarity-values.d.ts.map

package/dist/operations/migration/polarity-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polarity-values.d.ts","sourceRoot":"","sources":["../../../src/operations/migration/polarity-values.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,4BAA4B,4BAA4B,CAAC;AAEtE,6EAA6E;AAE7E,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,GACpB,SAAS;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CA+DxE;AAGD,wBAAgB,0BAA0B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAKxE"}

package/dist/operations/migration/polarity-values.js

@@ -0,0 +1,60 @@
+import { load as loadYaml } from "js-yaml";
+import { listLaneMarkdownFiles, readText, sliceFrontmatter, writeFileAtomically, } from "./kb-sources.js";
+// implements REQ-cli-schema-migration, REQ-kibi-truthful-consistency
+export const POLARITY_VALUE_BACKFILL_CODE = "polarity_value_backfill";
+/** Only polarity-only legacy claims have an unambiguous boolean encoding. */
+// implements REQ-cli-schema-migration, REQ-kibi-truthful-consistency
+export function planPolarityValueBackfill(workspaceRoot) {
+    const targets = [];
+    for (const file of listLaneMarkdownFiles(workspaceRoot, ["facts"])) {
+        const before = readText(file.absolutePath);
+        const slice = before === null ? null : sliceFrontmatter(before);
+        if (!slice || before === null)
+            continue;
+        let data;
+        try {
+            data = loadYaml(slice.text);
+        }
+        catch (error) {
+            throw new Error(`Cannot migrate fact ${file.relativePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!data ||
+            data.fact_kind !== "property_value" ||
+            !["require", "forbid"].includes(String(data.polarity)))
+            continue;
+        if ([
+            "operator",
+            "value_type",
+            "value_bool",
+            "value_int",
+            "value_number",
+            "value_string",
+        ].some((key) => Object.hasOwn(data, key)))
+            continue;
+        if (typeof data.subject_key !== "string" ||
+            typeof data.property_key !== "string")
+            throw new Error(`Cannot migrate polarity fact ${file.relativePath}: subject_key and property_key are required`);
+        const after = `${slice.prefix}${slice.text}operator: eq${slice.eol}value_type: bool${slice.eol}value_bool: true${slice.eol}${slice.suffix}`;
+        const parsed = loadYaml(sliceFrontmatter(after).text);
+        if (parsed.operator !== "eq" ||
+            parsed.value_type !== "bool" ||
+            parsed.value_bool !== true)
+            throw new Error(`Polarity migration could not verify ${file.relativePath}`);
+        targets.push({
+            id: typeof data.id === "string"
+                ? data.id
+                : file.relativePath.split("/").at(-1).slice(0, -3),
+            path: file.relativePath,
+            before,
+            after,
+        });
+    }
+    return targets;
+}
+// implements REQ-cli-schema-migration, REQ-kibi-truthful-consistency
+export function applyPolarityValueBackfill(workspaceRoot) {
+    const targets = planPolarityValueBackfill(workspaceRoot);
+    for (const target of targets)
+        writeFileAtomically(`${workspaceRoot}/${target.path}`, target.after);
+    return targets.length;
+}

package/dist/operations/migration/schema6.d.ts

@@ -0,0 +1,59 @@
+import { type MigrationAction } from "../../public/operations/migration-plan.js";
+import { CLOSE_SUPERSEDED_REQUIREMENTS_CODE, MIGRATION_SYNC_ACTION_ID, MIGRATION_SYNC_CODE, SOURCE_PATH_REWRITE_CODE } from "../../public/operations/schema6-check-actions.js";
+/** The KB schema generation that introduced entity `origin`. */
+export declare const ORIGIN_SCHEMA_VERSION = 6;
+/** Automatic: re-derive a drifted inventory with the current advisor. */
+export declare const SEMANTIC_INVENTORY_REDERIVE_CODE = "semantic_inventory_rederive";
+/** Review: a drifted inventory Kibi cannot re-derive safely. */
+export declare const SEMANTIC_INVENTORY_REVIEW_CODE = "semantic_inventory_review";
+/** Automatic: stamp `origin: {kind: migration}` on authored entities. */
+export declare const ENTITY_ORIGIN_BACKFILL_CODE = "entity_origin_backfill";
+export declare const ENTITY_ORIGIN_BACKFILL_ACTION_ID = "entity-origin-backfill";
+export { CLOSE_SUPERSEDED_REQUIREMENTS_CODE, MIGRATION_SYNC_ACTION_ID, MIGRATION_SYNC_CODE, SOURCE_PATH_REWRITE_CODE, };
+/**
+ * Exceptions without approved_by, read from authored sources so the list is
+ * available before the KB compiles.
+ */
+export declare function unapprovedExceptionsFromSources(workspaceRoot: string): Array<{
+    exceptionId: string;
+    exempts: string[];
+    source: string;
+}>;
+export type Schema6MigrationFragment = Readonly<{
+    actions: readonly MigrationAction[];
+    /** Automatic actions that rewrite authored sources. */
+    sourceRewriteActionIds: readonly string[];
+    diagnostics: readonly string[];
+}>;
+/**
+ * Source-derived migration actions: inventory re-derivation whenever an
+ * advisor change makes stored inventories drift and the lifecycle repairs
+ * (superseded requirements to close, dangling source paths) at any schema
+ * version, and, for a KB older than schema 6, the origin backfill plus the
+ * exceptions that stop exempting anything. Read-only.
+ */
+export declare function buildSchema6MigrationFragment(input: {
+    workspaceRoot: string;
+    currentSchemaVersion: number | null;
+}): Schema6MigrationFragment;
+/**
+ * Actions for the superseded-requirement-open and source-path-dangling
+ * findings in authored sources: close superseded requirements, and rewrite
+ * moved or remove redundant and dead source values, automatically; one
+ * review per supersession cycle and per source value Kibi cannot edit
+ * safely. Read-only.
+ */
+export declare function buildLifecycleRepairActions(workspaceRoot: string): {
+    actions: MigrationAction[];
+    sourceRewriteActionIds: string[];
+};
+/** The sync that recompiles sources rewritten by earlier actions. */
+export declare function migrationSyncAction(dependsOn: readonly string[]): MigrationAction;
+type ApplyContext = Readonly<{
+    workspaceRoot: string;
+    clock: () => Date;
+}>;
+/** Execute one automatic action produced by this module. */
+export declare function applySchema6MigrationAction(action: MigrationAction, context: ApplyContext): Promise<void>;
+export declare const SCHEMA6_AUTOMATIC_CODES: ReadonlySet<string>;
+//# sourceMappingURL=schema6.d.ts.map

package/dist/operations/migration/schema6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema6.d.ts","sourceRoot":"","sources":["../../../src/operations/migration/schema6.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,KAAK,eAAe,EAErB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAEL,kCAAkC,EAClC,wBAAwB,EACxB,mBAAmB,EAEnB,wBAAwB,EAOzB,MAAM,kDAAkD,CAAC;AA2B1D,gEAAgE;AAEhE,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,yEAAyE;AAEzE,eAAO,MAAM,gCAAgC,gCAAgC,CAAC;AAC9E,gEAAgE;AAEhE,eAAO,MAAM,8BAA8B,8BAA8B,CAAC;AAC1E,yEAAyE;AAEzE,eAAO,MAAM,2BAA2B,2BAA2B,CAAC;AAEpE,eAAO,MAAM,gCAAgC,2BAA2B,CAAC;AACzE,OAAO,EACL,kCAAkC,EAClC,wBAAwB,EACxB,mBAAmB,EACnB,wBAAwB,GACzB,CAAC;AAsEF;;;GAGG;AAEH,wBAAgB,+BAA+B,CAC7C,aAAa,EAAE,MAAM,GACpB,KAAK,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAsDnE;AAGD,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IACpC,uDAAuD;IACvD,sBAAsB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC,CAAC,CAAC;AAEH;;;;;;GAMG;AAEH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE;IACnD,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC,GAAG,wBAAwB,CA8F3B;AAED;;;;;;GAMG;AAEH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG;IAClE,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,sBAAsB,EAAE,MAAM,EAAE,CAAC;CAClC,CAoCA;AAED,qEAAqE;AAErE,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,eAAe,CAEjB;AA0CD,KAAK,YAAY,GAAG,QAAQ,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC,CAAC;AAEH,4DAA4D;AAE5D,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CA8Df;AAGD,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAOtD,CAAC"}