mdkg 0.3.2 → 0.3.4

package/dist/commands/fix.js

@@ -4,7 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectFixPlan = collectFixPlan;
+exports.collectFixApply = collectFixApply;
 exports.runFixPlanCommand = runFixPlanCommand;
+exports.runFixApplyCommand = runFixApplyCommand;
+exports.runFixIdsCommand = runFixIdsCommand;
 const crypto_1 = __importDefault(require("crypto"));
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
@@ -23,6 +26,9 @@ const template_schema_1 = require("../graph/template_schema");
 const workspace_files_1 = require("../graph/workspace_files");
 const errors_1 = require("../util/errors");
 const refs_1 = require("../util/refs");
+const atomic_1 = require("../util/atomic");
+const lock_1 = require("../util/lock");
+const index_1 = require("./index");
 const FAMILY_VALUES = new Set(["index", "refs", "ids", "all"]);
 const CONCRETE_FAMILIES = ["index", "refs", "ids"];
 function stableValue(value) {
@@ -668,14 +674,143 @@ function planRefRepairs(root, target) {
     return { proposed: changes, blocked: [] };
 }
 function candidateDuplicateId(baseId, used) {
-    for (let index = 2;; index += 1) {
-        const candidate = `${baseId}-dup-${index}`;
+    const match = /^([a-z]+)-([0-9]+)$/.exec(baseId);
+    if (!match) {
+        throw new errors_1.UsageError(`duplicate id ${baseId} cannot be repaired automatically because it is not a canonical numeric id`);
+    }
+    const prefix = match[1];
+    const start = Number.parseInt(match[2], 10) + 1;
+    for (let index = start;; index += 1) {
+        const candidate = `${prefix}-${index}`;
         if (!used.has(candidate)) {
             used.add(candidate);
             return candidate;
         }
     }
 }
+function gitShow(root, refPath) {
+    const result = (0, child_process_1.spawnSync)("git", ["show", refPath], { cwd: root, encoding: "utf8" });
+    if (result.status !== 0) {
+        return undefined;
+    }
+    return result.stdout;
+}
+function runGitStrict(root, args) {
+    const result = (0, child_process_1.spawnSync)("git", args, { cwd: root, encoding: "utf8" });
+    if (result.status !== 0) {
+        throw new errors_1.UsageError(`git ${args.join(" ")} failed: ${(result.stderr || result.stdout).trim() || "unknown error"}`);
+    }
+}
+function baseRefIdPaths(root, baseRef, files, config) {
+    const pathsById = new Map();
+    if (!baseRef) {
+        return pathsById;
+    }
+    const templateSchemas = (0, template_schema_1.loadTemplateSchemas)(root, config, node_1.ALLOWED_TYPES);
+    for (const absPath of files) {
+        const relativePath = rel(root, absPath);
+        const content = gitShow(root, `${baseRef}:${relativePath}`);
+        if (content === undefined) {
+            continue;
+        }
+        try {
+            const node = (0, node_1.parseNode)(content, absPath, {
+                workStatusEnum: config.work.status_enum,
+                priorityMin: config.work.priority_min,
+                priorityMax: config.work.priority_max,
+                templateSchemas,
+            });
+            if (!pathsById.has(node.id)) {
+                pathsById.set(node.id, new Set());
+            }
+            pathsById.get(node.id)?.add(relativePath);
+        }
+        catch {
+            continue;
+        }
+    }
+    return pathsById;
+}
+function rewriteIdInNodeContent(content, fromId, toId) {
+    const lines = content.split(/\n/);
+    let inFrontmatter = false;
+    let frontmatterClosed = false;
+    let idRewritten = false;
+    const rewritten = lines.map((line, index) => {
+        if (index === 0 && line.trim() === "---") {
+            inFrontmatter = true;
+            return line;
+        }
+        if (inFrontmatter && !frontmatterClosed && line.trim() === "---") {
+            frontmatterClosed = true;
+            inFrontmatter = false;
+            return line;
+        }
+        if (inFrontmatter && !idRewritten && line === `id: ${fromId}`) {
+            idRewritten = true;
+            return `id: ${toId}`;
+        }
+        return line.split(fromId).join(toId);
+    });
+    if (!idRewritten) {
+        throw new errors_1.UsageError(`unable to rewrite id ${fromId}; frontmatter id line not found`);
+    }
+    return rewritten.join("\n");
+}
+function isInsideRoot(root, filePath) {
+    const realRoot = `${relativeRoot(root)}${path_1.default.sep}`;
+    return path_1.default.resolve(filePath).startsWith(realRoot);
+}
+function replaceIdInRelativePath(relativePath, fromId, toId, usedPaths) {
+    const parsed = path_1.default.posix.parse(relativePath);
+    const baseName = parsed.base.includes(fromId)
+        ? parsed.base.replace(fromId, toId)
+        : `${toId}-${parsed.base}`;
+    let candidate = path_1.default.posix.join(parsed.dir, baseName);
+    if (!usedPaths.has(candidate)) {
+        usedPaths.add(candidate);
+        return candidate;
+    }
+    for (let index = 2;; index += 1) {
+        const suffixed = path_1.default.posix.join(parsed.dir, `${parsed.name}-${toId}-${index}${parsed.ext}`);
+        if (!usedPaths.has(suffixed)) {
+            usedPaths.add(suffixed);
+            return suffixed;
+        }
+    }
+}
+function gitConflictStages(root) {
+    const output = runGit(root, ["ls-files", "-u", "--", ".mdkg"]) ?? "";
+    const groups = new Map();
+    for (const line of output.split(/\r?\n/).filter(Boolean)) {
+        const match = /^([0-7]+) ([0-9a-f]+) ([123])\t(.+)$/.exec(line);
+        if (!match || !match[4].endsWith(".md")) {
+            continue;
+        }
+        const entry = {
+            mode: match[1],
+            object: match[2],
+            stage: Number.parseInt(match[3], 10),
+            path: match[4],
+        };
+        groups.set(entry.path, [...(groups.get(entry.path) ?? []), entry]);
+    }
+    return groups;
+}
+function workspaceAliasForPath(root, config, relativePath) {
+    const absPath = path_1.default.resolve(root, relativePath);
+    for (const alias of Object.keys(config.workspaces).sort()) {
+        const entry = config.workspaces[alias];
+        if (!entry.enabled) {
+            continue;
+        }
+        const wsRoot = path_1.default.resolve(root, entry.path, entry.mdkg_dir);
+        if (absPath === wsRoot || absPath.startsWith(`${wsRoot}${path_1.default.sep}`)) {
+            return alias;
+        }
+    }
+    return undefined;
+}
 function filesContaining(root, files, needle) {
     return files
         .filter((filePath) => {
@@ -728,18 +863,118 @@ function referenceRewriteItems(root, files, from, to) {
         .filter((item) => Boolean(item))
         .sort((a, b) => a.path.localeCompare(b.path));
 }
-function planDuplicateIdRepairs(root, target) {
+function planGitStageDuplicateIdRepairs(root, target, config, usedIdsByAlias, usedPaths, startIndex) {
+    const templateSchemas = (0, template_schema_1.loadTemplateSchemas)(root, config, node_1.ALLOWED_TYPES);
+    const proposed = [];
+    let matchedTarget = false;
+    for (const [relativePath, stages] of [...gitConflictStages(root).entries()].sort(([a], [b]) => a.localeCompare(b))) {
+        const ours = stages.find((entry) => entry.stage === 2);
+        const theirs = stages.find((entry) => entry.stage === 3);
+        if (!ours || !theirs) {
+            continue;
+        }
+        const alias = workspaceAliasForPath(root, config, relativePath);
+        if (!alias) {
+            continue;
+        }
+        const oursContent = gitShow(root, `:2:${relativePath}`);
+        const theirsContent = gitShow(root, `:3:${relativePath}`);
+        if (oursContent === undefined || theirsContent === undefined) {
+            continue;
+        }
+        try {
+            const absPath = path_1.default.resolve(root, relativePath);
+            const oursNode = (0, node_1.parseNode)(oursContent, absPath, {
+                workStatusEnum: config.work.status_enum,
+                priorityMin: config.work.priority_min,
+                priorityMax: config.work.priority_max,
+                templateSchemas,
+            });
+            const theirsNode = (0, node_1.parseNode)(theirsContent, absPath, {
+                workStatusEnum: config.work.status_enum,
+                priorityMin: config.work.priority_min,
+                priorityMax: config.work.priority_max,
+                templateSchemas,
+            });
+            if (oursNode.id !== theirsNode.id) {
+                continue;
+            }
+            const duplicateId = oursNode.id;
+            const qid = `${alias}:${duplicateId}`;
+            const targetMatches = !target || target.toLowerCase() === duplicateId || target.toLowerCase() === qid || target === relativePath;
+            if (!targetMatches) {
+                continue;
+            }
+            matchedTarget = true;
+            const usedIds = usedIdsByAlias.get(alias) ?? new Set();
+            usedIds.add(oursNode.id);
+            usedIds.add(theirsNode.id);
+            usedIdsByAlias.set(alias, usedIds);
+            const candidate = candidateDuplicateId(duplicateId, usedIds);
+            const candidatePath = replaceIdInRelativePath(relativePath, duplicateId, candidate, usedPaths);
+            proposed.push({
+                id: `ids.${String(startIndex + proposed.length + 1).padStart(3, "0")}`,
+                family: "ids",
+                risk: "high",
+                status: "planned",
+                reason: "git_stage_duplicate_id",
+                paths: [relativePath, candidatePath],
+                refs: [qid, `${alias}:${candidate}`].sort(),
+                evidence: {
+                    conflict_kind: "git_index_unresolved_duplicate_id",
+                    workspace: alias,
+                    duplicate_id: duplicateId,
+                    conflict_path: relativePath,
+                    canonical_stage: 2,
+                    duplicate_stage: 3,
+                    current_blob: ours.object,
+                    incoming_blob: theirs.object,
+                    deterministic_rule: "keep stage 2 at the conflicted path, rewrite stage 3 to the next unused canonical numeric id and path, then git add both files",
+                },
+                before: {
+                    duplicate_id: duplicateId,
+                    workspace: alias,
+                    conflict_path: relativePath,
+                    canonical_stage: 2,
+                    duplicate_stage: 3,
+                    current_blob: ours.object,
+                    incoming_blob: theirs.object,
+                },
+                after: {
+                    candidate_id: candidate,
+                    candidate_qid: `${alias}:${candidate}`,
+                    candidate_path: candidatePath,
+                    canonical_path: relativePath,
+                    collision_free: true,
+                    deterministic_rule: "keep stage 2 at the conflicted path, rewrite stage 3 to the next unused canonical numeric id and path, then git add both files",
+                },
+                command_hint: `mdkg fix ids --target ${duplicateId} --apply --json`,
+                apply_supported: true,
+                apply_kind: "git_stage_duplicate_id_rewrite",
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return { proposed, matchedTarget };
+}
+function planDuplicateIdRepairs(root, target, baseRef) {
     const config = (0, config_1.loadConfig)(root);
     const templateSchemas = (0, template_schema_1.loadTemplateSchemas)(root, config, node_1.ALLOWED_TYPES);
     const docsByAlias = (0, workspace_files_1.listWorkspaceDocFilesByAlias)(root, config);
     const proposed = [];
     const blocked = [];
+    const usedIdsByAlias = new Map();
+    const usedPaths = new Set();
     let matchedTarget = !target;
     for (const alias of Object.keys(docsByAlias).sort()) {
         const records = [];
         const usedIds = new Set();
         const files = docsByAlias[alias].sort();
+        const basePathsById = baseRefIdPaths(root, baseRef, files, config);
         for (const filePath of files) {
+            usedPaths.add(rel(root, filePath));
             if (path_1.default.basename(filePath) === "core.md" && path_1.default.basename(path_1.default.dirname(filePath)) === "core") {
                 continue;
             }
@@ -762,6 +997,7 @@ function planDuplicateIdRepairs(root, target) {
                 continue;
             }
         }
+        usedIdsByAlias.set(alias, usedIds);
         const groups = new Map();
         for (const record of records) {
             groups.set(record.id, [...(groups.get(record.id) ?? []), record]);
@@ -778,18 +1014,29 @@ function planDuplicateIdRepairs(root, target) {
                 continue;
             }
             matchedTarget = true;
-            const canonical = group[0];
+            const basePaths = basePathsById.get(id);
+            const baseCanonical = basePaths ? group.find((record) => basePaths.has(record.path)) : undefined;
+            const canonical = baseCanonical ?? group[0];
             const referencePaths = filesContaining(root, files, id);
-            const duplicateRecords = group.slice(1);
+            const duplicateRecords = group.filter((record) => record.path !== canonical.path);
             const groupPaths = group.map((record) => record.path).sort();
-            const deterministicRule = "keep the lexicographically first path unchanged; propose <id>-dup-<n> for each later path";
+            const deterministicRule = baseCanonical
+                ? "keep the path that already existed at --base-ref unchanged; propose the next unused canonical numeric id for each other path"
+                : "keep the lexicographically first path unchanged; propose the next unused canonical numeric id for each later path";
             for (const duplicate of duplicateRecords) {
                 const candidate = candidateDuplicateId(id, usedIds);
+                const selfReferenceRewrites = referenceRewriteItems(root, [duplicate.absPath], id, candidate);
+                const externalReferenceRewrites = referenceRewriteItems(root, files.filter((filePath) => filePath !== duplicate.absPath), id, candidate);
+                const safeReferenceRewrites = baseRef
+                    ? externalReferenceRewrites.filter((item) => gitShow(root, `${baseRef}:${item.path}`) === undefined)
+                    : [];
+                const safeReferencePaths = new Set(safeReferenceRewrites.map((item) => item.path));
+                const ambiguousReferenceRewrites = externalReferenceRewrites.filter((item) => !safeReferencePaths.has(item.path));
                 proposed.push({
                     id: `ids.${String(proposed.length + 1).padStart(3, "0")}`,
                     family: "ids",
                     risk: "high",
-                    status: "manual_review",
+                    status: "planned",
                     reason: "duplicate_id",
                     paths: [duplicate.path],
                     refs: Array.from(new Set([canonical.qid, duplicate.qid])).sort(),
@@ -797,6 +1044,8 @@ function planDuplicateIdRepairs(root, target) {
                         conflict_kind: "duplicate_local_id",
                         branch_merge_suspected: true,
                         workspace: alias,
+                        base_ref: baseRef ?? null,
+                        base_ref_canonical: Boolean(baseCanonical),
                         duplicate_id: id,
                         group_size: group.length,
                         group_paths: groupPaths,
@@ -813,6 +1062,7 @@ function planDuplicateIdRepairs(root, target) {
                     before: {
                         duplicate_id: id,
                         workspace: alias,
+                        base_ref: baseRef ?? null,
                         canonical_path: canonical.path,
                         duplicate_path: duplicate.path,
                         duplicate_group: {
@@ -827,14 +1077,23 @@ function planDuplicateIdRepairs(root, target) {
                         collision_free: true,
                         deterministic_rule: deterministicRule,
                         reference_paths: referencePaths,
-                        reference_rewrite_plan: referenceRewriteItems(root, files, id, candidate),
+                        self_reference_rewrites: selfReferenceRewrites,
+                        safe_reference_rewrites: safeReferenceRewrites,
+                        ambiguous_reference_rewrites: ambiguousReferenceRewrites,
+                        reference_rewrite_plan: [...selfReferenceRewrites, ...safeReferenceRewrites, ...ambiguousReferenceRewrites].sort((a, b) => a.path.localeCompare(b.path)),
                     },
-                    command_hint: `review ${duplicate.path} and update id ${id} to ${candidate}`,
-                    apply_supported: false,
+                    command_hint: `mdkg fix apply --family ids --target ${id}${baseRef ? ` --base-ref ${baseRef}` : ""} --json`,
+                    apply_supported: true,
+                    apply_kind: "duplicate_id_rewrite",
                 });
             }
         }
     }
+    const stageRepairs = planGitStageDuplicateIdRepairs(root, target, config, usedIdsByAlias, usedPaths, proposed.length);
+    proposed.push(...stageRepairs.proposed);
+    if (stageRepairs.matchedTarget) {
+        matchedTarget = true;
+    }
     if (!matchedTarget && target) {
         blocked.push({
             id: "ids.target.001",
@@ -881,15 +1140,20 @@ function collectFixPlan(options) {
     const root = relativeRoot(options.root);
     const indexRepairs = selected.includes("index") ? planIndexRepairs(root) : { proposed: [], blocked: [] };
     const refRepairs = selected.includes("refs") ? planRefRepairs(root, options.target) : { proposed: [], blocked: [] };
-    const idRepairs = selected.includes("ids") ? planDuplicateIdRepairs(root, options.target) : { proposed: [], blocked: [] };
+    const idRepairs = selected.includes("ids")
+        ? planDuplicateIdRepairs(root, options.target, options.baseRef)
+        : { proposed: [], blocked: [] };
     const proposedChanges = sortChanges([...indexRepairs.proposed, ...refRepairs.proposed, ...idRepairs.proposed]);
     const blockedChanges = sortChanges([...indexRepairs.blocked, ...refRepairs.blocked, ...idRepairs.blocked]);
+    const supportedApplyCount = proposedChanges.filter((change) => change.apply_supported).length;
+    const unsupportedApplyCount = proposedChanges.filter((change) => !change.apply_supported).length;
     const body = {
         action: "fix.plan",
         schema_version: 1,
         root,
         family,
         target: options.target ?? null,
+        base_ref: options.baseRef ?? null,
         dirty: collectDirtyState(root),
         families: emptyFamilySummaries(selected).map((entry) => ({
             ...entry,
@@ -903,9 +1167,13 @@ function collectFixPlan(options) {
             selected_families: selected,
             proposed_count: proposedChanges.length,
             blocked_count: blockedChanges.length,
-            apply_supported: false,
-            apply_deferred: true,
-            message: "fix apply is not available; this command is review-only and writes no files",
+            apply_supported: supportedApplyCount > 0,
+            apply_deferred: unsupportedApplyCount > 0 || blockedChanges.length > 0,
+            supported_apply_count: supportedApplyCount,
+            unsupported_apply_count: unsupportedApplyCount,
+            message: supportedApplyCount > 0
+                ? "ids-family duplicate-id repairs can be applied with mdkg fix apply --family ids or mdkg fix ids --apply"
+                : "this command is review-only for the selected findings and writes no files",
         },
     };
     const planHash = sha256(body);
@@ -917,6 +1185,171 @@ function collectFixPlan(options) {
         plan_id: `fix-plan-${planHash.slice("sha256:".length, "sha256:".length + 16)}`,
     };
 }
+function normalizeApplyFamily(value) {
+    const family = normalizeFamily(value ?? "ids");
+    if (family !== "ids") {
+        throw new errors_1.UsageError("fix apply currently supports only --family ids");
+    }
+    return "ids";
+}
+function applyDuplicateIdChange(root, change) {
+    if (change.family !== "ids" || change.reason !== "duplicate_id" || change.apply_kind !== "duplicate_id_rewrite") {
+        throw new errors_1.UsageError(`unsupported fix apply change ${change.id}`);
+    }
+    const relativePath = change.paths[0];
+    if (!relativePath) {
+        throw new errors_1.UsageError(`fix apply change ${change.id} is missing a path`);
+    }
+    const absPath = path_1.default.resolve(root, relativePath);
+    if (!isInsideRoot(root, absPath)) {
+        throw new errors_1.UsageError(`fix apply refused path outside repo: ${relativePath}`);
+    }
+    const before = change.before;
+    const after = change.after;
+    const fromId = typeof before.duplicate_id === "string" ? before.duplicate_id : undefined;
+    const toId = typeof after.candidate_id === "string" ? after.candidate_id : undefined;
+    if (!fromId || !toId) {
+        throw new errors_1.UsageError(`fix apply change ${change.id} is missing duplicate id rewrite details`);
+    }
+    const current = fs_1.default.readFileSync(absPath, "utf8");
+    const rewritten = rewriteIdInNodeContent(current, fromId, toId);
+    if (rewritten === current) {
+        throw new errors_1.UsageError(`fix apply change ${change.id} produced no file changes`);
+    }
+    (0, atomic_1.atomicWriteFile)(absPath, rewritten);
+    const afterDetails = change.after;
+    const safeReferenceRewrites = Array.isArray(afterDetails.safe_reference_rewrites)
+        ? afterDetails.safe_reference_rewrites
+        : [];
+    const touchedPaths = new Set([relativePath]);
+    for (const rewrite of safeReferenceRewrites) {
+        if (typeof rewrite.path !== "string" || typeof rewrite.from !== "string" || typeof rewrite.to !== "string") {
+            continue;
+        }
+        const rewriteAbs = path_1.default.resolve(root, rewrite.path);
+        if (!isInsideRoot(root, rewriteAbs) || !fs_1.default.existsSync(rewriteAbs)) {
+            continue;
+        }
+        const rewriteCurrent = fs_1.default.readFileSync(rewriteAbs, "utf8");
+        const rewriteNext = rewriteCurrent.split(rewrite.from).join(rewrite.to);
+        if (rewriteNext !== rewriteCurrent) {
+            (0, atomic_1.atomicWriteFile)(rewriteAbs, rewriteNext);
+            touchedPaths.add(rewrite.path);
+        }
+    }
+    return {
+        id: change.id,
+        family: "ids",
+        reason: change.reason,
+        apply_kind: "duplicate_id_rewrite",
+        path: relativePath,
+        touched_paths: Array.from(touchedPaths).sort(),
+        refs: change.refs,
+        before: change.before,
+        after: change.after,
+    };
+}
+function applyGitStageDuplicateIdChange(root, change) {
+    if (change.family !== "ids" || change.reason !== "git_stage_duplicate_id" || change.apply_kind !== "git_stage_duplicate_id_rewrite") {
+        throw new errors_1.UsageError(`unsupported git-stage fix apply change ${change.id}`);
+    }
+    const before = change.before;
+    const after = change.after;
+    const fromId = typeof before.duplicate_id === "string" ? before.duplicate_id : undefined;
+    const conflictPath = typeof before.conflict_path === "string" ? before.conflict_path : undefined;
+    const candidateId = typeof after.candidate_id === "string" ? after.candidate_id : undefined;
+    const candidatePath = typeof after.candidate_path === "string" ? after.candidate_path : undefined;
+    if (!fromId || !conflictPath || !candidateId || !candidatePath) {
+        throw new errors_1.UsageError(`fix apply change ${change.id} is missing git-stage rewrite details`);
+    }
+    const canonicalContent = gitShow(root, `:2:${conflictPath}`);
+    const duplicateContent = gitShow(root, `:3:${conflictPath}`);
+    if (canonicalContent === undefined || duplicateContent === undefined) {
+        throw new errors_1.UsageError(`fix apply change ${change.id} could not read Git conflict stages for ${conflictPath}`);
+    }
+    const canonicalAbs = path_1.default.resolve(root, conflictPath);
+    const candidateAbs = path_1.default.resolve(root, candidatePath);
+    if (!isInsideRoot(root, canonicalAbs) || !isInsideRoot(root, candidateAbs)) {
+        throw new errors_1.UsageError(`fix apply refused path outside repo while resolving ${conflictPath}`);
+    }
+    const rewrittenDuplicate = rewriteIdInNodeContent(duplicateContent, fromId, candidateId);
+    (0, atomic_1.atomicWriteFile)(canonicalAbs, canonicalContent);
+    (0, atomic_1.atomicWriteFile)(candidateAbs, rewrittenDuplicate);
+    runGitStrict(root, ["add", "--", conflictPath, candidatePath]);
+    return {
+        id: change.id,
+        family: "ids",
+        reason: change.reason,
+        apply_kind: "git_stage_duplicate_id_rewrite",
+        path: conflictPath,
+        touched_paths: [conflictPath, candidatePath],
+        refs: change.refs,
+        before: change.before,
+        after: change.after,
+    };
+}
+function collectFixApply(options) {
+    const family = normalizeApplyFamily(options.family);
+    const root = relativeRoot(options.root);
+    const config = (0, config_1.loadConfig)(root);
+    return (0, lock_1.withMutationLock)(root, config.index.lock_timeout_ms, () => {
+        const plan = collectFixPlan({ ...options, root, family });
+        const applicable = plan.proposed_changes.filter((change) => change.apply_supported);
+        const unsupported = plan.proposed_changes.filter((change) => !change.apply_supported);
+        if (plan.blocked_changes.length > 0) {
+            throw new errors_1.UsageError("fix apply refused because the plan contains blocked changes");
+        }
+        if (applicable.length === 0) {
+            throw new errors_1.UsageError("fix apply found no supported ids-family changes to apply");
+        }
+        const appliedChanges = applicable.map((change) => change.apply_kind === "git_stage_duplicate_id_rewrite"
+            ? applyGitStageDuplicateIdChange(root, change)
+            : applyDuplicateIdChange(root, change));
+        const indexReceipt = (0, index_1.rebuildDerivedIndexCaches)({ root, tolerant: true });
+        const body = {
+            action: "fix.apply",
+            ok: true,
+            schema_version: 1,
+            root,
+            family,
+            target: options.target ?? null,
+            base_ref: options.baseRef ?? null,
+            plan_id: plan.plan_id,
+            plan_hash: plan.plan_hash,
+            applied_changes: appliedChanges,
+            blocked_changes: plan.blocked_changes,
+            unsupported_changes: unsupported,
+            touched_paths: Array.from(new Set(appliedChanges.flatMap((change) => change.touched_paths))).sort(),
+            ambiguous_reference_rewrites: applicable.flatMap((change) => {
+                const after = change.after;
+                return Array.isArray(after.ambiguous_reference_rewrites) ? after.ambiguous_reference_rewrites : [];
+            }),
+            index: {
+                rebuilt: true,
+                paths: {
+                    nodes: rel(root, indexReceipt.paths.nodes),
+                    skills: rel(root, indexReceipt.paths.skills),
+                    capabilities: rel(root, indexReceipt.paths.capabilities),
+                    subgraphs: rel(root, indexReceipt.paths.subgraphs),
+                    sqlite: indexReceipt.paths.sqlite ? rel(root, indexReceipt.paths.sqlite) : null,
+                },
+            },
+            summary: {
+                applied_count: appliedChanges.length,
+                unsupported_count: unsupported.length,
+                blocked_count: plan.blocked_changes.length,
+                message: unsupported.length > 0
+                    ? "applied supported ids-family changes; unsupported findings remain review-only"
+                    : "applied supported ids-family duplicate-id repairs",
+            },
+        };
+        return {
+            ...body,
+            generated_at: new Date().toISOString(),
+            receipt_hash: sha256(body),
+        };
+    });
+}
 function runFixPlanCommand(options) {
     const payload = collectFixPlan(options);
     if (options.json) {
@@ -929,6 +1362,25 @@ function runFixPlanCommand(options) {
     console.log(`family: ${payload.family}`);
     console.log(`proposed_changes: ${payload.proposed_changes.length}`);
     console.log(`blocked_changes: ${payload.blocked_changes.length}`);
-    console.log("apply_supported: false");
-    console.log("note: fix apply is not available; rerun with --json for the machine-readable receipt");
+    console.log(`apply_supported: ${payload.summary.apply_supported}`);
+    console.log("note: use --json for the machine-readable receipt");
+}
+function runFixApplyCommand(options) {
+    const payload = collectFixApply(options);
+    if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log("fix apply");
+    console.log(`receipt_hash: ${payload.receipt_hash}`);
+    console.log(`family: ${payload.family}`);
+    console.log(`applied_changes: ${payload.applied_changes.length}`);
+    console.log(`touched_paths: ${payload.touched_paths.join(", ")}`);
+}
+function runFixIdsCommand(options) {
+    if (options.apply) {
+        runFixApplyCommand({ ...options, family: "ids" });
+        return;
+    }
+    runFixPlanCommand({ ...options, family: "ids" });
 }