kibi-cli 2.1.0 → 2.3.0

package/dist/traceability/impact-review.schema.json

@@ -0,0 +1,365 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "urn:kibi:impact-review:v1",
+    "title": "Kibi content-bound local impact review record",
+    "type": "object",
+    "additionalProperties": false,
+    "required": [
+        "contractVersion",
+        "policy",
+        "evaluator",
+        "scope",
+        "reviewer",
+        "reviewedAt",
+        "files"
+    ],
+    "properties": {
+        "contractVersion": { "const": "kibi.impact-review.v1" },
+        "policy": { "$ref": "#/$defs/policy" },
+        "evaluator": { "$ref": "#/$defs/evaluator" },
+        "scope": { "$ref": "#/$defs/scope" },
+        "reviewer": { "$ref": "#/$defs/reviewer" },
+        "reviewedAt": {
+            "type": "string",
+            "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]+)?(Z|[+-][0-9]{2}:[0-9]{2})$"
+        },
+        "files": { "type": "array", "items": { "$ref": "#/$defs/file" } }
+    },
+    "$defs": {
+        "sha256": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" },
+        "policy": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["id", "version", "fingerprint"],
+            "properties": {
+                "id": { "type": "string", "minLength": 1 },
+                "version": { "type": "string", "minLength": 1 },
+                "fingerprint": { "$ref": "#/$defs/sha256" }
+            }
+        },
+        "evaluator": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["contractVersion", "fingerprint"],
+            "properties": {
+                "contractVersion": { "const": "kibi.impact-evaluator.v1" },
+                "fingerprint": { "$ref": "#/$defs/sha256" }
+            }
+        },
+        "scope": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "fingerprint",
+                "knowledgeFingerprint",
+                "providerSetFingerprint"
+            ],
+            "properties": {
+                "fingerprint": { "$ref": "#/$defs/sha256" },
+                "knowledgeFingerprint": { "$ref": "#/$defs/sha256" },
+                "providerSetFingerprint": { "$ref": "#/$defs/sha256" }
+            }
+        },
+        "reviewer": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["id", "source"],
+            "properties": {
+                "id": { "type": "string", "minLength": 1 },
+                "source": { "const": "self-claimed-local" }
+            }
+        },
+        "range": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["start", "end"],
+            "properties": {
+                "start": { "type": "integer", "minimum": 0 },
+                "end": { "type": "integer", "minimum": 0 }
+            }
+        },
+        "uncoveredRange": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "startLine",
+                "startColumn",
+                "endLine",
+                "endColumn",
+                "reason"
+            ],
+            "properties": {
+                "startLine": { "type": "integer", "minimum": 1 },
+                "startColumn": { "type": "integer", "minimum": 0 },
+                "endLine": { "type": "integer", "minimum": 1 },
+                "endColumn": { "type": "integer", "minimum": 0 },
+                "reason": { "type": "string", "minLength": 1 }
+            }
+        },
+        "analysis": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "contractVersion",
+                "status",
+                "language",
+                "sourceFile",
+                "providerId",
+                "providerStamp",
+                "providerFingerprint",
+                "inputFingerprint",
+                "resultFingerprint",
+                "diagnosticCodes",
+                "uncoveredRanges"
+            ],
+            "properties": {
+                "contractVersion": { "const": "kibi.symbol-extractor.v2" },
+                "status": { "enum": ["ok", "partial", "unsupported", "failed"] },
+                "language": { "type": "string", "minLength": 1 },
+                "sourceFile": { "type": "string", "minLength": 1 },
+                "providerId": { "type": ["string", "null"] },
+                "providerStamp": {},
+                "providerFingerprint": {
+                    "oneOf": [{ "$ref": "#/$defs/sha256" }, { "type": "null" }]
+                },
+                "inputFingerprint": { "$ref": "#/$defs/sha256" },
+                "resultFingerprint": { "$ref": "#/$defs/sha256" },
+                "diagnosticCodes": {
+                    "type": "array",
+                    "items": { "type": "string", "minLength": 1 }
+                },
+                "uncoveredRanges": {
+                    "type": "array",
+                    "items": { "$ref": "#/$defs/uncoveredRange" }
+                }
+            }
+        },
+        "side": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["mode", "objectId", "byteFingerprint", "kind", "analysis"],
+            "properties": {
+                "mode": { "enum": ["100644", "100755", "120000", "160000"] },
+                "objectId": {
+                    "oneOf": [
+                        { "type": "string", "pattern": "^[0-9a-f]{40,64}$" },
+                        { "type": "null" }
+                    ]
+                },
+                "byteFingerprint": { "$ref": "#/$defs/sha256" },
+                "kind": { "enum": ["regular", "symlink", "gitlink"] },
+                "contentProjection": { "const": "proof_receipts_stripped" },
+                "analysis": {
+                    "oneOf": [{ "$ref": "#/$defs/analysis" }, { "type": "null" }]
+                }
+            },
+            "allOf": [
+                {
+                    "if": {
+                        "required": ["contentProjection"],
+                        "properties": {
+                            "contentProjection": { "const": "proof_receipts_stripped" }
+                        }
+                    },
+                    "then": { "properties": { "objectId": { "type": "null" } } }
+                },
+                {
+                    "if": { "not": { "required": ["contentProjection"] } },
+                    "then": {
+                        "properties": {
+                            "objectId": {
+                                "type": "string",
+                                "pattern": "^[0-9a-f]{40,64}$"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        "partialReview": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["kind", "side", "limitationClass", "ranges", "rationale"],
+            "properties": {
+                "kind": { "const": "partial_review" },
+                "side": { "enum": ["before", "after"] },
+                "limitationClass": { "type": "string", "minLength": 1 },
+                "ranges": {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": { "$ref": "#/$defs/uncoveredRange" }
+                },
+                "rationale": { "type": "string", "minLength": 1 }
+            }
+        },
+        "unsupportedReview": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["kind", "side", "wholeFile", "rationale"],
+            "properties": {
+                "kind": { "const": "unsupported_review" },
+                "side": { "enum": ["before", "after"] },
+                "wholeFile": { "const": true },
+                "rationale": { "type": "string", "minLength": 1 }
+            }
+        },
+        "updatedEntity": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "entityId",
+                "artifactPath",
+                "beforeFingerprint",
+                "afterFingerprint"
+            ],
+            "properties": {
+                "entityId": { "type": "string", "minLength": 1 },
+                "artifactPath": { "type": "string", "minLength": 1 },
+                "beforeFingerprint": {
+                    "oneOf": [{ "$ref": "#/$defs/sha256" }, { "type": "null" }]
+                },
+                "afterFingerprint": { "$ref": "#/$defs/sha256" }
+            }
+        },
+        "impactDecision": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["kind", "requirementIds", "knowledge"],
+            "properties": {
+                "kind": { "const": "impact" },
+                "requirementIds": {
+                    "type": "array",
+                    "minItems": 1,
+                    "uniqueItems": true,
+                    "items": { "type": "string", "minLength": 1 }
+                },
+                "knowledge": {
+                    "oneOf": [
+                        {
+                            "type": "object",
+                            "additionalProperties": false,
+                            "required": ["state", "rationale"],
+                            "properties": {
+                                "state": { "const": "still_current" },
+                                "rationale": { "type": "string", "minLength": 1 }
+                            }
+                        },
+                        {
+                            "type": "object",
+                            "additionalProperties": false,
+                            "required": ["state", "entities"],
+                            "properties": {
+                                "state": { "const": "updated" },
+                                "entities": {
+                                    "type": "array",
+                                    "minItems": 1,
+                                    "uniqueItems": true,
+                                    "items": { "$ref": "#/$defs/updatedEntity" }
+                                },
+                                "stillCurrent": {
+                                    "type": "array",
+                                    "uniqueItems": true,
+                                    "items": {
+                                        "type": "object",
+                                        "additionalProperties": false,
+                                        "required": ["requirementId", "rationale"],
+                                        "properties": {
+                                            "requirementId": {
+                                                "type": "string",
+                                                "minLength": 1,
+                                                "pattern": "\\S"
+                                            },
+                                            "rationale": {
+                                                "type": "string",
+                                                "minLength": 1,
+                                                "pattern": "\\S"
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    ]
+                }
+            }
+        },
+        "decision": {
+            "oneOf": [
+                { "$ref": "#/$defs/impactDecision" },
+                {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["kind", "reason", "rationale"],
+                    "properties": {
+                        "kind": { "const": "no_impact" },
+                        "reason": { "type": "string", "minLength": 1 },
+                        "rationale": { "type": "string", "minLength": 1 }
+                    }
+                },
+                {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["kind", "policyReason", "rationale"],
+                    "properties": {
+                        "kind": { "const": "not_applicable" },
+                        "policyReason": { "type": "string", "minLength": 1 },
+                        "rationale": { "type": "string", "minLength": 1 }
+                    }
+                }
+            ]
+        },
+        "file": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "path",
+                "status",
+                "analysisDepth",
+                "disposition",
+                "oldHunkRanges",
+                "newHunkRanges",
+                "before",
+                "after",
+                "analysisReviews",
+                "decision"
+            ],
+            "properties": {
+                "path": { "type": "string", "minLength": 1 },
+                "status": { "enum": ["A", "M", "R", "C", "T", "D"] },
+                "oldPath": { "type": "string", "minLength": 1 },
+                "copyFromPath": { "type": "string", "minLength": 1 },
+                "analysisDepth": { "enum": ["symbol", "metadata", "file", "none"] },
+                "disposition": { "enum": ["checked", "advisory", "skipped"] },
+                "skipReason": {
+                    "enum": ["binary", "unsupported_encoding", "symlink", "submodule"]
+                },
+                "gitMode": { "type": "string" },
+                "previousMode": { "type": "string" },
+                "oldHunkRanges": {
+                    "type": "array",
+                    "items": { "$ref": "#/$defs/range" }
+                },
+                "newHunkRanges": {
+                    "type": "array",
+                    "items": { "$ref": "#/$defs/range" }
+                },
+                "before": { "oneOf": [{ "$ref": "#/$defs/side" }, { "type": "null" }] },
+                "after": { "oneOf": [{ "$ref": "#/$defs/side" }, { "type": "null" }] },
+                "analysisReviews": {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            { "$ref": "#/$defs/partialReview" },
+                            { "$ref": "#/$defs/unsupportedReview" }
+                        ]
+                    }
+                },
+                "decision": { "$ref": "#/$defs/decision" }
+            },
+            "anyOf": [
+                { "properties": { "before": { "$ref": "#/$defs/side" } } },
+                { "properties": { "after": { "$ref": "#/$defs/side" } } }
+            ]
+        }
+    }
+}

package/dist/traceability/impact-side-evidence.d.ts

@@ -0,0 +1,13 @@
+import type { HostSourceAnalysisResultV2 } from "../plugins/source-analysis-service.js";
+import type { SourceChangeAnalysis } from "../plugins/source-change-analysis.js";
+import type { GitChangeSnapshot } from "./git-change-snapshot.js";
+import type { StagedPath } from "./git-staged.js";
+import { type SideEvidence } from "./impact-review.js";
+/** Per-path, per-side evidence: projected bytes, hunks and host analysis bindings. */
+export declare function isKnowledgeMarkdown(path: string): boolean;
+export declare function isReceiptOnlyChange(file: StagedPath): boolean;
+export declare function projectedPathEvidence(file: StagedPath): StagedPath;
+export declare function sideEvidence(snapshot: GitChangeSnapshot, tree: string, path: string, result: HostSourceAnalysisResultV2 | null, content: string | undefined): SideEvidence | null;
+export declare function assertAnalysisInput(file: StagedPath, change: SourceChangeAnalysis | undefined): void;
+export declare function exactPathProjection(file: StagedPath, before: SideEvidence | null, after: SideEvidence | null): unknown;
+//# sourceMappingURL=impact-side-evidence.d.ts.map

package/dist/traceability/impact-side-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact-side-evidence.d.ts","sourceRoot":"","sources":["../../src/traceability/impact-side-evidence.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AACxF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAEjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,EAEL,KAAK,YAAY,EAIlB,MAAM,oBAAoB,CAAC;AAE5B,sFAAsF;AAEtF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD;AAUD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CA0B7D;AAwFD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAqBlE;AASD,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,0BAA0B,GAAG,IAAI,EACzC,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B,YAAY,GAAG,IAAI,CAuFrB;AAGD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,oBAAoB,GAAG,SAAS,GACvC,IAAI,CAQN;AAGD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,YAAY,GAAG,IAAI,EAC3B,KAAK,EAAE,YAAY,GAAG,IAAI,GACzB,OAAO,CAoBT"}

package/dist/traceability/impact-side-evidence.js

@@ -0,0 +1,240 @@
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { snapshotFileContent } from "../public/operations/proof-receipt-projection.js";
+import { blobBytes, treeEntry } from "./impact-git-tree.js";
+import { assertSha256, fingerprint, fingerprintBytes, } from "./impact-review.js";
+/** Per-path, per-side evidence: projected bytes, hunks and host analysis bindings. */
+// implements REQ-impact-policy-stage-e-content-bound-review
+export function isKnowledgeMarkdown(path) {
+    return path.startsWith(".kb/") && path.endsWith(".md");
+}
+function projectedKnowledgeMarkdown(path, content) {
+    if (!isKnowledgeMarkdown(path))
+        return content;
+    return snapshotFileContent(path, Buffer.from(content, "utf8")).toString("utf8");
+}
+// implements REQ-impact-policy-stage-e-content-bound-review
+export function isReceiptOnlyChange(file) {
+    if (!isKnowledgeMarkdown(file.path) ||
+        file.status !== "M" ||
+        file.oldPath !== undefined ||
+        file.copyFromPath !== undefined ||
+        file.skipReason !== undefined ||
+        file.previousContent === undefined ||
+        file.content === undefined)
+        return false;
+    const previousMode = file.previousMode;
+    const currentMode = file.gitMode;
+    if ((previousMode !== "100644" && previousMode !== "100755") ||
+        currentMode !== previousMode)
+        return false;
+    const before = Buffer.from(file.previousContent, "utf8");
+    const after = Buffer.from(file.content, "utf8");
+    return (!before.equals(after) &&
+        snapshotFileContent(file.path, before).equals(snapshotFileContent(file.path, after)));
+}
+function normalizeHunks(ranges, content) {
+    const lineCount = Math.max(1, (content ?? "").split(/\r?\n/).length);
+    return ranges.map((range) => ({
+        start: range.start,
+        end: range.end === Number.MAX_SAFE_INTEGER ? lineCount : range.end,
+    }));
+}
+function projectedHunks(beforeContent, afterContent) {
+    const temporary = mkdtempSync(join(tmpdir(), "kibi-impact-projected-diff-"));
+    try {
+        const beforePath = join(temporary, "before.md");
+        const afterPath = join(temporary, "after.md");
+        writeFileSync(beforePath, beforeContent ?? "");
+        writeFileSync(afterPath, afterContent ?? "");
+        let diffText = "";
+        try {
+            diffText = execFileSync("git", [
+                "diff",
+                "--no-index",
+                "--no-ext-diff",
+                "--no-textconv",
+                "--no-color",
+                "--unified=0",
+                "--",
+                beforePath,
+                afterPath,
+            ], {
+                encoding: "utf8",
+                maxBuffer: 64 * 1024 * 1024,
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+        }
+        catch (error) {
+            if (typeof error !== "object" ||
+                error === null ||
+                !("status" in error) ||
+                error.status !== 1)
+                throw error;
+            diffText =
+                "stdout" in error && typeof error.stdout === "string"
+                    ? error.stdout
+                    : "stdout" in error && Buffer.isBuffer(error.stdout)
+                        ? error.stdout.toString("utf8")
+                        : "";
+        }
+        const oldHunkRanges = [];
+        const hunkRanges = [];
+        const regex = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/gm;
+        for (const match of diffText.matchAll(regex)) {
+            const oldStart = Number.parseInt(match[1] ?? "0", 10);
+            const oldCount = Number.parseInt(match[2] ?? "1", 10);
+            const newStart = Number.parseInt(match[3] ?? "0", 10);
+            const newCount = Number.parseInt(match[4] ?? "1", 10);
+            if (oldCount > 0)
+                oldHunkRanges.push({
+                    start: oldStart,
+                    end: oldStart + oldCount - 1,
+                });
+            if (newCount > 0)
+                hunkRanges.push({ start: newStart, end: newStart + newCount - 1 });
+        }
+        return {
+            oldHunkRanges: normalizeHunks(oldHunkRanges, beforeContent),
+            hunkRanges: normalizeHunks(hunkRanges, afterContent),
+        };
+    }
+    finally {
+        rmSync(temporary, { recursive: true, force: true });
+    }
+}
+// implements REQ-impact-policy-stage-e-content-bound-review
+export function projectedPathEvidence(file) {
+    const previousPath = file.oldPath ?? file.copyFromPath ?? file.path;
+    if (!isKnowledgeMarkdown(file.path) && !isKnowledgeMarkdown(previousPath))
+        return file;
+    const previousContent = file.previousContent === undefined
+        ? undefined
+        : projectedKnowledgeMarkdown(previousPath, file.previousContent);
+    const content = file.content === undefined
+        ? undefined
+        : projectedKnowledgeMarkdown(file.path, file.content);
+    const ranges = projectedHunks(previousContent, content);
+    const { diffText: _diffText, ...projected } = file;
+    return {
+        ...projected,
+        ...(previousContent !== undefined ? { previousContent } : {}),
+        ...(content !== undefined ? { content } : {}),
+        oldHunkRanges: ranges.oldHunkRanges,
+        hunkRanges: ranges.hunkRanges,
+    };
+}
+function sideAnalysisFingerprint(result) {
+    return fingerprint(result);
+}
+// implements REQ-impact-policy-stage-e-content-bound-review
+export function sideEvidence(snapshot, tree, path, result, content) {
+    const entry = treeEntry(snapshot, tree, path);
+    if (!entry)
+        return null;
+    if (!["100644", "100755", "120000", "160000"].includes(entry.mode))
+        throw new Error(`Unsupported Git mode ${entry.mode} for ${path}`);
+    if ((entry.mode === "160000") !== (entry.type === "commit") ||
+        (entry.mode !== "160000" && entry.type !== "blob"))
+        throw new Error(`Git mode/object type mismatch for ${path}`);
+    const bytes = blobBytes(snapshot, entry);
+    const kind = entry.mode === "160000" || entry.type === "commit"
+        ? "gitlink"
+        : entry.mode === "120000"
+            ? "symlink"
+            : "regular";
+    const projected = bytes !== undefined && isKnowledgeMarkdown(path);
+    const evidenceBytes = bytes && projected ? snapshotFileContent(path, bytes) : bytes;
+    const byteFingerprint = evidenceBytes
+        ? fingerprintBytes(evidenceBytes)
+        : fingerprint({
+            mode: entry.mode,
+            type: entry.type,
+            objectId: entry.objectId,
+        });
+    let analysis = null;
+    if (result) {
+        if (result.sourceFile !== path)
+            throw new Error(`Analysis source path mismatch for ${path}`);
+        if (content === undefined ||
+            !/^[0-9a-f]{64}$/.test(result.inputFingerprint))
+            throw new Error(`Host analysis lacks a valid input fingerprint for captured path ${path}`);
+        if (result.providerFingerprint !== null)
+            assertSha256(`sha256:${result.providerFingerprint}`, `Provider fingerprint for ${path}`);
+        if ((result.status === "partial" && result.uncoveredRanges.length === 0) ||
+            (result.status === "ok" && result.uncoveredRanges.length > 0))
+            throw new Error(`Source analysis status/range mismatch for ${path}`);
+        analysis = {
+            contractVersion: result.contractVersion,
+            status: result.status,
+            language: result.language,
+            sourceFile: result.sourceFile,
+            providerId: result.providerId,
+            providerStamp: result.stamp,
+            providerFingerprint: result.providerFingerprint === null
+                ? null
+                : `sha256:${result.providerFingerprint}`,
+            // The wrapper supplies host-validated analysis of these exact captured
+            // bytes. The byteFingerprint above independently binds the Git blob; do
+            // not recompute this host contract here because v2 may include the
+            // classifier, explicit language hint, and normalization version.
+            inputFingerprint: `sha256:${result.inputFingerprint}`,
+            resultFingerprint: sideAnalysisFingerprint(result),
+            diagnosticCodes: result.diagnostics.map((row) => row.code).sort(),
+            uncoveredRanges: result.uncoveredRanges.map((range) => ({
+                startLine: range.startLine,
+                startColumn: range.startColumn,
+                endLine: range.endLine,
+                endColumn: range.endColumn,
+                reason: range.reason,
+            })),
+        };
+    }
+    if (kind === "regular" && bytes === undefined)
+        throw new Error(`Regular tree entry has no blob: ${path}`);
+    return {
+        mode: entry.mode,
+        objectId: projected ? null : entry.objectId,
+        byteFingerprint,
+        kind,
+        ...(projected
+            ? { contentProjection: "proof_receipts_stripped" }
+            : {}),
+        analysis,
+    };
+}
+// implements REQ-impact-policy-stage-e-content-bound-review
+export function assertAnalysisInput(file, change) {
+    if (file.analysisDepth === "metadata" || file.skipReason)
+        return;
+    if (file.previousContent !== undefined && !change?.before)
+        throw new Error(`Missing before-side source analysis for ${file.path}`);
+    if (file.content !== undefined && !change?.after)
+        throw new Error(`Missing after-side source analysis for ${file.path}`);
+    if (change && change.path !== file.path)
+        throw new Error(`Analysis path mismatch for ${file.path}`);
+}
+// implements REQ-impact-policy-stage-e-content-bound-review
+export function exactPathProjection(file, before, after) {
+    return {
+        path: file.path,
+        status: file.status,
+        ...(file.oldPath === undefined ? {} : { oldPath: file.oldPath }),
+        ...(file.copyFromPath === undefined
+            ? {}
+            : { copyFromPath: file.copyFromPath }),
+        analysisDepth: file.analysisDepth,
+        disposition: file.disposition,
+        ...(file.skipReason === undefined ? {} : { skipReason: file.skipReason }),
+        ...(file.gitMode === undefined ? {} : { gitMode: file.gitMode }),
+        ...(file.previousMode === undefined
+            ? {}
+            : { previousMode: file.previousMode }),
+        oldHunkRanges: file.oldHunkRanges ?? [],
+        newHunkRanges: file.hunkRanges,
+        before,
+        after,
+    };
+}

package/dist/traceability/reviewed-coordinate-refresh.d.ts

@@ -0,0 +1,10 @@
+import type { HostSourceAnalysisResultV2, SourceAnalysisService } from "../plugins/source-analysis-service.js";
+import type { GitChangeSnapshot } from "./git-change-snapshot.js";
+import type { Fingerprint } from "./impact-review.js";
+/** Authorize lexical coordinate migration only from a captured local staged review.
+ * Protected PR hosts must use their target-base evaluator, not this HEAD policy. */
+export declare function createReviewedDecoratorCoordinateVerifier(snapshot: GitChangeSnapshot, service: SourceAnalysisService, bindings: {
+    providerSetFingerprint: Fingerprint;
+    evaluatorFingerprint: Fingerprint;
+}): (path: string, analysis: HostSourceAnalysisResultV2) => Promise<void>;
+//# sourceMappingURL=reviewed-coordinate-refresh.d.ts.map

package/dist/traceability/reviewed-coordinate-refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviewed-coordinate-refresh.d.ts","sourceRoot":"","sources":["../../src/traceability/reviewed-coordinate-refresh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAC1B,qBAAqB,EACtB,MAAM,uCAAuC,CAAC;AAE/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAKlE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD;oFACoF;AACpF,wBAAgB,yCAAyC,CACvD,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,qBAAqB,EAC9B,QAAQ,EAAE;IACR,sBAAsB,EAAE,WAAW,CAAC;IACpC,oBAAoB,EAAE,WAAW,CAAC;CACnC,GACA,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,0BAA0B,KAAK,OAAO,CAAC,IAAI,CAAC,CA4DvE"}