sysprom 1.20.0 → 1.21.0

package/dist/schema.json

@@ -210,10 +210,6 @@
                         },
                         "type": "array"
                     },
-                    "input": {
-                        "description": "ID of the input artefact. Applicable to artefact_flow nodes.",
-                        "type": "string"
-                    },
                     "lifecycle": {
                         "additionalProperties": {
                             "anyOf": [
@@ -306,10 +302,6 @@
                         },
                         "type": "array"
                     },
-                    "output": {
-                        "description": "ID of the output artefact. Applicable to artefact_flow nodes.",
-                        "type": "string"
-                    },
                     "plan": {
                         "description": "Execution plan as a sequence of tasks. Applicable to change nodes.",
                         "items": {
@@ -377,25 +369,8 @@
                         "type": "string"
                     },
                     "status": {
-                        "enum": [
-                            "proposed",
-                            "accepted",
-                            "active",
-                            "implemented",
-                            "adopted",
-                            "defined",
-                            "introduced",
-                            "in_progress",
-                            "complete",
-                            "consolidated",
-                            "experimental",
-                            "deprecated",
-                            "retired",
-                            "superseded",
-                            "abandoned",
-                            "deferred"
-                        ],
-                        "type": "string"
+                        "description": "Deprecated field. Node-level status is not supported; use lifecycle states instead.",
+                        "not": {}
                     },
                     "subsystem": {
                         "$ref": "#"
@@ -416,12 +391,10 @@
                             "gate",
                             "mode",
                             "artefact",
-                            "artefact_flow",
                             "decision",
                             "change",
                             "view",
-                            "milestone",
-                            "version"
+                            "milestone"
                         ],
                         "type": "string"
                     }
@@ -488,25 +461,12 @@
                             "affects",
                             "supersedes",
                             "must_preserve",
-                            "performs",
                             "part_of",
                             "precedes",
                             "must_follow",
-                            "blocks",
-                            "routes_to",
-                            "orchestrates",
                             "governed_by",
                             "modifies",
-                            "triggered_by",
-                            "applies_to",
-                            "produces",
-                            "consumes",
-                            "transforms_into",
-                            "selects",
-                            "requires",
-                            "disables",
-                            "influence",
-                            "justifies"
+                            "produces"
                         ],
                         "type": "string"
                     }

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

@@ -50,8 +50,12 @@ const optsSchema = mutationOpts.extend({
 function populateNodeFromOpts(node, description, status, context, rationale, scope, selected, options) {
     if (description)
         node.description = description;
-    if (status)
-        node.status = status;
+    if (status) {
+        node.lifecycle = {
+            ...(node.lifecycle ?? {}),
+            [status]: true,
+        };
+    }
     if (context)
         node.context = context;
     if (rationale)

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

@@ -4,6 +4,7 @@ import { textToString } from "../../text.js";
 import { readOpts, loadDoc } from "../shared.js";
 import { queryNodesOp, queryNodeOp, queryRelationshipsOp, traceFromNodeOp, timelineOp, nodeHistoryOp, stateAtOp, } from "../../operations/index.js";
 import { NodeType, NodeStatus } from "../../schema.js";
+import { primaryLifecycleState } from "../../lifecycle-state.js";
 // ---------------------------------------------------------------------------
 // Presentation helpers
 // ---------------------------------------------------------------------------
@@ -16,8 +17,9 @@ function printNodeCompact(r) {
 function printNodeVerbose(r) {
     console.log(`${pc.cyan(r.id)} — ${pc.bold(r.name)}`);
     console.log(`  ${pc.dim("Type")}: ${r.type}`);
-    if (r.status)
-        console.log(`  ${pc.dim("Status")}: ${pc.yellow(r.status)}`);
+    const state = primaryLifecycleState(r);
+    if (state)
+        console.log(`  ${pc.dim("State")}: ${pc.yellow(state)}`);
     if (r.description)
         console.log(`  ${pc.dim("Description")}: ${textToString(r.description)}`);
     if (r.context)
@@ -65,7 +67,7 @@ function printTraceTree(tn, depth) {
 // ---------------------------------------------------------------------------
 const nodesOpts = readOpts.extend({
     type: NodeType.optional().describe("filter by node type"),
-    status: NodeStatus.optional().describe("filter by node status"),
+    status: NodeStatus.optional().describe("filter by lifecycle state"),
 });
 const nodeArgs = z.object({
     id: z.string().describe("node ID to retrieve"),

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

@@ -218,7 +218,7 @@ const syncSubcommand = {
         const specKitDoc = parseSpecKitFeature(specKitDir, idPrefix, constitutionPath);
         // Compare documents
         const diff = compareDocuments(syspromDoc, specKitDoc);
-        // Merge: Spec-Kit wins for content (description, status), SysProM wins for structure
+        // Merge: Spec-Kit wins for content (description, lifecycle), SysProM wins for structure
         const mergedNodes = new Map(syspromDoc.nodes.map((n) => [n.id, n]));
         const specKitNodes = new Map(specKitDoc.nodes.map((n) => [n.id, n]));
         for (const [id, specKitNode] of specKitNodes) {
@@ -232,7 +232,7 @@ const syncSubcommand = {
                 const merged = {
                     ...syspromNode,
                     description: specKitNode.description ?? syspromNode.description,
-                    status: specKitNode.status ?? syspromNode.status,
+                    lifecycle: specKitNode.lifecycle ?? syspromNode.lifecycle,
                     context: specKitNode.context ?? syspromNode.context,
                     options: specKitNode.options ?? syspromNode.options,
                     selected: specKitNode.selected ?? syspromNode.selected,

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

@@ -52,7 +52,7 @@ const updateNodeArgs = z.object({
 });
 const updateNodeOpts = mutationOpts.extend({
     description: z.string().optional().describe("update node description"),
-    status: NodeStatus.optional().describe("update node status"),
+    status: NodeStatus.optional().describe("set lifecycle state to true"),
     context: z.string().optional().describe("update node context"),
     rationale: z.string().optional().describe("update node rationale"),
     lifecycle: z
@@ -97,13 +97,15 @@ const nodeSubcommand = {
         const fields = {};
         if (opts.description !== undefined)
             fields.description = opts.description;
-        if (opts.status !== undefined)
-            fields.status = opts.status;
         if (opts.context !== undefined)
             fields.context = opts.context;
         if (opts.rationale !== undefined)
             fields.rationale = opts.rationale;
-        const lifecycleFields = parseLifecycleFields(node.lifecycle, opts.lifecycle ?? []);
+        const lifecycleArgs = [...(opts.lifecycle ?? [])];
+        if (opts.status !== undefined) {
+            lifecycleArgs.push(`${opts.status}=true`);
+        }
+        const lifecycleFields = parseLifecycleFields(node.lifecycle, lifecycleArgs);
         if (lifecycleFields) {
             fields.lifecycle = lifecycleFields;
         }

package/dist/src/endpoint-types.d.ts

@@ -22,3 +22,7 @@ export declare const RELATIONSHIP_ENDPOINT_TYPES: Record<RelationshipType, {
  * ```
  */
 export declare function isValidEndpointPair(relType: RelationshipType, fromType: NodeType, toType: NodeType): boolean;
+/**
+ * True when a relationship is a read-model view dependency.
+ */
+export declare function isViewReadModelDependsOnRelationship(relType: RelationshipType, fromType: NodeType, toType: NodeType): boolean;

package/dist/src/endpoint-types.js

@@ -54,9 +54,9 @@ export const RELATIONSHIP_ENDPOINT_TYPES = {
             "gate",
             "mode",
             "artefact",
-            "artefact_flow",
             "decision",
             "change",
+            "view",
         ],
         to: [
             "intent",
@@ -73,7 +73,6 @@ export const RELATIONSHIP_ENDPOINT_TYPES = {
             "gate",
             "mode",
             "artefact",
-            "artefact_flow",
             "decision",
             "change",
         ],
@@ -92,26 +91,6 @@ export const RELATIONSHIP_ENDPOINT_TYPES = {
         ],
         to: ["invariant", "principle", "policy", "protocol", "concept"],
     },
-    // Requires — explicit requirements
-    requires: {
-        from: [
-            "intent",
-            "concept",
-            "capability",
-            "element",
-            "realisation",
-            "stage",
-            "change",
-        ],
-        to: [
-            "intent",
-            "concept",
-            "capability",
-            "element",
-            "realisation",
-            "artefact",
-        ],
-    },
     // Affects — broad impact relationships
     affects: {
         from: ["decision", "change", "artefact", "stage"],
@@ -145,7 +124,6 @@ export const RELATIONSHIP_ENDPOINT_TYPES = {
             "realisation",
             "decision",
             "change",
-            "version",
         ],
         to: [
             "intent",
@@ -155,19 +133,6 @@ export const RELATIONSHIP_ENDPOINT_TYPES = {
             "realisation",
             "decision",
             "change",
-            "version",
-        ],
-    },
-    // Performs — process enactment
-    performs: {
-        from: ["stage", "role"],
-        to: [
-            "capability",
-            "artefact",
-            "artefact_flow",
-            "stage",
-            "concept",
-            "protocol",
         ],
     },
     // Precedes — temporal ordering
@@ -213,21 +178,6 @@ export const RELATIONSHIP_ENDPOINT_TYPES = {
             "mode",
         ],
     },
-    // Blocks — impediments and constraints
-    blocks: {
-        from: ["invariant", "policy", "decision", "principle"],
-        to: ["decision", "change", "stage"],
-    },
-    // Routes to — data/process flow
-    routes_to: {
-        from: ["artefact_flow"],
-        to: ["artefact_flow", "stage", "artefact"],
-    },
-    // Orchestrates — abstract workflow nodes direct executable flow nodes
-    orchestrates: {
-        from: ["concept", "protocol", "capability"],
-        to: ["milestone", "stage", "gate", "artefact_flow"],
-    },
     // Governed by — governance relationships
     governed_by: {
         from: [
@@ -246,7 +196,7 @@ export const RELATIONSHIP_ENDPOINT_TYPES = {
     },
     // Modifies — mutation and change
     modifies: {
-        from: ["change", "artefact_flow", "stage"],
+        from: ["change", "stage"],
         to: [
             "intent",
             "concept",
@@ -256,80 +206,20 @@ export const RELATIONSHIP_ENDPOINT_TYPES = {
             "artefact",
         ],
     },
-    // Transforms into — metamorphosis
-    transforms_into: {
-        from: ["artefact"],
-        to: ["artefact"],
-    },
-    // Triggered by — causation
-    triggered_by: {
-        from: ["stage", "gate", "artefact_flow", "change"],
-        to: ["decision", "artefact", "gate", "stage"],
-    },
-    // Disables — negation/reversal
-    disables: {
-        from: ["decision", "change"],
-        to: ["capability", "realisation"],
-    },
-    // Applies to — applicability and scope
-    applies_to: {
-        from: ["policy", "principle", "mode", "protocol", "invariant"],
-        to: [
-            "intent",
-            "concept",
-            "capability",
-            "element",
-            "realisation",
-            "stage",
-            "decision",
-            "change",
-            "invariant",
-        ],
-    },
     // Produces — generation
     produces: {
-        from: ["stage", "artefact_flow", "realisation", "concept", "capability"],
+        from: ["stage", "realisation", "concept", "capability"],
         to: ["artefact", "concept"],
     },
-    // Consumes — usage
-    consumes: {
-        from: ["stage", "artefact_flow", "realisation", "role"],
-        to: ["artefact"],
-    },
-    // Selects — choice and instantiation
-    selects: {
-        from: ["decision", "mode"],
-        to: ["capability", "stage"],
-    },
-    // Influence — soft dependency between decisions and across nodes (CHG40)
-    influence: {
-        from: [
-            "intent",
-            "concept",
-            "capability",
-            "element",
-            "realisation",
-            "decision",
-            "change",
-            "stage",
-        ],
-        to: [
-            "intent",
-            "concept",
-            "capability",
-            "element",
-            "realisation",
-            "decision",
-            "change",
-            "stage",
-        ],
-    },
-    // Justifies — design rationale grounding (principle/decision → invariant/decision/principle/concept)
-    justifies: {
-        from: ["principle", "decision"],
-        to: ["invariant", "decision", "principle", "concept"],
-    },
 };
+const VIEW_READ_MODEL_DEPENDENCY_TARGETS = [
+    "concept",
+    "capability",
+    "element",
+    "stage",
+    "artefact",
+    "role",
+];
 /**
  * Check if a relationship type is valid for the given endpoint node types.
  * @param relType - The relationship type
@@ -342,6 +232,17 @@ export const RELATIONSHIP_ENDPOINT_TYPES = {
  * ```
  */
 export function isValidEndpointPair(relType, fromType, toType) {
+    if (relType === "depends_on" && fromType === "view") {
+        return VIEW_READ_MODEL_DEPENDENCY_TARGETS.includes(toType);
+    }
     const endpoints = RELATIONSHIP_ENDPOINT_TYPES[relType];
     return endpoints.from.includes(fromType) && endpoints.to.includes(toType);
 }
+/**
+ * True when a relationship is a read-model view dependency.
+ */
+export function isViewReadModelDependsOnRelationship(relType, fromType, toType) {
+    return (relType === "depends_on" &&
+        fromType === "view" &&
+        VIEW_READ_MODEL_DEPENDENCY_TARGETS.includes(toType));
+}

package/dist/src/json-to-md.js

@@ -1,6 +1,7 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { NODE_FILE_MAP, NODE_TYPE_LABELS, NodeType, RelationshipType, RELATIONSHIP_TYPE_LABELS, } from "./schema.js";
+import { primaryLifecycleState } from "./lifecycle-state.js";
 import { graphOp } from "./operations/graph.js";
 import { graphRefinementOp } from "./operations/graph-refinement.js";
 import { graphDecisionOp } from "./operations/graph-decision.js";
@@ -203,10 +204,6 @@ function renderNode(n, headingLevel, fromIdx, nodeMap, currentFile) {
         lines.push(...rels);
         lines.push("");
     }
-    if (n.status) {
-        lines.push(`- Status: ${n.status}`);
-        lines.push("");
-    }
     // Decision fields
     if (n.context) {
         lines.push(`Context: ${renderText(n.context)}`);
@@ -277,16 +274,6 @@ function renderNode(n, headingLevel, fromIdx, nodeMap, currentFile) {
         }
         lines.push("");
     }
-    // Artefact flow
-    if (n.input) {
-        lines.push(`- Input: ${n.input}`);
-    }
-    if (n.output) {
-        lines.push(`- Output: ${n.output}`);
-    }
-    if (n.input || n.output) {
-        lines.push("");
-    }
     // Inline external references
     if (n.external_references && n.external_references.length > 0) {
         lines.push(...renderExternalReferences(n.external_references));
@@ -533,7 +520,6 @@ export function jsonToMarkdownSingle(doc, options) {
         ...NODE_FILE_MAP.CHANGES,
         "view",
         "milestone",
-        "version",
     ];
     lines.push(...renderNodesGrouped(doc.nodes, allTypes, fromIdx, 2, nodeMap));
     // Diagrams section
@@ -638,7 +624,7 @@ export function jsonToMarkdownMultiDoc(doc, outDir, options) {
                 title: `${n.id} — ${n.name}`,
                 doc_type: n.type,
                 scope: n.type,
-                status: n.status,
+                status: primaryLifecycleState(n),
             },
         };
         // Count how many distinct file types would be produced

package/dist/src/lifecycle-state.d.ts

@@ -0,0 +1,9 @@
+import type { Node, NodeStatus } from "./schema.js";
+/**
+ * Return true when a lifecycle state is marked as reached on a node.
+ */
+export declare function hasLifecycleState(node: Node, state: string): boolean;
+/**
+ * Return the most advanced reached lifecycle state, if any.
+ */
+export declare function primaryLifecycleState(node: Node): NodeStatus | undefined;

package/dist/src/lifecycle-state.js

@@ -0,0 +1,22 @@
+import { NODE_STATUSES } from "./schema.js";
+function isLifecycleReached(value) {
+    return value === true || typeof value === "string";
+}
+/**
+ * Return true when a lifecycle state is marked as reached on a node.
+ */
+export function hasLifecycleState(node, state) {
+    return isLifecycleReached(node.lifecycle?.[state]);
+}
+/**
+ * Return the most advanced reached lifecycle state, if any.
+ */
+export function primaryLifecycleState(node) {
+    for (let index = NODE_STATUSES.length - 1; index >= 0; index -= 1) {
+        const state = NODE_STATUSES[index];
+        if (hasLifecycleState(node, state)) {
+            return state;
+        }
+    }
+    return undefined;
+}

package/dist/src/mcp/server.js

@@ -113,11 +113,11 @@ server.registerTool("stats", {
 });
 // Register query-nodes tool
 server.registerTool("query-nodes", {
-    description: "Query nodes by type, status, or other criteria",
+    description: "Query nodes by type, lifecycle state, or other criteria",
     inputSchema: z.object({
         path: z.string().describe("Path to SysProM file"),
         type: z.string().optional().describe("Filter by node type"),
-        status: z.string().optional().describe("Filter by node status"),
+        status: z.string().optional().describe("Filter by lifecycle state"),
     }),
 }, ({ path, type, status }) => {
     const { doc } = loadDocument(path);
@@ -310,7 +310,6 @@ server.registerTool("update-node", {
         const allowedFields = [
             "name",
             "description",
-            "status",
             "context",
             "options",
             "selected",
@@ -320,8 +319,6 @@ server.registerTool("update-node", {
             "plan",
             "propagation",
             "includes",
-            "input",
-            "output",
             "external_references",
         ];
         const droppedFields = [];
@@ -495,7 +492,7 @@ server.registerTool("infer-completeness", {
 });
 // Register infer-lifecycle tool
 server.registerTool("infer-lifecycle", {
-    description: "Infer lifecycle state for nodes based on status and lifecycle fields",
+    description: "Infer lifecycle state for nodes based on lifecycle fields",
     inputSchema: z.object({
         path: z.string().describe("Path to SysProM file"),
     }),

package/dist/src/md-to-json.js

@@ -1,7 +1,7 @@
 import * as z from "zod";
 import { readFileSync, existsSync, readdirSync, statSync } from "node:fs";
 import { join, basename } from "node:path";
-import { NODE_FILE_MAP, NODE_LABEL_TO_TYPE, RELATIONSHIP_TYPE_LABELS, RELATIONSHIP_LABEL_TO_TYPE, NodeType, RelationshipType, NodeStatus, ExternalReferenceRole, } from "./schema.js";
+import { NODE_FILE_MAP, NODE_LABEL_TO_TYPE, RELATIONSHIP_TYPE_LABELS, RELATIONSHIP_LABEL_TO_TYPE, NodeType, RelationshipType, ExternalReferenceRole, } from "./schema.js";
 /** Strip markdown link syntax `[text](url)` → `text`. */
 /**
  * Strip markdown link syntax `[text](url)` → `text`.
@@ -27,12 +27,6 @@ function parseRelType(s) {
         throw new Error(`Unknown relationship type: "${s}". Valid types: ${RelationshipType.options.join(", ")}`);
     return result.data;
 }
-function parseNodeStatus(s) {
-    const result = NodeStatus.safeParse(s);
-    if (!result.success)
-        throw new Error(`Unknown node status: "${s}". Valid statuses: ${NodeStatus.options.join(", ")}`);
-    return result.data;
-}
 function parseExtRefRole(s) {
     const result = ExternalReferenceRole.safeParse(s);
     if (!result.success)
@@ -262,10 +256,6 @@ function parseNodeFromSection(section) {
     if (descLines.length > 0) {
         node.description = parseText(descLines.join("\n"));
     }
-    // Status
-    const status = parseSingleValue(body, "- Status");
-    if (status)
-        node.status = parseNodeStatus(status);
     // Decision fields
     const context = parseSingleValue(body, "Context");
     if (context)
@@ -316,13 +306,6 @@ function parseNodeFromSection(section) {
     const includes = parseListItems(body, "Includes");
     if (includes.length > 0)
         node.includes = includes;
-    // Artefact flow
-    const input = parseSingleValue(body, "- Input");
-    if (input)
-        node.input = input;
-    const output = parseSingleValue(body, "- Output");
-    if (output)
-        node.output = output;
     // Lifecycle and propagation from child sections
     for (const child of section.children) {
         if (child.heading === "Lifecycle") {
@@ -484,7 +467,6 @@ export function markdownSingleToJson(content) {
         ...NODE_FILE_MAP.CHANGES,
         "view",
         "milestone",
-        "version",
     ];
     const { nodes, rels } = parseDocFile(content, allTypes);
     const tableRels = parseRelationshipTable(body);