kibi-cli 0.19.0 → 2.0.0

package/dist/operations/mutation/delete.js

@@ -1,33 +1,391 @@
-import { parseEntityFromList, parseListOfLists } from "../../prolog/codec.js";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { InputError, OperationError } from "../../cli-errors.js";
+import { parseEntityFromList, parseListOfLists, toPrologAtom, } from "../../prolog/codec.js";
+import { listShards, readAllShards, removeRelationshipsFromShards, } from "../../relationships/shards.js";
+import { resolveBranchAttachment } from "../../utils/branch-resolver.js";
 import { buildEntityDeleteAuditGoal } from "./audit.js";
-import { dependentRelationshipsGoal } from "./relationships.js";
+import { RELATIONSHIP_TYPES, dependentRelationshipsGoal, } from "./relationships.js";
 import { saveAtomicMutation, saveMutation } from "./save.js";
+import { normalizeAuthoredSourcePath, renderMarkdownRelationshipDeletion, renderSourceDeletion, renderYamlRelationshipDeletion, resolveContainedSourcePath, writePendingSourceReceipt, } from "./source-authoring.js";
+import { acquireWorkspaceMutationLock, classifySourceMutationFailure, releaseWorkspaceMutationLock, } from "./workspace-mutation-lock.js";
 function requireProlog(context) {
-    if (context.prolog === undefined) {
+    if (context.prolog === undefined)
         throw new Error("Delete operation requires a Prolog runtime");
-    }
     return context.prolog;
 }
+export function assertFilesystemCapableRuntime(fs) {
+    if (!fs) {
+        throw new Error("Relationship source patch requires a filesystem-capable runtime");
+    }
+}
 async function loadEntity(prolog, id) {
     const safeId = id.replaceAll("'", "''");
     const result = await prolog.query(`findall(['${safeId}',Type,Props], kb_entity('${safeId}', Type, Props), Results)`);
-    if (!result.success) {
+    if (!result.success)
         throw new Error(`Failed to load metadata for entity ${id}: ${result.error ?? "Unknown error"}`);
-    }
     const rows = parseListOfLists(result.bindings.Results ?? "[]");
-    if (rows.length === 0) {
+    if (rows.length === 0)
         throw new Error(`Failed to load metadata for entity ${id}: Entity not found`);
-    }
     return { ...parseEntityFromList(rows[0] ?? []), id };
 }
+function isSelector(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const row = value;
+    return ["type", "from", "to"].every((key) => typeof row[key] === "string" && row[key].trim().length > 0);
+}
+function sourceIsAuthored(source) {
+    const normalized = source.replaceAll("\\", "/");
+    if (/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(normalized))
+        return false;
+    return /\.(?:md|mdx|ya?ml)$/i.test(normalized);
+}
+function fileHash(pathname) {
+    if (!existsSync(pathname))
+        return null;
+    return createHash("sha256").update(readFileSync(pathname)).digest("hex");
+}
+// implements REQ-011
+// covered_by TEST-cli-source-relationship-parity-unit
+async function executeRelationshipDeleteUnlocked(selectors, context, onCommitted = () => undefined) {
+    const prolog = requireProlog(context);
+    const allowed = new Set(RELATIONSHIP_TYPES);
+    const errors = [];
+    const errorCodes = [];
+    const seenSelectors = new Set();
+    const attachment = context.branchAttachment ?? resolveBranchAttachment(context.workspaceRoot);
+    if ("error" in attachment)
+        throw new Error(attachment.error);
+    if (attachment.migrationRequired &&
+        (context.branchAttachment !== undefined || context.fs !== undefined)) {
+        throw new Error(`Delete blocked: migrate legacy branch storage first with 'kibi branch migrate --from ${attachment.kbBranch} --to ${attachment.gitBranch} --apply'`);
+    }
+    // Relationship YAML shards are canonical tracked sources. Never patch the
+    // hashed compiled branch store here; sync will rebuild derived state.
+    const shardRoot = path.join(context.workspaceRoot, ".kb");
+    let shardRecords = [];
+    try {
+        shardRecords = readAllShards(shardRoot);
+    }
+    catch (error) {
+        throw new Error(`Relationship deletion preflight failed while reading legacy shards: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const preflight = [];
+    const liveByKey = new Map();
+    const sourcePatches = new Map();
+    for (const selector of selectors) {
+        const selectorKey = `${selector.type}\0${selector.from}\0${selector.to}`;
+        if (seenSelectors.has(selectorKey)) {
+            errors.push(`Duplicate relationship selector: ${selector.type} ${selector.from}->${selector.to}`);
+            errorCodes.push({ code: "duplicate_relationship_selector", selector });
+            continue;
+        }
+        seenSelectors.add(selectorKey);
+        if (!allowed.has(selector.type)) {
+            errors.push(`Unsupported relationship type '${selector.type}'`);
+            errorCodes.push({ code: "unsupported_relationship_type", selector });
+            continue;
+        }
+        const matchingShard = shardRecords.filter((record) => record.type === selector.type &&
+            record.from === selector.from &&
+            record.to === selector.to);
+        const liveResult = await prolog.query(`once(kb_relationship(${toPrologAtom(selector.type)}, ${toPrologAtom(selector.from)}, ${toPrologAtom(selector.to)}))`);
+        let sourceRemoved = false;
+        let authoredSourceKind;
+        if (context.fs) {
+            // Authored YAML symbol relationships remain authoritative even when the
+            // compiled edge or relationship shard is present. Patch the source first
+            // so the next sync cannot recreate a relationship the caller deleted.
+            // Legacy Markdown declarations are authoritative by the same rule.
+            try {
+                const entity = await loadEntity(prolog, selector.from);
+                const source = typeof entity.source === "string" ? entity.source : "";
+                if (sourceIsAuthored(source)) {
+                    authoredSourceKind = /\.(?:ya?ml)$/i.test(source.replaceAll("\\", "/"))
+                        ? "YAML"
+                        : "Markdown";
+                    const relative = normalizeAuthoredSourcePath(context.workspaceRoot, source);
+                    const absolute = resolveContainedSourcePath(context.workspaceRoot, relative);
+                    const isYaml = /\.(?:ya?ml)$/i.test(relative);
+                    const previous = sourcePatches.get(relative);
+                    const before = previous?.before ?? (await context.fs.readFile(absolute));
+                    const current = previous?.after ?? before;
+                    const rendered = isYaml
+                        ? renderYamlRelationshipDeletion(relative, current, selector)
+                        : renderMarkdownRelationshipDeletion(relative, current, selector);
+                    if (rendered.removed) {
+                        sourcePatches.set(relative, {
+                            before,
+                            after: rendered.body,
+                        });
+                        sourceRemoved = true;
+                    }
+                }
+            }
+            catch (error) {
+                if (authoredSourceKind !== undefined) {
+                    throw new Error(`Authored ${authoredSourceKind} relationship deletion failed for ${selector.from}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                // The normal typed preflight below reports a deterministic not-found
+                // or inspection error when no authored source can prove the edge.
+            }
+        }
+        // A canonical shard is authoritative even when the compiled store cannot
+        // materialize the edge (for example, because one endpoint was deleted or
+        // the previous sync reported a dangling relationship).  Such a record is
+        // still safely removable through the public relationship-delete operation.
+        // Only fail preflight when neither the compiled edge nor a canonical shard
+        // record can prove that the requested relationship exists.
+        if (!liveResult.success &&
+            liveResult.error &&
+            matchingShard.length === 0 &&
+            !sourceRemoved) {
+            errors.push(`Failed to inspect ${selector.type} ${selector.from}->${selector.to}: ${liveResult.error ?? "Query failed"}`);
+            errorCodes.push({ code: "relationship_preflight_failed", selector });
+            continue;
+        }
+        const liveExists = liveResult.success;
+        if (!liveExists && matchingShard.length === 0 && !sourceRemoved) {
+            errors.push(`Relationship does not exist: ${selector.type} ${selector.from}->${selector.to}`);
+            errorCodes.push({ code: "relationship_not_found", selector });
+            continue;
+        }
+        liveByKey.set(selectorKey, liveExists);
+        preflight.push(selector);
+    }
+    if (errors.length > 0)
+        return {
+            deleted: 0,
+            relationships_deleted: 0,
+            skipped: errors.length,
+            errors,
+            error_codes: errorCodes,
+            relationship_results: [],
+        };
+    // Keep byte-level before-images for rollback. Re-serializing parsed records
+    // would silently discard comments, ordering, and CST trivia from unrelated
+    // shard records after a later compiled-store failure.
+    const originalShardBytes = new Map(listShards(shardRoot).map((shardPath) => [
+        shardPath,
+        readFileSync(shardPath, "utf8"),
+    ]));
+    const originalShardHashes = new Map(listShards(shardRoot).map((shardPath) => [shardPath, fileHash(shardPath)]));
+    let shardRemovals;
+    try {
+        shardRemovals = removeRelationshipsFromShards(shardRoot, preflight);
+    }
+    catch (error) {
+        // A shard publication can fail after one of the deterministic renames.
+        // Restore every preflight image before surfacing the error so canonical
+        // source remains authoritative even when the compiled retract never ran.
+        try {
+            for (const [shardPath, body] of originalShardBytes) {
+                writeFileSync(shardPath, body, "utf8");
+            }
+        }
+        catch (rollbackError) {
+            throw new Error(`reconciliation_required: relationship shard preflight failed and rollback failed (${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)})`);
+        }
+        throw new Error(`Relationship shard update failed before compiled mutation: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const writeSourcePatch = async (relative, body) => {
+        assertFilesystemCapableRuntime(context.fs);
+        const absolute = resolveContainedSourcePath(context.workspaceRoot, relative);
+        await context.fs.mkdir(path.dirname(absolute));
+        const temporary = `${absolute}.kibi-relationship-${process.pid}-${randomUUID()}`;
+        try {
+            await context.fs.writeFile(temporary, body);
+            if (context.fs.rename)
+                await context.fs.rename(temporary, absolute);
+            else {
+                await context.fs.writeFile(absolute, body);
+                await context.fs.unlink?.(temporary).catch(() => undefined);
+            }
+        }
+        catch (error) {
+            // A failed rename must not leak the unique temp file into the authored
+            // tree; the published target (if any) is untouched at this point.
+            await context.fs.unlink?.(temporary).catch(() => undefined);
+            throw error;
+        }
+    };
+    try {
+        for (const [relative, patch] of sourcePatches) {
+            await writeSourcePatch(relative, patch.after);
+        }
+    }
+    catch (error) {
+        for (const [relative, patch] of sourcePatches) {
+            try {
+                await writeSourcePatch(relative, patch.before);
+            }
+            catch {
+                // Preserve the original error; the caller can recover from the
+                // hash-bound source state on the next invocation.
+            }
+        }
+        throw new Error(`Relationship source update failed before compiled mutation: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let retracted = 0;
+    try {
+        for (const selector of preflight) {
+            const selectorKey = `${selector.type}\0${selector.from}\0${selector.to}`;
+            if (liveByKey.get(selectorKey) !== true)
+                continue;
+            const result = await prolog.query(`kb_retract_relationship(${toPrologAtom(selector.type)}, ${toPrologAtom(selector.from)}, ${toPrologAtom(selector.to)})`);
+            if (!result.success)
+                throw new Error(result.error ?? "Query failed");
+            retracted += 1;
+        }
+        if (retracted > 0)
+            await saveMutation(prolog, "delete");
+        // The compiled mutation is now authoritative. Receipt publication below
+        // must not make the enclosing operation look retryable.
+        onCommitted();
+    }
+    catch (error) {
+        const paths = [
+            ...new Set(shardRemovals.flatMap((item) => item.shardPaths)),
+        ];
+        try {
+            for (const [shardPath, body] of originalShardBytes)
+                writeFileSync(shardPath, body, "utf8");
+            for (const [relative, patch] of sourcePatches) {
+                await writeSourcePatch(relative, patch.before);
+            }
+        }
+        catch (rollbackError) {
+            throw new Error(`reconciliation_required: compiled relationship retraction failed and shard rollback failed (${paths.join(", ")}): ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+        }
+        throw new Error(`Relationship retraction failed; canonical relationship shards were restored (${paths.join(", ")}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const sourceWrites = Array.from(new Set(shardRemovals.flatMap((item) => item.shardPaths))).flatMap((shardPath) => {
+        const before = originalShardHashes.get(shardPath) ?? null;
+        const after = fileHash(shardPath);
+        if (before === after)
+            return [];
+        const relative = path
+            .relative(context.workspaceRoot, shardPath)
+            .replaceAll("\\", "/");
+        if (after !== null) {
+            writePendingSourceReceipt(context.workspaceRoot, relative, after);
+        }
+        return [
+            {
+                path: relative,
+                mode: "write",
+                beforeHash: before,
+                afterHash: after,
+                created: false,
+            },
+        ];
+    });
+    sourceWrites.push(...Array.from(sourcePatches, ([relative, patch]) => {
+        const beforeHash = createHash("sha256")
+            .update(patch.before)
+            .digest("hex");
+        const afterHash = createHash("sha256").update(patch.after).digest("hex");
+        writePendingSourceReceipt(context.workspaceRoot, relative, afterHash);
+        return {
+            path: relative,
+            mode: "write",
+            beforeHash,
+            afterHash,
+            created: false,
+        };
+    }));
+    return {
+        deleted: 0,
+        relationships_deleted: retracted,
+        skipped: 0,
+        errors: [],
+        error_codes: [],
+        relationship_results: preflight.map((selector, index) => ({
+            ...selector,
+            deleted: true,
+            shard_records_removed: shardRemovals[index]?.removed ?? false,
+            compiled_edge_retracted: liveByKey.get(`${selector.type}\0${selector.from}\0${selector.to}`) ===
+                true,
+        })),
+        sync_required: shardRemovals.some((item) => item.removed) || sourcePatches.size > 0,
+        ...(sourceWrites.length > 0 ? { sourceWrites } : {}),
+    };
+}
+export async function executeRelationshipDelete(selectors, context, onCommitted = () => undefined) {
+    if (!context.fs || context.sourceMutationLockHeld === true)
+        return executeRelationshipDeleteUnlocked(selectors, context, onCommitted);
+    const lock = await acquireWorkspaceMutationLock(context.workspaceRoot);
+    let operationFailure;
+    let committed = false;
+    try {
+        const result = await executeRelationshipDeleteUnlocked(selectors, context, () => {
+            committed = true;
+            onCommitted();
+        });
+        committed = true;
+        return result;
+    }
+    catch (error) {
+        const failure = classifySourceMutationFailure("Relationship delete", error, committed);
+        operationFailure = { error: failure };
+        throw failure;
+    }
+    finally {
+        releaseWorkspaceMutationLock(lock, operationFailure, committed);
+    }
+}
 export async function executeDelete(input, context) {
+    const branchAttachment = context.branchAttachment ?? resolveBranchAttachment(context.workspaceRoot);
+    if ("error" in branchAttachment) {
+        throw new Error(`Unable to resolve KB branch: ${branchAttachment.error}`);
+    }
+    if (branchAttachment.migrationRequired &&
+        (context.branchAttachment !== undefined || context.fs !== undefined)) {
+        throw new Error(`Delete blocked: KB is attached through legacy branch storage (${branchAttachment.gitBranch} -> ${branchAttachment.kbBranch}). Run 'kibi branch migrate --from ${branchAttachment.kbBranch} --to ${branchAttachment.gitBranch} --apply' first.`);
+    }
     const prolog = requireProlog(context);
-    if (input.ids.length === 0)
-        throw new Error("At least one ID required for delete");
+    let sourceMutationLock;
+    let committed = false;
+    let operationFailure;
     try {
+        if (context.fs && context.sourceMutationLockHeld !== true) {
+            sourceMutationLock = await acquireWorkspaceMutationLock(context.workspaceRoot);
+        }
+        const ids = input.ids ?? [];
+        const relationships = input.relationships ?? [];
+        if ((ids.length === 0) === (relationships.length === 0))
+            throw new Error("Delete requires exactly one non-empty input: ids or relationships");
+        if (relationships.length > 0) {
+            if (relationships.some((value) => !isSelector(value)))
+                throw new Error("Each relationship selector requires non-empty type, from, and to strings");
+            const payload = await executeRelationshipDelete(relationships, { ...context, sourceMutationLockHeld: true }, () => {
+                committed = true;
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Deleted ${payload.relationships_deleted ?? 0} relationships. Skipped ${payload.skipped}.${payload.sync_required ? " Run kibi sync to reconcile the relationship shard." : ""}`,
+                    },
+                ],
+                structuredContent: payload,
+            };
+        }
         const errors = [];
         const goals = [];
-        for (const id of input.ids) {
+        const authoredIds = [];
+        const authoredRequirementIds = [];
+        const sourceHashes = {};
+        // Keep the original body for rollback, while applying each deletion to the
+        // body produced by the previous deletion. A deletion plan must contain one
+        // hash-bound write per authored path; otherwise apply-plan's last write can
+        // resurrect an earlier record when multiple IDs share one manifest.
+        const sourceBodies = new Map();
+        const evolvingSourceBodies = new Map();
+        const sourcePlansByPath = new Map();
+        for (const id of ids) {
             const safeId = id.replaceAll("'", "''");
             const exists = await prolog.query(`once(kb_entity('${safeId}', _, _))`);
             if (!exists.success) {
@@ -43,13 +401,102 @@ export async function executeDelete(input, context) {
                 errors.push(`Cannot delete entity ${id}: has dependents (other entities reference it)`);
                 continue;
             }
-            goals.push(buildEntityDeleteAuditGoal(await loadEntity(prolog, id)));
+            const entity = await loadEntity(prolog, id);
+            const source = typeof entity.source === "string" ? entity.source : "";
+            if (sourceIsAuthored(source)) {
+                authoredIds.push(id);
+                if (entity.type === "req")
+                    authoredRequirementIds.push(id);
+                if (context.fs) {
+                    const relativeSource = normalizeAuthoredSourcePath(context.workspaceRoot, source);
+                    const sourcePath = path.join(context.workspaceRoot, relativeSource);
+                    try {
+                        const original = sourceBodies.get(relativeSource) ??
+                            (await context.fs.readFile(sourcePath));
+                        if (!sourceBodies.has(relativeSource)) {
+                            sourceBodies.set(relativeSource, original);
+                        }
+                        const contents = evolvingSourceBodies.has(relativeSource)
+                            ? evolvingSourceBodies.get(relativeSource)
+                            : original;
+                        if (contents === undefined) {
+                            throw new Error(`Authored document ${relativeSource} no longer contains ${id}`);
+                        }
+                        const deletion = renderSourceDeletion(relativeSource, id, String(entity.type), contents);
+                        evolvingSourceBodies.set(relativeSource, deletion.mode === "write" ? deletion.body : undefined);
+                        const beforeHash = createHash("sha256")
+                            .update(original)
+                            .digest("hex");
+                        const afterHash = deletion.body === undefined
+                            ? null
+                            : createHash("sha256").update(deletion.body).digest("hex");
+                        sourceHashes[relativeSource] = beforeHash;
+                        sourcePlansByPath.set(relativeSource, {
+                            path: relativeSource,
+                            mode: deletion.mode,
+                            beforeHash,
+                            afterHash,
+                            ...(deletion.body === undefined ? {} : { body: deletion.body }),
+                        });
+                    }
+                    catch {
+                        sourceHashes[relativeSource] = null;
+                    }
+                }
+            }
+            goals.push(buildEntityDeleteAuditGoal(entity));
         }
-        if (goals.length > 0)
-            await saveAtomicMutation(prolog, goals, "delete");
-        else
-            await saveMutation(prolog, "delete");
-        const payload = { deleted: goals.length, skipped: errors.length, errors };
+        if (authoredIds.length > 0 && context.sourcePlanApplication !== true) {
+            const supersessionRequired = authoredRequirementIds.length > 0;
+            const sourcePlans = [...sourcePlansByPath.values()];
+            const planBody = {
+                version: "kibi.entity-deletion-plan.v1",
+                entityIds: authoredIds,
+                sourceHashes,
+                sourceWrites: sourcePlans,
+                supersessionRequired,
+            };
+            const planHash = createHash("sha256")
+                .update(JSON.stringify(planBody))
+                .digest("hex");
+            const payload = {
+                deleted: 0,
+                skipped: authoredIds.length,
+                errors: [
+                    supersessionRequired
+                        ? "Authored requirements require an explicit supersession plan; no direct delete is performed."
+                        : "Authored entity deletion returns a hash-bound plan for kb_apply_plan.",
+                ],
+                deletionPlan: { ...planBody, planHash },
+            };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Deletion plan ${planHash.slice(0, 12)} must be applied through kb_apply_plan.`,
+                    },
+                ],
+                structuredContent: payload,
+            };
+        }
+        try {
+            if (goals.length > 0)
+                await saveAtomicMutation(prolog, goals, "delete");
+            else
+                await saveMutation(prolog, "delete");
+            committed = true;
+        }
+        catch (error) {
+            for (const [source, body] of sourceBodies) {
+                await context.fs?.writeFile(resolveContainedSourcePath(context.workspaceRoot, source), body);
+            }
+            throw error;
+        }
+        const payload = {
+            deleted: goals.length,
+            skipped: errors.length,
+            errors,
+        };
         return {
             content: [
                 {
@@ -61,7 +508,24 @@ export async function executeDelete(input, context) {
         };
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Delete execution failed: ${message}`);
+        // Typed operation errors keep their code and retryability. After the
+        // commit milestone, a generic failure is already a committed mutation:
+        // wrap it as non-retryable immediately instead of only when lock release
+        // also fails.
+        if (error instanceof OperationError || error instanceof InputError) {
+            operationFailure = { error };
+            throw error;
+        }
+        if (committed) {
+            const failure = classifySourceMutationFailure("Delete", error, true);
+            operationFailure = { error: failure };
+            throw failure;
+        }
+        const failure = new Error(`Delete execution failed: ${error instanceof Error ? error.message : String(error)}`);
+        operationFailure = { error: failure };
+        throw failure;
+    }
+    finally {
+        releaseWorkspaceMutationLock(sourceMutationLock, operationFailure, committed);
     }
 }

package/dist/operations/mutation/entity-projection.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Convert a query-shaped entity back into writable properties.
+ *
+ * Discovery queries project relationship predicates alongside entity
+ * properties for convenience. Feeding that projection back to an upsert would
+ * accidentally treat those predicates as authored properties and can create
+ * duplicate or stale edges. Keep this helper shared by every query-to-write
+ * path so relationship history remains owned by the relationship input lane.
+ */
+export declare function projectEntityProperties(entity: Readonly<Record<string, unknown>>): Record<string, unknown>;
+//# sourceMappingURL=entity-projection.d.ts.map

package/dist/operations/mutation/entity-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-projection.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/entity-projection.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOzB"}

package/dist/operations/mutation/entity-projection.js

@@ -0,0 +1,14 @@
+import { RELATIONSHIP_TYPES } from "./relationships.js";
+/**
+ * Convert a query-shaped entity back into writable properties.
+ *
+ * Discovery queries project relationship predicates alongside entity
+ * properties for convenience. Feeding that projection back to an upsert would
+ * accidentally treat those predicates as authored properties and can create
+ * duplicate or stale edges. Keep this helper shared by every query-to-write
+ * path so relationship history remains owned by the relationship input lane.
+ */
+export function projectEntityProperties(entity) {
+    const relationshipKeys = new Set(RELATIONSHIP_TYPES);
+    return Object.fromEntries(Object.entries(entity).filter(([key]) => key !== "id" && key !== "type" && !relationshipKeys.has(key)));
+}

package/dist/operations/mutation/relationships.d.ts

@@ -1,5 +1,8 @@
 import type { PrologPort } from "../../public/operations/runtime-types.js";
 import type { RelationshipInput } from "./types.js";
+export declare const RELATIONSHIP_TYPES: readonly ["depends_on", "specified_by", "verified_by", "validates", "implements", "covered_by", "executable_for", "constrained_by", "constrains", "requires_property", "requires_predicate", "requires_rule", "guards", "publishes", "consumes", "supersedes", "relates_to"];
+export type RelationshipType = (typeof RELATIONSHIP_TYPES)[number];
+export declare function wrongKindRelationshipError(type: string, target: string, wrongKind: string): Error;
 export declare function dependentRelationshipsGoal(entityId: string): string;
 type RelationshipTuple = {
     readonly relType: string;
@@ -9,6 +12,14 @@ type RelationshipTuple = {
 export declare function formatInvalidRelationshipTuple(tuple: RelationshipTuple): string;
 export declare function formatInvalidRelationshipError(raw: string): string | null;
 export declare function validateRelationshipSources(entityId: string, relationships: readonly RelationshipInput[]): void;
+type SupersedesHistory = "valid" | "reversed" | "unknown";
+type SupersedesHistoryDeps = Readonly<{
+    firstAdditionCommit: (workspaceRoot: string, source: string) => string | null;
+    isAncestor: (workspaceRoot: string, ancestor: string, descendant: string) => boolean | null;
+}>;
+export declare function firstGitAdditionCommit(workspaceRoot: string, source: string): string | null;
+export declare function classifySupersedesHistory(workspaceRoot: string, sourceCommit: string | null, targetCommit: string | null, deps?: Pick<SupersedesHistoryDeps, "isAncestor">): SupersedesHistory;
+export declare function validateSupersedesSourceHistory(prolog: PrologPort, entity: Readonly<Record<string, unknown>>, relationships: readonly RelationshipInput[], workspaceRoot: string, deps?: SupersedesHistoryDeps): Promise<void>;
 export declare function formatRelationshipSourceMismatch(entityId: string, relationship: RelationshipInput): string;
 export declare function validateLiveRelationshipTargets(prolog: PrologPort, entity: Readonly<Record<string, unknown>>, relationships: readonly RelationshipInput[]): Promise<void>;
 export declare function validateStrictLanePairing(prolog: PrologPort, relationships: readonly RelationshipInput[]): Promise<void>;

package/dist/operations/mutation/relationships.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relationships.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/relationships.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAE3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAsBpD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED,KAAK,iBAAiB,GAAG;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAgCF,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,iBAAiB,GACvB,MAAM,CAER;AAED,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAczE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,IAAI,CAMN;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,iBAAiB,GAC9B,MAAM,CAIR;AAuBD,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,OAAO,CAAC,IAAI,CAAC,CAuBf;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,OAAO,CAAC,IAAI,CAAC,CAgCf;AAED,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAevC"}
+{"version":3,"file":"relationships.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/relationships.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAE3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,eAAO,MAAM,kBAAkB,8QAkBrB,CAAC;AACX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnE,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,KAAK,CAKP;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED,KAAK,iBAAiB,GAAG;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAgCF,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,iBAAiB,GACvB,MAAM,CAER;AAED,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAczE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,IAAI,CAMN;AAED,KAAK,iBAAiB,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;AAE1D,KAAK,qBAAqB,GAAG,QAAQ,CAAC;IACpC,mBAAmB,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAC9E,UAAU,EAAE,CACV,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,KACf,OAAO,GAAG,IAAI,CAAC;CACrB,CAAC,CAAC;AAMH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GACb,MAAM,GAAG,IAAI,CAef;AAsBD,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,IAAI,GAAE,IAAI,CACR,qBAAqB,EACrB,YAAY,CACqB,GAClC,iBAAiB,CAenB;AAGD,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,aAAa,EAAE,SAAS,iBAAiB,EAAE,EAC3C,aAAa,EAAE,MAAM,EACrB,IAAI,GAAE,qBAAuD,GAC5D,OAAO,CAAC,IAAI,CAAC,CAyCf;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,iBAAiB,GAC9B,MAAM,CAIR;AAuBD,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,OAAO,CAAC,IAAI,CAAC,CAuBf;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,OAAO,CAAC,IAAI,CAAC,CA+Bf;AAED,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAevC"}