sysprom 1.14.0 → 1.15.0

package/dist/src/operations/infer-impact.js

@@ -0,0 +1,144 @@
+import * as z from "zod";
+import { defineOperation } from "./define-operation.js";
+import { Node, SysProMDocument } from "../schema.js";
+/**
+ * Impact node in the impact trace.
+ */
+const ImpactNode = z.object({
+    id: z.string(),
+    node: Node.optional(),
+    impactType: z.enum(["direct", "transitive", "potential"]),
+    distance: z.number().int().nonnegative(),
+});
+/**
+ * Output schema for inferImpactOp.
+ */
+const ImpactOutput = z.object({
+    sourceId: z.string(),
+    impactedNodes: z.array(ImpactNode),
+    summary: z.object({
+        direct: z.number(),
+        transitive: z.number(),
+        potential: z.number(),
+        total: z.number(),
+    }),
+});
+/**
+ * Relationship types that indicate impact propagation.
+ */
+const IMPACT_RELATIONSHIPS = new Set([
+    "affects",
+    "depends_on",
+    "modifies",
+    "constrained_by",
+    "requires",
+    "produces",
+    "consumes",
+]);
+/**
+ * Relationship types that indicate potential impact (weaker signal).
+ */
+const POTENTIAL_IMPACT_RELATIONSHIPS = new Set([
+    "part_of",
+    "governed_by",
+    "must_follow",
+]);
+/**
+ * Infer impact from a starting node through the graph.
+ *
+ * Traces impact propagation through affect, dependency, and modification
+ * relationships, categorising nodes as directly impacted, transitively
+ * impacted, or potentially impacted.
+ */
+export const inferImpactOp = defineOperation({
+    name: "infer-impact",
+    description: "Infer impact from a node through the graph following impact relationships",
+    input: z.object({
+        doc: SysProMDocument,
+        startId: z.string(),
+    }),
+    output: ImpactOutput,
+    fn: (input) => {
+        const nodeMap = new Map(input.doc.nodes.map((n) => [n.id, n]));
+        const visited = new Set();
+        const impactedNodes = [];
+        // Mark source as visited to exclude it from results
+        visited.add(input.startId);
+        // BFS traversal with impact type tracking
+        const queue = [];
+        // Start with direct impacts
+        const directImpacts = (input.doc.relationships ?? [])
+            .filter((r) => r.from === input.startId && IMPACT_RELATIONSHIPS.has(r.type))
+            .map((r) => r.to);
+        const potentialImpacts = (input.doc.relationships ?? [])
+            .filter((r) => r.from === input.startId &&
+            POTENTIAL_IMPACT_RELATIONSHIPS.has(r.type))
+            .map((r) => r.to);
+        // Add direct impacts to queue
+        for (const id of directImpacts) {
+            queue.push({ id, distance: 1, impactType: "direct" });
+        }
+        // Add potential impacts to queue
+        for (const id of potentialImpacts) {
+            if (!directImpacts.includes(id)) {
+                queue.push({ id, distance: 1, impactType: "potential" });
+            }
+        }
+        // BFS traversal
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current)
+                break;
+            if (visited.has(current.id))
+                continue;
+            visited.add(current.id);
+            const node = nodeMap.get(current.id);
+            impactedNodes.push({
+                id: current.id,
+                node,
+                impactType: current.impactType,
+                distance: current.distance,
+            });
+            // Find transitive impacts
+            const transitiveImpacts = (input.doc.relationships ?? [])
+                .filter((r) => r.from === current.id &&
+                (IMPACT_RELATIONSHIPS.has(r.type) ||
+                    POTENTIAL_IMPACT_RELATIONSHIPS.has(r.type)))
+                .map((r) => ({
+                id: r.to,
+                impactType: current.distance >= 1
+                    ? "transitive"
+                    : current.impactType,
+            }));
+            for (const impact of transitiveImpacts) {
+                if (!visited.has(impact.id)) {
+                    queue.push({
+                        id: impact.id,
+                        distance: current.distance + 1,
+                        impactType: impact.impactType,
+                    });
+                }
+            }
+        }
+        // Sort by distance, then by impact type priority
+        const impactPriority = { direct: 0, transitive: 1, potential: 2 };
+        impactedNodes.sort((a, b) => {
+            if (a.distance !== b.distance)
+                return a.distance - b.distance;
+            return impactPriority[a.impactType] - impactPriority[b.impactType];
+        });
+        const summary = {
+            direct: impactedNodes.filter((n) => n.impactType === "direct").length,
+            transitive: impactedNodes.filter((n) => n.impactType === "transitive")
+                .length,
+            potential: impactedNodes.filter((n) => n.impactType === "potential")
+                .length,
+            total: impactedNodes.length,
+        };
+        return {
+            sourceId: input.startId,
+            impactedNodes,
+            summary,
+        };
+    },
+});

package/dist/src/operations/infer-lifecycle.d.ts

@@ -0,0 +1,421 @@
+import * as z from "zod";
+/**
+ * Lifecycle inference result for a single node.
+ */
+declare const LifecycleResult: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    name: 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]>>>;
+    inferredState: z.ZodString;
+    inferredPhase: z.ZodEnum<{
+        unknown: "unknown";
+        early: "early";
+        middle: "middle";
+        late: "late";
+        terminal: "terminal";
+    }>;
+}, z.core.$strip>;
+/** Lifecycle inference result for a single node. */
+export type LifecycleResult = z.infer<typeof LifecycleResult>;
+/**
+ * Output schema for inferLifecycleOp.
+ */
+declare const LifecycleOutput: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        name: 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]>>>;
+        inferredState: z.ZodString;
+        inferredPhase: z.ZodEnum<{
+            unknown: "unknown";
+            early: "early";
+            middle: "middle";
+            late: "late";
+            terminal: "terminal";
+        }>;
+    }, z.core.$strip>>;
+    summary: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+/** Output of lifecycle inference operation. */
+export type LifecycleOutput = z.infer<typeof LifecycleOutput>;
+/**
+ * Infer lifecycle state for all nodes based on status and lifecycle fields.
+ *
+ * Returns inferred state, phase classification, and summary statistics.
+ */
+export declare const inferLifecycleOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
+    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;
+                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[];
+                };
+            }, 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";
+            };
+            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?: {
+                    [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;
+                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;
+        };
+    };
+}, z.core.$strip>, z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        name: 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]>>>;
+        inferredState: z.ZodString;
+        inferredPhase: z.ZodEnum<{
+            unknown: "unknown";
+            early: "early";
+            middle: "middle";
+            late: "late";
+            terminal: "terminal";
+        }>;
+    }, z.core.$strip>>;
+    summary: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>>;
+export {};

package/dist/src/operations/infer-lifecycle.js

@@ -0,0 +1,119 @@
+import * as z from "zod";
+import { defineOperation } from "./define-operation.js";
+import { SysProMDocument, NodeStatus } from "../schema.js";
+/**
+ * Lifecycle inference result for a single node.
+ */
+const LifecycleResult = z.object({
+    id: z.string(),
+    type: z.string(),
+    name: z.string(),
+    status: NodeStatus.optional(),
+    lifecycle: z
+        .record(z.string(), z.union([z.boolean(), z.string()]))
+        .optional(),
+    inferredState: z.string(),
+    inferredPhase: z.enum(["early", "middle", "late", "terminal", "unknown"]),
+});
+/**
+ * Output schema for inferLifecycleOp.
+ */
+const LifecycleOutput = z.object({
+    nodes: z.array(LifecycleResult),
+    summary: z.record(z.string(), z.number()),
+});
+/**
+ * Lifecycle phases based on typical progression.
+ */
+const PHASE_MAP = {
+    proposed: "early",
+    accepted: "early",
+    defined: "early",
+    in_progress: "middle",
+    active: "middle",
+    experimental: "middle",
+    implemented: "late",
+    adopted: "late",
+    introduced: "late",
+    complete: "late",
+    consolidated: "late",
+    deprecated: "terminal",
+    retired: "terminal",
+    superseded: "terminal",
+    abandoned: "terminal",
+    deferred: "terminal",
+};
+/**
+ * Determine the most advanced lifecycle state from lifecycle record.
+ * @param lifecycle - The lifecycle record to analyse.
+ * @returns The most advanced state name, or null if no active states.
+ * @example
+ * ```ts
+ * getMostAdvancedState({ proposed: true, accepted: "2024-01-15" });
+ * // Returns "accepted"
+ * ```
+ */
+function getMostAdvancedState(lifecycle) {
+    if (!lifecycle)
+        return null;
+    // Find states that are true or have a date string
+    const activeStates = Object.entries(lifecycle)
+        .filter(([, value]) => value === true || typeof value === "string")
+        .map(([state]) => state);
+    if (activeStates.length === 0)
+        return null;
+    // Return the last active state (assumes ordered by progression)
+    return activeStates[activeStates.length - 1];
+}
+/**
+ * Infer lifecycle state for all nodes based on status and lifecycle fields.
+ *
+ * Returns inferred state, phase classification, and summary statistics.
+ */
+export const inferLifecycleOp = defineOperation({
+    name: "infer-lifecycle",
+    description: "Infer lifecycle state for nodes based on status and lifecycle fields",
+    input: z.object({
+        doc: SysProMDocument,
+    }),
+    output: LifecycleOutput,
+    fn: (input) => {
+        const results = [];
+        const summary = {
+            early: 0,
+            middle: 0,
+            late: 0,
+            terminal: 0,
+            unknown: 0,
+        };
+        for (const node of input.doc.nodes) {
+            // Determine inferred state from lifecycle or status
+            let inferredState;
+            let inferredPhase;
+            const lifecycleState = getMostAdvancedState(node.lifecycle);
+            if (lifecycleState) {
+                inferredState = lifecycleState;
+                inferredPhase = PHASE_MAP[lifecycleState] ?? "unknown";
+            }
+            else if (node.status) {
+                inferredState = node.status;
+                inferredPhase = PHASE_MAP[node.status] ?? "unknown";
+            }
+            else {
+                inferredState = "undefined";
+                inferredPhase = "unknown";
+            }
+            summary[inferredPhase]++;
+            results.push({
+                id: node.id,
+                type: node.type,
+                name: node.name,
+                status: node.status,
+                lifecycle: node.lifecycle,
+                inferredState,
+                inferredPhase,
+            });
+        }
+        return { nodes: results, summary };
+    },
+});