sysprom 1.21.1 → 1.22.0

package/dist/src/operations/update-metadata.d.ts

@@ -88,18 +88,6 @@ export declare const updateMetadataOp: import("./define-operation.js").DefinedOp
                     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>>;
             external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -231,11 +219,6 @@ export declare const updateMetadataOp: import("./define-operation.js").DefinedOp
                     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;
                 external_references?: {
@@ -362,18 +345,6 @@ export declare const updateMetadataOp: import("./define-operation.js").DefinedOp
                 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>>;
         external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -505,11 +476,6 @@ export declare const updateMetadataOp: import("./define-operation.js").DefinedOp
                 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;
             external_references?: {

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

@@ -91,18 +91,6 @@ export declare const updateNodeOp: import("./define-operation.js").DefinedOperat
                     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>>;
             external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -234,11 +222,6 @@ export declare const updateNodeOp: import("./define-operation.js").DefinedOperat
                     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;
                 external_references?: {
@@ -347,18 +330,6 @@ export declare const updateNodeOp: import("./define-operation.js").DefinedOperat
                 description?: string | string[] | undefined;
             };
         }>>>;
-        plan: z.ZodOptional<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.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>>;
         includes: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
         external_references: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -477,18 +448,6 @@ export declare const updateNodeOp: import("./define-operation.js").DefinedOperat
                         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>>;
                 external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -684,18 +643,6 @@ export declare const updateNodeOp: import("./define-operation.js").DefinedOperat
                 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>>;
         external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -827,11 +774,6 @@ export declare const updateNodeOp: import("./define-operation.js").DefinedOperat
                 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;
             external_references?: {

package/dist/src/operations/validate.d.ts

@@ -104,18 +104,6 @@ export declare const validateOp: import("./define-operation.js").DefinedOperatio
                     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>>;
             external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -247,11 +235,6 @@ export declare const validateOp: import("./define-operation.js").DefinedOperatio
                     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;
                 external_references?: {

package/dist/src/operations/validate.js

@@ -127,6 +127,77 @@ export const validateOp = defineOperation({
                 issues.push(`${n.id} (${n.name}): decision has no selected option`);
             }
         }
+        const isLifecycleReached = (value) => value === true || typeof value === "string";
+        const isGateReady = (node) => {
+            if (node.type !== "gate")
+                return false;
+            const lifecycle = node.lifecycle ?? {};
+            const values = Object.values(lifecycle);
+            if (values.length === 0)
+                return false;
+            return values.every((value) => isLifecycleReached(value));
+        };
+        const globalNodeMap = new Map(input.doc.nodes.map((node) => [node.id, node]));
+        const validatePlanSubsystem = (subsystem, protocolId) => {
+            if (!subsystem)
+                return;
+            const localNodeMap = new Map(subsystem.nodes.map((node) => [node.id, node]));
+            for (const node of subsystem.nodes) {
+                if (node.type !== "change") {
+                    issues.push(`${protocolId}: implementation plan contains non-change node ${node.id} (${node.type})`);
+                    continue;
+                }
+                if (hasLifecycleState(node, "complete")) {
+                    const blockers = [];
+                    for (const rel of subsystem.relationships ?? []) {
+                        if (rel.from !== node.id || rel.type !== "depends_on")
+                            continue;
+                        const dependency = localNodeMap.get(rel.to) ?? globalNodeMap.get(rel.to);
+                        if (dependency?.type !== "change") {
+                            blockers.push(`dependency ${rel.to} is not a change task`);
+                            continue;
+                        }
+                        if (!hasLifecycleState(dependency, "complete")) {
+                            blockers.push(`dependency ${rel.to} is not complete`);
+                        }
+                    }
+                    for (const rel of subsystem.relationships ?? []) {
+                        if (rel.from !== node.id || rel.type !== "constrained_by")
+                            continue;
+                        const gate = localNodeMap.get(rel.to) ?? globalNodeMap.get(rel.to);
+                        if (!gate || !isGateReady(gate)) {
+                            blockers.push(`gate ${rel.to} is not ready`);
+                        }
+                    }
+                    if (blockers.length > 0) {
+                        issues.push(`${node.id} (${node.name}): complete task has unresolved blockers (${blockers.join(", ")})`);
+                    }
+                }
+                if (node.subsystem) {
+                    validatePlanSubsystem(node.subsystem, protocolId);
+                }
+            }
+            for (const rel of subsystem.relationships ?? []) {
+                if (rel.type !== "depends_on")
+                    continue;
+                const fromNode = localNodeMap.get(rel.from);
+                const toNode = localNodeMap.get(rel.to);
+                if (!fromNode || !toNode) {
+                    issues.push(`${protocolId}: depends_on relationship ${rel.from} -> ${rel.to} must stay within the same plan scope`);
+                    continue;
+                }
+                if (fromNode.type !== "change" || toNode.type !== "change") {
+                    issues.push(`${protocolId}: depends_on scheduling relationship must connect change task nodes (${rel.from} -> ${rel.to})`);
+                }
+            }
+        };
+        for (const node of input.doc.nodes) {
+            if (node.type !== "protocol")
+                continue;
+            if (!node.id.endsWith("-PROT-IMPL"))
+                continue;
+            validatePlanSubsystem(node.subsystem, node.id);
+        }
         return {
             valid: issues.length === 0,
             issues,

package/dist/src/schema.d.ts

@@ -202,21 +202,6 @@ export declare const Operation: z.ZodObject<{
 };
 /** An atomic operation within a change, targeting a specific node. */
 export type Operation = z.infer<typeof Operation>;
-/** Zod schema for a task within a change's execution plan. */
-export declare const Task: 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;
-    };
-};
-/** A single task within a change's execution plan, with a description and done flag. */
-export type Task = z.infer<typeof Task>;
 /** Zod schema for an external reference — a link to a resource outside the SysProM graph. */
 export declare const ExternalReference: z.ZodObject<{
     role: z.ZodEnum<{
@@ -478,18 +463,6 @@ export declare const NodeBase: z.ZodObject<{
             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>>;
     external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -592,18 +565,6 @@ declare const NodeSchema: z.ZodObject<{
             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>>;
     external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -759,11 +720,6 @@ export declare const SysProMDocument: z.ZodObject<{
                 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;
             external_references?: {
@@ -878,18 +834,6 @@ export declare const Node: z.ZodObject<{
             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>>;
     external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -946,11 +890,6 @@ export declare const Node: z.ZodObject<{
             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;
         external_references?: {

package/dist/src/schema.js

@@ -167,13 +167,6 @@ export const Operation = defineSchema(z
     description: Text.optional(),
 })
     .describe("An atomic operation within a change."));
-/** Zod schema for a task within a change's execution plan. */
-export const Task = defineSchema(z
-    .looseObject({
-    description: Text,
-    done: z.boolean().default(false).optional(),
-})
-    .describe("A single task within a change's execution plan."));
 /** Zod schema for an external reference — a link to a resource outside the SysProM graph. */
 export const ExternalReference = defineSchema(z
     .object({
@@ -282,10 +275,6 @@ export const NodeBase = z
         .array(Operation)
         .describe("Operations performed. Applicable to change nodes.")
         .optional(),
-    plan: z
-        .array(Task)
-        .describe("Execution plan as a sequence of tasks. Applicable to change nodes.")
-        .optional(),
     propagation: z
         .record(z.string(), z.boolean())
         .describe("Layer propagation status. Applicable to change nodes.")

package/dist/src/speckit/generate.js

@@ -105,20 +105,12 @@ function getIdSuffix(id) {
     const parts = id.split("-");
     return parts[parts.length - 1] ?? "000";
 }
-/**
- * Parse tasks from a change node's plan array.
- * @param node - The change node.
- * @returns Array of task descriptions and done flags.
- * @example
- * ```ts
- * const tasks = parseTasks(changeNode);
- * ```
- */
-function parseTasks(node) {
-    return (node.plan ?? []).map((task) => ({
-        description: textToString(task.description),
-        done: task.done ?? false,
-    }));
+function childTaskNodes(change) {
+    return (change.subsystem?.nodes ?? []).filter((n) => n.type === "change");
+}
+function isDone(node) {
+    return (node.lifecycle?.complete === true ||
+        typeof node.lifecycle?.complete === "string");
 }
 /**
  * Format the lifecycle state for spec output: "proposed" -> "Draft", etc.
@@ -494,10 +486,10 @@ export function generateTasks(doc, prefix) {
         return output.trim();
     }
     // Recursive helper to render a change node and its tasks, including nested child changes.
-    // Render tasks from a change node's plan array.
+    // Render tasks from child change nodes.
     function renderPlanItems(change, taskCounter) {
         let result = "";
-        const tasks = parseTasks(change);
+        const tasks = childTaskNodes(change);
         for (const task of tasks) {
             // Find capability that this change implements.
             let usStory = null;
@@ -511,13 +503,13 @@ export function generateTasks(doc, prefix) {
                     usStory = getIdSuffix(implRelsDoc[0].to);
                 }
             }
-            const checkbox = task.done ? "[x]" : "[ ]";
+            const checkbox = isDone(task) ? "[x]" : "[ ]";
             const taskNum = String(taskCounter.value).padStart(3, "0");
             let taskLine = `- ${checkbox} T${taskNum}`;
             if (usStory && usStory !== "000") {
                 taskLine += ` [US${usStory}]`;
             }
-            taskLine += ` ${textToString(task.description)}`;
+            taskLine += ` ${task.name}`;
             result += taskLine + "\n";
             taskCounter.value++;
         }
@@ -536,9 +528,14 @@ export function generateTasks(doc, prefix) {
             result += "\n";
         else
             result += "\n\n";
-        // Recurse into child change nodes.
+        // Recurse into child phase nodes only (task nodes are rendered as checkboxes above).
         if (change.subsystem?.nodes && change.subsystem.nodes.length > 0) {
-            const childChanges = change.subsystem.nodes.filter((n) => n.type === "change");
+            const childChanges = change.subsystem.nodes.filter((n) => {
+                if (n.type !== "change")
+                    return false;
+                const children = n.subsystem?.nodes ?? [];
+                return children.some((child) => child.type === "change");
+            });
             for (const childChange of childChanges) {
                 result += renderChangeNode(childChange, headingLevel + 1, taskCounter);
             }

package/dist/src/speckit/index.d.ts

@@ -1,4 +1,4 @@
 export { detectSpecKitProject, listFeatures, getFeature, resolveConstitution, type SpecKitProject, type SpecKitFeature, } from "./project.js";
 export { parseConstitution, parseSpec, parsePlan, parseTasks, parseChecklist, parseSpecKitFeature, type ParseResult, } from "./parse.js";
 export { generateConstitution, generateSpec, generatePlan, generateTasks, generateChecklist, generateSpecKitProject, } from "./generate.js";
-export { initDocument, addTask, planStatus, planProgress, checkGate, isTaskDone, countTasks, type PlanStatus, type PhaseProgress, type GateIssue, type GateResult, } from "./plan.js";
+export { initDocument, addTask, setTaskLifecycle, planStatus, planProgress, checkGate, isTaskDone, countTasks, type PlanStatus, type PhaseProgress, type GateIssue, type GateResult, type BlockageReason, type TaskBlockage, } from "./plan.js";

package/dist/src/speckit/index.js

@@ -1,4 +1,4 @@
 export { detectSpecKitProject, listFeatures, getFeature, resolveConstitution, } from "./project.js";
 export { parseConstitution, parseSpec, parsePlan, parseTasks, parseChecklist, parseSpecKitFeature, } from "./parse.js";
 export { generateConstitution, generateSpec, generatePlan, generateTasks, generateChecklist, generateSpecKitProject, } from "./generate.js";
-export { initDocument, addTask, planStatus, planProgress, checkGate, isTaskDone, countTasks, } from "./plan.js";
+export { initDocument, addTask, setTaskLifecycle, planStatus, planProgress, checkGate, isTaskDone, countTasks, } from "./plan.js";

package/dist/src/speckit/parse.d.ts

@@ -40,7 +40,7 @@ export declare function parseSpec(content: string, idPrefix: string): ParseResul
  */
 export declare function parsePlan(content: string, idPrefix: string): ParseResult;
 /**
- * Parse a Spec-Kit tasks file into SysProM change nodes with task plans.
+ * Parse a Spec-Kit tasks file into SysProM change nodes with nested task nodes.
  * @param content - Markdown file content.
  * @param idPrefix - ID prefix for generated nodes.
  * @returns The result.

package/dist/src/speckit/parse.js

@@ -580,7 +580,7 @@ export function parsePlan(content, idPrefix) {
 // tasks.md parser
 // ---------------------------------------------------------------------------
 /**
- * Parse a Spec-Kit tasks file into SysProM change nodes with task plans.
+ * Parse a Spec-Kit tasks file into SysProM change nodes with nested task nodes.
  * @param content - Markdown file content.
  * @param idPrefix - ID prefix for generated nodes.
  * @returns The result.
@@ -631,21 +631,27 @@ export function parseTasks(content, idPrefix) {
             }
         }
     }
-    // Create change nodes for each phase (with LOCAL IDs in subsystem)
-    // Use numeric indices (CHG-1, CHG-2, etc.) for phase changes
+    const toTaskNode = (parentId, index, task) => ({
+        id: `${parentId}-${String(index + 1)}`,
+        type: "change",
+        name: task.text,
+        lifecycle: task.done ? { complete: true } : { proposed: true },
+    });
+    // Create change nodes for each phase (with local IDs in subsystem)
+    // Use numeric indices (CHG-1, CHG-2, etc.) for phase changes.
     for (let i = 0; i < phases.length; i++) {
         const phase = phases[i];
         const tasks = changesByPhase[phase.phaseNum] ?? [];
-        const plan = tasks.map((t) => ({
-            description: t.text,
-            done: t.done,
-        }));
         const changeLocalId = `CHG-${String(phase.phaseNum)}`;
         subsystemNodes.push({
             id: changeLocalId,
             type: "change",
             name: phase.title,
-            plan,
+            lifecycle: { introduced: true },
+            subsystem: {
+                nodes: tasks.map((task, index) => toTaskNode(changeLocalId, index, task)),
+                relationships: [],
+            },
         });
         // Wire must_follow between consecutive phase changes
         if (i > 0) {
@@ -657,18 +663,18 @@ export function parseTasks(content, idPrefix) {
             });
         }
     }
-    // Create change nodes for user stories (with LOCAL IDs in subsystem)
+    // Create change nodes for user stories (with local IDs in subsystem)
     for (const [storyKey, tasks] of Object.entries(changesByStory)) {
-        const plan = tasks.map((t) => ({
-            description: t.text,
-            done: t.done,
-        }));
         const changeLocalId = `CHG-${storyKey}`;
         subsystemNodes.push({
             id: changeLocalId,
             type: "change",
             name: storyKey,
-            plan,
+            lifecycle: { introduced: true },
+            subsystem: {
+                nodes: tasks.map((task, index) => toTaskNode(changeLocalId, index, task)),
+                relationships: [],
+            },
         });
         // Link to the capability at the top level (using GLOBAL ID format)
         const changeGlobalId = `${idPrefix}-CHG-${storyKey}`;

package/dist/src/speckit/plan.d.ts

@@ -17,6 +17,8 @@ export interface PlanStatus {
     tasks: {
         total: number;
         done: number;
+        blocked: number;
+        blockedTasks: TaskBlockage[];
     };
     checklist: {
         defined: boolean;
@@ -28,10 +30,13 @@ export interface PlanStatus {
 /** Per-phase progress metrics — task counts and completion percentage. */
 export interface PhaseProgress {
     phase: number;
+    id: string;
     name: string;
     done: number;
     total: number;
     percent: number;
+    blocked: boolean;
+    blockageReasons: BlockageReason[];
 }
 /** A specific issue preventing gate entry — incomplete tasks, missing acceptance criteria, or unlinked requirements. */
 export type GateIssue = {
@@ -58,6 +63,18 @@ export interface GateResult {
 export interface TaskCount {
     total: number;
     done: number;
+    blocked: number;
+    blockedTasks: TaskBlockage[];
+}
+/** Why a task is blocked. */
+export interface BlockageReason {
+    kind: "dependency_unmet" | "gate_not_ready";
+    nodeId: string;
+}
+/** Blockage detail for a specific task. */
+export interface TaskBlockage {
+    taskId: string;
+    reasons: BlockageReason[];
 }
 /**
  * Scaffold a new SysProMDocument with the standard spec-kit-compatible node
@@ -106,18 +123,22 @@ export declare function initDocument(prefix: string, name: string): SysProMDocum
  * ```
  */
 export declare function addTask(doc: SysProMDocument, prefix: string, name?: string, parentId?: string): SysProMDocument;
+type TaskLifecycleAction = "start" | "complete" | "reopen";
 /**
- * Check if a change node's task is complete.
+ * Set lifecycle state on a task (change node) within a plan implementation protocol.
  *
- * If no subsystem or no change children in subsystem:
- *   - All items in node.plan must have done === true AND at least one item must exist.
- * If subsystem has change children:
- *   - All children must be recursively done AND own plan items (if any) must be done.
+ * - start: marks introduced + in_progress true
+ * - complete: marks complete true and clears in_progress
+ * - reopen: clears complete and marks in_progress true
+ */
+export declare function setTaskLifecycle(doc: SysProMDocument, prefix: string, taskId: string, action: TaskLifecycleAction): SysProMDocument;
+/**
+ * Check if a task change node is complete.
  * @param node - The change node to evaluate.
- * @returns Whether all tasks in the node's plan are complete.
+ * @returns Whether the task lifecycle includes complete.
  * @example
  * ```ts
- * isTaskDone(changeNode); // => true if all plan items done
+ * isTaskDone(changeNode); // => true when lifecycle.complete is reached
  * ```
  */
 export declare function isTaskDone(node: Node): boolean;
@@ -178,3 +199,4 @@ export declare function planProgress(doc: SysProMDocument, prefix: string): Phas
  * ```
  */
 export declare function checkGate(doc: SysProMDocument, prefix: string, phase: number): GateResult;
+export {};