sysprom 1.3.0 → 1.4.0

package/dist/src/cli/commands/update.js

@@ -147,13 +147,13 @@ const removeRelSubcommand = {
         const opts = removeRelOpts.parse(rawOpts);
         const loaded = loadDoc(opts.path);
         const { doc } = loaded;
-        const newDoc = removeRelationshipOp({
+        const result = removeRelationshipOp({
             doc,
             from: args.from,
             type: args.type,
             to: args.to,
         });
-        persistDoc(newDoc, loaded, opts);
+        persistDoc(result.doc, loaded, opts);
         if (opts.json) {
             console.log(JSON.stringify({ from: args.from, type: args.type, to: args.to }, null, 2));
         }

package/dist/src/operations/remove-node.d.ts

@@ -602,6 +602,9 @@ export declare const removeNodeOp: import("./define-operation.js").DefinedOperat
         };
     };
     id: z.ZodString;
+    hard: z.ZodOptional<z.ZodBoolean>;
+    recursive: z.ZodOptional<z.ZodBoolean>;
+    repair: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;

package/dist/src/operations/remove-node.js

@@ -17,17 +17,71 @@ export const removeNodeOp = defineOperation({
     input: z.object({
         doc: SysProMDocument,
         id: z.string(),
+        hard: z.boolean().optional(),
+        recursive: z.boolean().optional(),
+        repair: z.boolean().optional(),
     }),
     output: RemoveResult,
-    fn({ doc, id }) {
+    fn({ doc, id, hard, recursive, repair }) {
         const nodeIdx = doc.nodes.findIndex((n) => n.id === id);
         if (nodeIdx === -1) {
             throw new Error(`Node not found: ${id}`);
         }
+        const nodeToRemove = doc.nodes[nodeIdx];
         const warnings = [];
-        // Remove the node
-        const newNodes = doc.nodes.filter((n) => n.id !== id);
-        // Clean up all references to the removed node
+        // Check recursive guard for hard delete
+        if (hard && nodeToRemove.subsystem) {
+            if (!recursive) {
+                throw new Error(`Cannot hard delete node ${id} with subsystem without --recursive flag`);
+            }
+        }
+        let newNodes;
+        let newRelationships = doc.relationships ?? [];
+        if (hard) {
+            // Hard delete: physically remove the node
+            newNodes = doc.nodes.filter((n) => n.id !== id);
+            // Handle must_follow chain repair if requested
+            if (repair) {
+                const incomingChains = newRelationships.filter((r) => r.to === id && r.type === "must_follow");
+                const outgoingChains = newRelationships.filter((r) => r.from === id && r.type === "must_follow");
+                // Remove all relationships involving the deleted node
+                newRelationships = newRelationships.filter((r) => r.from !== id && r.to !== id);
+                // Repair chains by connecting incoming to outgoing
+                // Only repair if there are both incoming AND outgoing chains
+                if (incomingChains.length > 0 && outgoingChains.length > 0) {
+                    for (const incoming of incomingChains) {
+                        for (const outgoing of outgoingChains) {
+                            // Only add if not already connected
+                            const exists = newRelationships.some((r) => r.from === incoming.from &&
+                                r.to === outgoing.to &&
+                                r.type === "must_follow");
+                            if (!exists) {
+                                newRelationships.push({
+                                    from: incoming.from,
+                                    to: outgoing.to,
+                                    type: "must_follow",
+                                });
+                                warnings.push(`Repaired chain: ${incoming.from} → ${outgoing.to}`);
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                // Without repair, just remove all relationships
+                const oldRelCount = newRelationships.length;
+                newRelationships = newRelationships.filter((r) => r.from !== id && r.to !== id);
+                if (newRelationships.length < oldRelCount) {
+                    warnings.push(`Removed relationships involving ${id}`);
+                }
+            }
+        }
+        else {
+            // Soft delete: mark as retired and preserve relationships
+            newNodes = doc.nodes.map((n) => n.id === id ? { ...n, status: "retired" } : n);
+            // Don't remove relationships in soft delete
+        }
+        // Clean up all references to the removed node (both soft and hard)
         const cleanedNodes = newNodes.map((n) => {
             let updated = n;
             // Remove from view includes
@@ -59,12 +113,6 @@ export const removeNodeOp = defineOperation({
             }
             return updated;
         });
-        // Remove relationships involving this node
-        const oldRelCount = (doc.relationships ?? []).length;
-        const newRelationships = (doc.relationships ?? []).filter((r) => r.from !== id && r.to !== id);
-        if (newRelationships.length < oldRelCount) {
-            warnings.push(`Removed relationships involving ${id}`);
-        }
         // Remove from external references
         const newExternalRefs = (doc.external_references ?? []).filter((ref) => ref.node_id !== id);
         return {

package/dist/src/operations/remove-relationship.d.ts

@@ -1,6 +1,7 @@
 import * as z from "zod";
 /**
  * Remove a relationship matching from, type, and to. Returns a new document without it.
+ * Optionally repairs must_follow chains when removal would break them.
  * @throws {Error} If no matching relationship is found.
  */
 export declare const removeRelationshipOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
@@ -329,130 +330,206 @@ export declare const removeRelationshipOp: import("./define-operation.js").Defin
         is(value: unknown): value is "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables";
     };
     to: z.ZodString;
+    repair: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodObject<{
-    $schema: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodObject<{
-        title: z.ZodOptional<z.ZodString>;
-        doc_type: z.ZodOptional<z.ZodString>;
-        scope: z.ZodOptional<z.ZodString>;
-        status: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-    }, z.core.$loose> & {
-        is(value: unknown): value is {
-            [x: string]: unknown;
-            title?: string | undefined;
-            doc_type?: string | undefined;
-            scope?: string | undefined;
-            status?: string | undefined;
-            version?: string | number | undefined;
-        };
-    }>;
-    nodes: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodEnum<{
-            intent: "intent";
-            concept: "concept";
-            capability: "capability";
-            element: "element";
-            realisation: "realisation";
-            invariant: "invariant";
-            principle: "principle";
-            policy: "policy";
-            protocol: "protocol";
-            stage: "stage";
-            role: "role";
-            gate: "gate";
-            mode: "mode";
-            artefact: "artefact";
-            artefact_flow: "artefact_flow";
-            decision: "decision";
-            change: "change";
-            view: "view";
-            milestone: "milestone";
-            version: "version";
-        }> & {
-            is(value: unknown): value is "intent" | "concept" | "capability" | "element" | "realisation" | "invariant" | "principle" | "policy" | "protocol" | "stage" | "role" | "gate" | "mode" | "artefact" | "artefact_flow" | "decision" | "change" | "view" | "milestone" | "version";
-        };
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
-            is(value: unknown): value is string | string[];
-        }>;
-        status: z.ZodOptional<z.ZodEnum<{
-            deprecated: "deprecated";
-            proposed: "proposed";
-            accepted: "accepted";
-            active: "active";
-            implemented: "implemented";
-            adopted: "adopted";
-            defined: "defined";
-            introduced: "introduced";
-            in_progress: "in_progress";
-            complete: "complete";
-            consolidated: "consolidated";
-            experimental: "experimental";
-            retired: "retired";
-            superseded: "superseded";
-            abandoned: "abandoned";
-            deferred: "deferred";
-        }> & {
-            is(value: unknown): value is "deprecated" | "proposed" | "accepted" | "active" | "implemented" | "adopted" | "defined" | "introduced" | "in_progress" | "complete" | "consolidated" | "experimental" | "retired" | "superseded" | "abandoned" | "deferred";
-        }>;
-        lifecycle: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>>;
-        context: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
-            is(value: unknown): value is string | string[];
-        }>;
-        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            description: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
-                is(value: unknown): value is string | string[];
-            };
+    doc: z.ZodObject<{
+        $schema: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            doc_type: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
         }, z.core.$loose> & {
             is(value: unknown): value is {
                 [x: string]: unknown;
-                id: string;
-                description: string | string[];
+                title?: string | undefined;
+                doc_type?: string | undefined;
+                scope?: string | undefined;
+                status?: string | undefined;
+                version?: string | number | undefined;
             };
-        }>>;
-        selected: z.ZodOptional<z.ZodString>;
-        rationale: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
-            is(value: unknown): value is string | string[];
         }>;
-        scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        operations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
             type: z.ZodEnum<{
-                link: "link";
-                add: "add";
-                update: "update";
-                remove: "remove";
-            }>;
-            target: z.ZodOptional<z.ZodString>;
+                intent: "intent";
+                concept: "concept";
+                capability: "capability";
+                element: "element";
+                realisation: "realisation";
+                invariant: "invariant";
+                principle: "principle";
+                policy: "policy";
+                protocol: "protocol";
+                stage: "stage";
+                role: "role";
+                gate: "gate";
+                mode: "mode";
+                artefact: "artefact";
+                artefact_flow: "artefact_flow";
+                decision: "decision";
+                change: "change";
+                view: "view";
+                milestone: "milestone";
+                version: "version";
+            }> & {
+                is(value: unknown): value is "intent" | "concept" | "capability" | "element" | "realisation" | "invariant" | "principle" | "policy" | "protocol" | "stage" | "role" | "gate" | "mode" | "artefact" | "artefact_flow" | "decision" | "change" | "view" | "milestone" | "version";
+            };
+            name: z.ZodString;
             description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
                 is(value: unknown): value is string | string[];
             }>;
-        }, z.core.$loose> & {
-            is(value: unknown): value is {
-                [x: string]: unknown;
-                type: "link" | "add" | "update" | "remove";
-                target?: string | undefined;
-                description?: string | string[] | undefined;
-            };
-        }>>;
-        plan: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            description: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+            status: z.ZodOptional<z.ZodEnum<{
+                deprecated: "deprecated";
+                proposed: "proposed";
+                accepted: "accepted";
+                active: "active";
+                implemented: "implemented";
+                adopted: "adopted";
+                defined: "defined";
+                introduced: "introduced";
+                in_progress: "in_progress";
+                complete: "complete";
+                consolidated: "consolidated";
+                experimental: "experimental";
+                retired: "retired";
+                superseded: "superseded";
+                abandoned: "abandoned";
+                deferred: "deferred";
+            }> & {
+                is(value: unknown): value is "deprecated" | "proposed" | "accepted" | "active" | "implemented" | "adopted" | "defined" | "introduced" | "in_progress" | "complete" | "consolidated" | "experimental" | "retired" | "superseded" | "abandoned" | "deferred";
+            }>;
+            lifecycle: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>>;
+            context: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
                 is(value: unknown): value is string | string[];
+            }>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                    is(value: unknown): value is string | string[];
+                };
+            }, z.core.$loose> & {
+                is(value: unknown): value is {
+                    [x: string]: unknown;
+                    id: string;
+                    description: string | string[];
+                };
+            }>>;
+            selected: z.ZodOptional<z.ZodString>;
+            rationale: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                is(value: unknown): value is string | string[];
+            }>;
+            scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            operations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    link: "link";
+                    add: "add";
+                    update: "update";
+                    remove: "remove";
+                }>;
+                target: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                    is(value: unknown): value is string | string[];
+                }>;
+            }, z.core.$loose> & {
+                is(value: unknown): value is {
+                    [x: string]: unknown;
+                    type: "link" | "add" | "update" | "remove";
+                    target?: string | undefined;
+                    description?: string | string[] | undefined;
+                };
+            }>>;
+            plan: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                description: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                    is(value: unknown): value is string | string[];
+                };
+                done: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            }, z.core.$loose> & {
+                is(value: unknown): value is {
+                    [x: string]: unknown;
+                    description: string | string[];
+                    done?: boolean | undefined;
+                };
+            }>>;
+            propagation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+            includes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            input: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodString>;
+            external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                role: z.ZodEnum<{
+                    output: "output";
+                    input: "input";
+                    context: "context";
+                    evidence: "evidence";
+                    source: "source";
+                    standard: "standard";
+                    prior_art: "prior_art";
+                }> & {
+                    is(value: unknown): value is "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
+                };
+                identifier: z.ZodString;
+                description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                    is(value: unknown): value is string | string[];
+                }>;
+                node_id: z.ZodOptional<z.ZodString>;
+                internalised: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                    is(value: unknown): value is string | string[];
+                }>;
+            }, z.core.$strip> & {
+                is(value: unknown): value is {
+                    role: "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
+                    identifier: string;
+                    description?: string | string[] | undefined;
+                    node_id?: string | undefined;
+                    internalised?: string | string[] | undefined;
+                };
+            }>>;
+            readonly subsystem: z.ZodOptional<z.ZodObject</*elided*/ any, z.core.$strip>>;
+        }, z.core.$loose>>;
+        relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            type: z.ZodEnum<{
+                refines: "refines";
+                realises: "realises";
+                implements: "implements";
+                depends_on: "depends_on";
+                constrained_by: "constrained_by";
+                affects: "affects";
+                supersedes: "supersedes";
+                must_preserve: "must_preserve";
+                performs: "performs";
+                part_of: "part_of";
+                precedes: "precedes";
+                must_follow: "must_follow";
+                blocks: "blocks";
+                routes_to: "routes_to";
+                governed_by: "governed_by";
+                modifies: "modifies";
+                triggered_by: "triggered_by";
+                applies_to: "applies_to";
+                produces: "produces";
+                consumes: "consumes";
+                transforms_into: "transforms_into";
+                selects: "selects";
+                requires: "requires";
+                disables: "disables";
+            }> & {
+                is(value: unknown): value is "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables";
             };
-            done: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                is(value: unknown): value is string | string[];
+            }>;
         }, z.core.$loose> & {
             is(value: unknown): value is {
                 [x: string]: unknown;
-                description: string | string[];
-                done?: boolean | undefined;
+                from: string;
+                to: string;
+                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables";
+                description?: string | string[] | undefined;
             };
         }>>;
-        propagation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
-        includes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        input: z.ZodOptional<z.ZodString>;
-        output: z.ZodOptional<z.ZodString>;
         external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
             role: z.ZodEnum<{
                 output: "output";
@@ -482,114 +559,65 @@ export declare const removeRelationshipOp: import("./define-operation.js").Defin
                 internalised?: string | string[] | undefined;
             };
         }>>;
-        readonly subsystem: z.ZodOptional<z.ZodObject</*elided*/ any, z.core.$strip>>;
-    }, z.core.$loose>>;
-    relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        from: z.ZodString;
-        to: z.ZodString;
-        type: z.ZodEnum<{
-            refines: "refines";
-            realises: "realises";
-            implements: "implements";
-            depends_on: "depends_on";
-            constrained_by: "constrained_by";
-            affects: "affects";
-            supersedes: "supersedes";
-            must_preserve: "must_preserve";
-            performs: "performs";
-            part_of: "part_of";
-            precedes: "precedes";
-            must_follow: "must_follow";
-            blocks: "blocks";
-            routes_to: "routes_to";
-            governed_by: "governed_by";
-            modifies: "modifies";
-            triggered_by: "triggered_by";
-            applies_to: "applies_to";
-            produces: "produces";
-            consumes: "consumes";
-            transforms_into: "transforms_into";
-            selects: "selects";
-            requires: "requires";
-            disables: "disables";
-        }> & {
-            is(value: unknown): value is "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables";
-        };
-        description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
-            is(value: unknown): value is string | string[];
-        }>;
-    }, z.core.$loose> & {
-        is(value: unknown): value is {
-            [x: string]: unknown;
-            from: string;
-            to: string;
-            type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables";
-            description?: string | string[] | undefined;
-        };
-    }>>;
-    external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        role: z.ZodEnum<{
-            output: "output";
-            input: "input";
-            context: "context";
-            evidence: "evidence";
-            source: "source";
-            standard: "standard";
-            prior_art: "prior_art";
-        }> & {
-            is(value: unknown): value is "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
-        };
-        identifier: z.ZodString;
-        description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
-            is(value: unknown): value is string | string[];
-        }>;
-        node_id: z.ZodOptional<z.ZodString>;
-        internalised: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
-            is(value: unknown): value is string | string[];
-        }>;
     }, z.core.$strip> & {
         is(value: unknown): value is {
-            role: "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
-            identifier: string;
-            description?: string | string[] | undefined;
-            node_id?: string | undefined;
-            internalised?: string | string[] | undefined;
-        };
-    }>>;
-}, z.core.$strip> & {
-    is(value: unknown): value is {
-        nodes: {
-            [x: string]: unknown;
-            id: string;
-            type: "intent" | "concept" | "capability" | "element" | "realisation" | "invariant" | "principle" | "policy" | "protocol" | "stage" | "role" | "gate" | "mode" | "artefact" | "artefact_flow" | "decision" | "change" | "view" | "milestone" | "version";
-            name: string;
-            description?: string | string[] | undefined;
-            status?: "deprecated" | "proposed" | "accepted" | "active" | "implemented" | "adopted" | "defined" | "introduced" | "in_progress" | "complete" | "consolidated" | "experimental" | "retired" | "superseded" | "abandoned" | "deferred" | undefined;
-            lifecycle?: Record<string, string | boolean> | undefined;
-            context?: string | string[] | undefined;
-            options?: {
+            nodes: {
                 [x: string]: unknown;
                 id: string;
-                description: string | string[];
-            }[] | undefined;
-            selected?: string | undefined;
-            rationale?: string | string[] | undefined;
-            scope?: string[] | undefined;
-            operations?: {
-                [x: string]: unknown;
-                type: "link" | "add" | "update" | "remove";
-                target?: string | undefined;
+                type: "intent" | "concept" | "capability" | "element" | "realisation" | "invariant" | "principle" | "policy" | "protocol" | "stage" | "role" | "gate" | "mode" | "artefact" | "artefact_flow" | "decision" | "change" | "view" | "milestone" | "version";
+                name: string;
                 description?: string | string[] | undefined;
-            }[] | undefined;
-            plan?: {
+                status?: "deprecated" | "proposed" | "accepted" | "active" | "implemented" | "adopted" | "defined" | "introduced" | "in_progress" | "complete" | "consolidated" | "experimental" | "retired" | "superseded" | "abandoned" | "deferred" | undefined;
+                lifecycle?: Record<string, string | boolean> | undefined;
+                context?: string | string[] | undefined;
+                options?: {
+                    [x: string]: unknown;
+                    id: string;
+                    description: string | string[];
+                }[] | undefined;
+                selected?: string | undefined;
+                rationale?: string | string[] | undefined;
+                scope?: string[] | undefined;
+                operations?: {
+                    [x: string]: unknown;
+                    type: "link" | "add" | "update" | "remove";
+                    target?: string | undefined;
+                    description?: string | string[] | undefined;
+                }[] | undefined;
+                plan?: {
+                    [x: string]: unknown;
+                    description: string | string[];
+                    done?: boolean | undefined;
+                }[] | undefined;
+                propagation?: Record<string, boolean> | undefined;
+                includes?: string[] | undefined;
+                input?: string | undefined;
+                output?: string | undefined;
+                external_references?: {
+                    role: "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
+                    identifier: string;
+                    description?: string | string[] | undefined;
+                    node_id?: string | undefined;
+                    internalised?: string | string[] | undefined;
+                }[] | undefined;
+                subsystem?: /*elided*/ any | undefined;
+            }[];
+            $schema?: string | undefined;
+            metadata?: {
+                [x: string]: unknown;
+                title?: string | undefined;
+                doc_type?: string | undefined;
+                scope?: string | undefined;
+                status?: string | undefined;
+                version?: string | number | undefined;
+            } | undefined;
+            relationships?: {
                 [x: string]: unknown;
-                description: string | string[];
-                done?: boolean | undefined;
+                from: string;
+                to: string;
+                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables";
+                description?: string | string[] | undefined;
             }[] | undefined;
-            propagation?: Record<string, boolean> | undefined;
-            includes?: string[] | undefined;
-            input?: string | undefined;
-            output?: string | undefined;
             external_references?: {
                 role: "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
                 identifier: string;
@@ -597,30 +625,7 @@ export declare const removeRelationshipOp: import("./define-operation.js").Defin
                 node_id?: string | undefined;
                 internalised?: string | string[] | undefined;
             }[] | undefined;
-            subsystem?: /*elided*/ any | undefined;
-        }[];
-        $schema?: string | undefined;
-        metadata?: {
-            [x: string]: unknown;
-            title?: string | undefined;
-            doc_type?: string | undefined;
-            scope?: string | undefined;
-            status?: string | undefined;
-            version?: string | number | undefined;
-        } | undefined;
-        relationships?: {
-            [x: string]: unknown;
-            from: string;
-            to: string;
-            type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables";
-            description?: string | string[] | undefined;
-        }[] | undefined;
-        external_references?: {
-            role: "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
-            identifier: string;
-            description?: string | string[] | undefined;
-            node_id?: string | undefined;
-            internalised?: string | string[] | undefined;
-        }[] | undefined;
+        };
     };
-}>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strip>>;

package/dist/src/operations/remove-relationship.js

@@ -1,8 +1,10 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument, RelationshipType } from "../schema.js";
+import { RemoveResult } from "./remove-node.js";
 /**
  * Remove a relationship matching from, type, and to. Returns a new document without it.
+ * Optionally repairs must_follow chains when removal would break them.
  * @throws {Error} If no matching relationship is found.
  */
 export const removeRelationshipOp = defineOperation({
@@ -13,18 +15,67 @@ export const removeRelationshipOp = defineOperation({
         from: z.string(),
         type: RelationshipType,
         to: z.string(),
+        repair: z.boolean().optional(),
     }),
-    output: SysProMDocument,
-    fn({ doc, from, type, to }) {
+    output: RemoveResult,
+    fn({ doc, from, type, to, repair }) {
         const rels = doc.relationships ?? [];
         const idx = rels.findIndex((r) => r.from === from && r.type === type && r.to === to);
         if (idx === -1) {
             throw new Error(`Relationship not found: ${from} ${type} ${to}`);
         }
-        const newRelationships = rels.filter((r) => !(r.from === from && r.type === type && r.to === to));
+        const warnings = [];
+        // If repair flag is set and this is a must_follow relationship, prepare repairs first
+        const repairs = [];
+        if (repair && type === "must_follow") {
+            // Find all must_follow relationships from the 'to' node (outgoing)
+            const outgoing = rels.filter((r) => r.from === to && r.type === "must_follow");
+            // If there are relationships following the target, repair by connecting the source directly
+            if (outgoing.length > 0) {
+                // Also find all must_follow relationships pointing to the 'from' node (for multi-chain repair)
+                const incoming = rels.filter((r) => r.to === from && r.type === "must_follow");
+                // If there are incoming relationships, connect them all to outgoing targets
+                if (incoming.length > 0) {
+                    for (const inc of incoming) {
+                        for (const out of outgoing) {
+                            const bridgeExists = rels.some((r) => r.from === inc.from &&
+                                r.to === out.to &&
+                                r.type === "must_follow");
+                            if (!bridgeExists) {
+                                repairs.push({
+                                    from: inc.from,
+                                    to: out.to,
+                                    type: "must_follow",
+                                });
+                                warnings.push(`Repaired chain: ${inc.from} → ${out.to}`);
+                            }
+                        }
+                    }
+                }
+                // Always connect the source node to outgoing targets
+                for (const out of outgoing) {
+                    const bridgeExists = rels.some((r) => r.from === from && r.to === out.to && r.type === "must_follow");
+                    if (!bridgeExists) {
+                        repairs.push({
+                            from: from,
+                            to: out.to,
+                            type: "must_follow",
+                        });
+                        warnings.push(`Repaired chain: ${from} → ${out.to}`);
+                    }
+                }
+            }
+        }
+        // Remove the specified relationship and add repairs
+        const newRelationships = rels
+            .filter((r) => !(r.from === from && r.type === type && r.to === to))
+            .concat(repairs);
         return {
-            ...doc,
-            relationships: newRelationships.length > 0 ? newRelationships : undefined,
+            doc: {
+                ...doc,
+                relationships: newRelationships.length > 0 ? newRelationships : undefined,
+            },
+            warnings,
         };
     },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sysprom",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "SysProM — System Provenance Model CLI and library",
   "author": "ExaDev",
   "homepage": "https://exadev.github.io/SysProM",