@unbrained/pm-cli 2026.6.30 → 2026.7.2

package/dist/cli-bundle/chunks/{plan-ZHKZ7JVF.js → plan-BGDR73Z6.js}

@@ -1,26 +1,26 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="29e74621-056d-50a2-8168-18b5c3a20a97")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="ef3dc07a-8c97-52e0-9665-6d7daf701594")}catch(e){}}();
 import {
   runCreate
-} from "./chunk-UB3V5WUI.js";
-import "./chunk-4YIMPANT.js";
-import "./chunk-D6USKAMA.js";
-import "./chunk-OB3RJV5F.js";
-import "./chunk-7RIJGN4R.js";
+} from "./chunk-RM37OPYK.js";
+import "./chunk-KCO2EAN5.js";
+import "./chunk-LRKMWUUV.js";
+import "./chunk-KLXF7NCC.js";
+import "./chunk-QH3FSKRJ.js";
 import {
   splitCommaList
 } from "./chunk-P4SESZGT.js";
-import "./chunk-YEDFE4DC.js";
-import "./chunk-QE5UFCCO.js";
+import "./chunk-ZNT7KEWE.js";
+import "./chunk-2KWL5NPW.js";
 import {
   locateItem,
   mutateItem,
   readLocatedItem
-} from "./chunk-KGQ3W65B.js";
-import "./chunk-V3KLX7U7.js";
+} from "./chunk-NRZS637N.js";
+import "./chunk-KN3URLKS.js";
 import {
   nowIso
-} from "./chunk-KRASIL6M.js";
+} from "./chunk-K2VYLVX4.js";
 import {
   EXIT_CODE,
   PLAN_HARNESS_VALUES,
@@ -35,7 +35,7 @@ import {
   resolveItemTypeRegistry,
   resolvePmRoot,
   resolveTypeName
-} from "./chunk-CY5IJMUM.js";
+} from "./chunk-I66WE2HE.js";
 
 // dist/cli/commands/plan.js
 var PLAN_SUBCOMMANDS = [
@@ -459,6 +459,119 @@ async function readPlanItem(ctx, id) {
   ensurePlanItem(loaded.document.metadata);
   return { document: loaded.document, itemId: located.id };
 }
+function buildPlanCreateDependencies(options) {
+  const deps = [];
+  if (options.parent) {
+    deps.push(`id=${options.parent.trim()},kind=parent`);
+  }
+  for (const ref of toArray(options.related))
+    deps.push(`id=${ref},kind=related`);
+  for (const ref of toArray(options.blocks))
+    deps.push(`id=${ref},kind=blocks`);
+  for (const ref of toArray(options.blockedBy))
+    deps.push(`id=${ref},kind=blocked_by`);
+  return deps.length > 0 ? deps : void 0;
+}
+function buildInitialValidation(options) {
+  const text = options.validationText?.trim();
+  const command = options.validationCommand?.trim();
+  const expected = options.validationExpected?.trim();
+  if (!text && !command && !expected) {
+    return void 0;
+  }
+  return {
+    text: text || command || "Validation check",
+    command: command || void 0,
+    expected: expected || void 0
+  };
+}
+function hasPlanStepDetailOptions(options) {
+  return Boolean(options.stepBody?.trim()) || Boolean(options.stepOwner?.trim()) || Boolean(options.stepStatus?.trim()) || Boolean(options.stepEvidence?.trim()) || Boolean(options.stepBlockedReason?.trim()) || Boolean(options.stepReplacement?.trim()) || toArray(options.dependsOn).length > 0 || toArray(options.link).length > 0 || toSpecArray(options.file).length > 0 || toSpecArray(options.test).length > 0 || toSpecArray(options.doc).length > 0;
+}
+function resolveInitialStepSeed(options) {
+  const stepTitleFlag = options.stepTitle?.trim() || void 0;
+  const repeatedStepTitles = toOrderedStepTitles(options.step);
+  const templateSteps = options.template?.trim() ? resolvePlanTemplateSteps(options.template) : [];
+  return {
+    repeatedStepTitles,
+    stepTitleFlag,
+    stepTitles: [
+      ...stepTitleFlag ? [stepTitleFlag] : [],
+      ...repeatedStepTitles,
+      ...templateSteps.map((step) => step.title)
+    ],
+    templateSteps
+  };
+}
+function assertInitialStepSeedAllowed(seed, hasPerStepDetailOptions) {
+  if ((seed.stepTitleFlag || seed.repeatedStepTitles.length > 0) && seed.templateSteps.length > 0) {
+    throw new PmCliError("pm plan create --template cannot be combined with --step-title or --step; choose one step seeding source", EXIT_CODE.USAGE, {
+      code: "ambiguous_option_combination",
+      examples: [
+        `pm plan create --title "Fix login crash" --template ${PLAN_TEMPLATE_NAMES[0]}`,
+        'pm plan create --title "Custom plan" --step "Read the code" --step "Write the fix"'
+      ]
+    });
+  }
+  if (seed.stepTitles.length > 1 && hasPerStepDetailOptions) {
+    throw new PmCliError("pm plan create per-step options apply to a single initial step; with multiple --step values create the plan first, then refine steps individually", EXIT_CODE.USAGE, {
+      code: "ambiguous_option_combination",
+      examples: [
+        'pm plan create --title "Execution plan" --step "Read the code" --step "Write the fix"',
+        'pm plan update-step <plan-id> plan-step-001 --step-body "Inspect retry path"'
+      ]
+    });
+  }
+}
+function buildSingleInitialStep(options, title) {
+  const status = asStepStatus(options.stepStatus, "pending");
+  const linkedItems = buildLinkInputs(options, "depends_on");
+  const files = toSpecArray(options.file).map(parseStepFile);
+  const tests = toSpecArray(options.test).map(parseStepTest);
+  const docs = toSpecArray(options.doc).map(parseStepDoc);
+  const now = nowIso();
+  return {
+    id: "plan-step-001",
+    order: 1,
+    title,
+    body: options.stepBody?.trim() || void 0,
+    status,
+    owner: options.stepOwner?.trim() || void 0,
+    evidence: options.stepEvidence?.trim() || void 0,
+    blocked_reason: status === "blocked" ? options.stepBlockedReason?.trim() || "" : void 0,
+    linked_items: linkedItems.length > 0 ? linkedItems : void 0,
+    files: files.length > 0 ? files : void 0,
+    tests: tests.length > 0 ? tests : void 0,
+    docs: docs.length > 0 ? docs : void 0,
+    created_at: now,
+    updated_at: now,
+    completed_at: status === "completed" ? now : void 0
+  };
+}
+function buildInitialSteps(options) {
+  const seed = resolveInitialStepSeed(options);
+  const hasDetailOptions = hasPlanStepDetailOptions(options);
+  assertInitialStepSeedAllowed(seed, hasDetailOptions);
+  if (seed.stepTitles.length === 0) {
+    return { steps: [], hasPerStepDetailOptions: hasDetailOptions };
+  }
+  if (seed.stepTitles.length === 1) {
+    return { steps: [buildSingleInitialStep(options, seed.stepTitles[0])], hasPerStepDetailOptions: hasDetailOptions };
+  }
+  const now = nowIso();
+  return {
+    steps: seed.stepTitles.map((stepTitle, index) => ({
+      id: `${STEP_ID_PREFIX}${String(index + 1).padStart(3, "0")}`,
+      order: index + 1,
+      title: stepTitle,
+      body: seed.templateSteps[index]?.body,
+      status: "pending",
+      created_at: now,
+      updated_at: now
+    })),
+    hasPerStepDetailOptions: hasDetailOptions
+  };
+}
 async function planCreate(options, global, ctx) {
   const title = options.title?.trim();
   if (!title) {
@@ -470,19 +583,6 @@ async function planCreate(options, global, ctx) {
   const mode = asPlanMode(options.mode, DEFAULT_PLAN_MODE);
   const harness = asHarness(options.harness);
   const fromSearch = options.fromSearch?.trim();
-  const related = toArray(options.related);
-  const blocks = toArray(options.blocks);
-  const blockedBy = toArray(options.blockedBy);
-  const deps = [];
-  if (options.parent) {
-    deps.push(`id=${options.parent.trim()},kind=parent`);
-  }
-  for (const ref of related)
-    deps.push(`id=${ref},kind=related`);
-  for (const ref of blocks)
-    deps.push(`id=${ref},kind=blocks`);
-  for (const ref of blockedBy)
-    deps.push(`id=${ref},kind=blocked_by`);
   const description = options.description?.trim() ?? options.scope?.trim() ?? title;
   const createOptions = {
     title,
@@ -492,7 +592,7 @@ async function planCreate(options, global, ctx) {
     tags: options.tags,
     priority: options.priority,
     parent: options.parent,
-    dep: deps.length > 0 ? deps : void 0,
+    dep: buildPlanCreateDependencies(options),
     author: options.author,
     message: options.message ?? (fromSearch ? `plan create (search: ${fromSearch})` : `plan create`)
   };
@@ -526,78 +626,8 @@ async function planCreate(options, global, ctx) {
   });
   let finalMetadata = seedResult.item;
   let initialStep;
-  const initialValidationText = options.validationText?.trim();
-  const initialValidationCommand = options.validationCommand?.trim();
-  const initialValidationExpected = options.validationExpected?.trim();
-  const initialValidation = initialValidationText || initialValidationCommand || initialValidationExpected ? {
-    text: initialValidationText || initialValidationCommand || "Validation check",
-    command: initialValidationCommand || void 0,
-    expected: initialValidationExpected || void 0
-  } : void 0;
-  const stepTitleFlag = options.stepTitle?.trim();
-  const repeatedStepTitles = toOrderedStepTitles(options.step);
-  const templateSteps = options.template?.trim() ? resolvePlanTemplateSteps(options.template) : [];
-  const stepTitles = [
-    ...stepTitleFlag ? [stepTitleFlag] : [],
-    ...repeatedStepTitles,
-    ...templateSteps.map((step) => step.title)
-  ];
-  const hasPerStepDetailOptions = Boolean(options.stepBody?.trim()) || Boolean(options.stepOwner?.trim()) || Boolean(options.stepStatus?.trim()) || Boolean(options.stepEvidence?.trim()) || Boolean(options.stepBlockedReason?.trim()) || Boolean(options.stepReplacement?.trim()) || toArray(options.dependsOn).length > 0 || toArray(options.link).length > 0 || toSpecArray(options.file).length > 0 || toSpecArray(options.test).length > 0 || toSpecArray(options.doc).length > 0;
-  if ((stepTitleFlag || repeatedStepTitles.length > 0) && templateSteps.length > 0) {
-    throw new PmCliError("pm plan create --template cannot be combined with --step-title or --step; choose one step seeding source", EXIT_CODE.USAGE, {
-      code: "ambiguous_option_combination",
-      examples: [
-        `pm plan create --title "Fix login crash" --template ${PLAN_TEMPLATE_NAMES[0]}`,
-        'pm plan create --title "Custom plan" --step "Read the code" --step "Write the fix"'
-      ]
-    });
-  }
-  if (stepTitles.length > 1 && hasPerStepDetailOptions) {
-    throw new PmCliError("pm plan create per-step options apply to a single initial step; with multiple --step values create the plan first, then refine steps individually", EXIT_CODE.USAGE, {
-      code: "ambiguous_option_combination",
-      examples: [
-        'pm plan create --title "Execution plan" --step "Read the code" --step "Write the fix"',
-        'pm plan update-step <plan-id> plan-step-001 --step-body "Inspect retry path"'
-      ]
-    });
-  }
-  let initialSteps = [];
-  if (stepTitles.length === 1) {
-    const status = asStepStatus(options.stepStatus, "pending");
-    const linkedItems = buildLinkInputs(options, "depends_on");
-    const files = toSpecArray(options.file).map(parseStepFile);
-    const tests = toSpecArray(options.test).map(parseStepTest);
-    const docs = toSpecArray(options.doc).map(parseStepDoc);
-    const now = nowIso();
-    initialSteps = [{
-      id: "plan-step-001",
-      order: 1,
-      title: stepTitles[0],
-      body: options.stepBody?.trim() || void 0,
-      status,
-      owner: options.stepOwner?.trim() || void 0,
-      evidence: options.stepEvidence?.trim() || void 0,
-      blocked_reason: status === "blocked" ? options.stepBlockedReason?.trim() || "" : void 0,
-      linked_items: linkedItems.length > 0 ? linkedItems : void 0,
-      files: files.length > 0 ? files : void 0,
-      tests: tests.length > 0 ? tests : void 0,
-      docs: docs.length > 0 ? docs : void 0,
-      created_at: now,
-      updated_at: now,
-      completed_at: status === "completed" ? now : void 0
-    }];
-  } else if (stepTitles.length > 1) {
-    const now = nowIso();
-    initialSteps = stepTitles.map((stepTitle, index) => ({
-      id: `${STEP_ID_PREFIX}${String(index + 1).padStart(3, "0")}`,
-      order: index + 1,
-      title: stepTitle,
-      body: templateSteps[index]?.body,
-      status: "pending",
-      created_at: now,
-      updated_at: now
-    }));
-  }
+  const initialValidation = buildInitialValidation(options);
+  const { steps: initialSteps, hasPerStepDetailOptions } = buildInitialSteps(options);
   if (initialSteps.length > 0) {
     initialStep = initialSteps[0];
     const stepped = await mutateItem({
@@ -717,10 +747,6 @@ async function planAddStep(id, options, ctx) {
   }
   const status = asStepStatus(options.stepStatus, "pending");
   const allowMultipleActive = options.allowMultipleActive === true;
-  const linkedItems = buildLinkInputs(options, "depends_on");
-  const files = toSpecArray(options.file).map(parseStepFile);
-  const tests = toSpecArray(options.test).map(parseStepTest);
-  const docs = toSpecArray(options.doc).map(parseStepDoc);
   const { document, resultStep, itemId } = await mutatePlanSteps({
     id,
     options,
@@ -729,31 +755,8 @@ async function planAddStep(id, options, ctx) {
     message: `plan add-step "${title}"`,
     mutator(steps) {
       const order = steps.length + 1;
-      if (status === "in_progress" && !allowMultipleActive) {
-        for (const step2 of steps) {
-          if (step2.status === "in_progress") {
-            throw new PmCliError(`Plan already has step ${step2.id} in_progress. Pass --allow-multiple-active or update that step first.`, EXIT_CODE.CONFLICT);
-          }
-        }
-      }
-      const now = nowIso();
-      const step = {
-        id: newStepId(steps),
-        order,
-        title,
-        body: options.stepBody?.trim() || void 0,
-        status,
-        owner: options.stepOwner?.trim() || void 0,
-        evidence: options.stepEvidence?.trim() || void 0,
-        blocked_reason: status === "blocked" ? options.stepBlockedReason?.trim() || "" : void 0,
-        linked_items: linkedItems.length > 0 ? linkedItems : void 0,
-        files: files.length > 0 ? files : void 0,
-        tests: tests.length > 0 ? tests : void 0,
-        docs: docs.length > 0 ? docs : void 0,
-        created_at: now,
-        updated_at: now,
-        completed_at: status === "completed" ? now : void 0
-      };
+      assertInProgressStepAllowed(steps, void 0, status, allowMultipleActive);
+      const step = buildAddedPlanStep(steps, options, { order, title, status });
       steps.push(step);
       return { changedSteps: [step.id], resultStep: step };
     }
@@ -768,6 +771,40 @@ async function planAddStep(id, options, ctx) {
     generated_at: nowIso()
   };
 }
+function assertInProgressStepAllowed(steps, currentStepId, desiredStatus, allowMultipleActive) {
+  if (desiredStatus !== "in_progress" || allowMultipleActive) {
+    return;
+  }
+  const activeStep = steps.find((step) => step.id !== currentStepId && step.status === "in_progress");
+  if (!activeStep) {
+    return;
+  }
+  throw new PmCliError(`Plan already has step ${activeStep.id} in_progress. Pass --allow-multiple-active or update that step first.`, EXIT_CODE.CONFLICT);
+}
+function buildAddedPlanStep(existingSteps, options, seed) {
+  const linkedItems = buildLinkInputs(options, "depends_on");
+  const files = toSpecArray(options.file).map(parseStepFile);
+  const tests = toSpecArray(options.test).map(parseStepTest);
+  const docs = toSpecArray(options.doc).map(parseStepDoc);
+  const now = nowIso();
+  return {
+    id: newStepId(existingSteps),
+    order: seed.order,
+    title: seed.title,
+    body: options.stepBody?.trim() || void 0,
+    status: seed.status,
+    owner: options.stepOwner?.trim() || void 0,
+    evidence: options.stepEvidence?.trim() || void 0,
+    blocked_reason: seed.status === "blocked" ? options.stepBlockedReason?.trim() || "" : void 0,
+    linked_items: linkedItems.length > 0 ? linkedItems : void 0,
+    files: files.length > 0 ? files : void 0,
+    tests: tests.length > 0 ? tests : void 0,
+    docs: docs.length > 0 ? docs : void 0,
+    created_at: now,
+    updated_at: now,
+    completed_at: seed.status === "completed" ? now : void 0
+  };
+}
 function buildLinkInputs(options, fallbackKind) {
   const dependsOn = toArray(options.dependsOn).map((id) => ({ id, kind: fallbackKind }));
   const related = toArray(options.related).map((id) => ({ id, kind: "related" }));
@@ -795,35 +832,9 @@ async function planUpdateStep(id, options, ctx, args) {
       const step = resolveStepRef(steps, args.stepRef);
       const now = nowIso();
       const desiredStatus = args.finalStatus ?? asStepStatus(options.stepStatus, step.status);
-      if (desiredStatus === "in_progress" && step.status !== "in_progress" && !options.allowMultipleActive && !args.allowMultipleActive) {
-        for (const other of steps) {
-          if (other.id !== step.id && other.status === "in_progress") {
-            throw new PmCliError(`Plan already has step ${other.id} in_progress. Pass --allow-multiple-active or update that step first.`, EXIT_CODE.CONFLICT);
-          }
-        }
-      }
-      if (desiredStatus === "blocked" && !options.stepBlockedReason?.trim() && !step.blocked_reason) {
-        throw new PmCliError("Blocking a step requires --step-blocked-reason or an already-recorded blocked_reason.", EXIT_CODE.USAGE);
-      }
-      if (options.stepTitle?.trim())
-        step.title = options.stepTitle.trim();
-      if (options.stepBody !== void 0)
-        step.body = options.stepBody.trim() || void 0;
-      if (options.stepOwner !== void 0)
-        step.owner = options.stepOwner.trim() || void 0;
-      if (options.stepEvidence !== void 0)
-        step.evidence = options.stepEvidence.trim() || void 0;
-      if (options.stepBlockedReason !== void 0)
-        step.blocked_reason = options.stepBlockedReason.trim() || void 0;
-      if (options.stepReplacement !== void 0)
-        step.superseded_by = options.stepReplacement.trim() || void 0;
-      step.status = desiredStatus;
-      step.updated_at = now;
-      if (desiredStatus === "completed" && !step.completed_at) {
-        step.completed_at = now;
-      } else if (desiredStatus !== "completed") {
-        step.completed_at = void 0;
-      }
+      const allowMultipleActive = options.allowMultipleActive === true || args.allowMultipleActive === true;
+      assertInProgressStepAllowed(steps, step.status === "in_progress" ? step.id : void 0, desiredStatus, allowMultipleActive);
+      applyStepUpdates(step, options, desiredStatus, now);
       doc.metadata.updated_at = now;
       return { changedSteps: [step.id], resultStep: step };
     }
@@ -838,6 +849,49 @@ async function planUpdateStep(id, options, ctx, args) {
     generated_at: nowIso()
   };
 }
+function applyStepUpdates(step, options, desiredStatus, now) {
+  assertBlockedStepReason(step, options, desiredStatus);
+  applyStepFieldUpdates(step, options);
+  step.status = desiredStatus;
+  step.updated_at = now;
+  applyStepCompletionTimestamp(step, desiredStatus, now);
+}
+function assertBlockedStepReason(step, options, desiredStatus) {
+  if (desiredStatus !== "blocked" || options.stepBlockedReason?.trim() || step.blocked_reason) {
+    return;
+  }
+  throw new PmCliError("Blocking a step requires --step-blocked-reason or an already-recorded blocked_reason.", EXIT_CODE.USAGE);
+}
+function applyStepFieldUpdates(step, options) {
+  const title = options.stepTitle?.trim();
+  if (title) {
+    step.title = title;
+  }
+  if (options.stepBody !== void 0) {
+    step.body = options.stepBody.trim() || void 0;
+  }
+  if (options.stepOwner !== void 0) {
+    step.owner = options.stepOwner.trim() || void 0;
+  }
+  if (options.stepEvidence !== void 0) {
+    step.evidence = options.stepEvidence.trim() || void 0;
+  }
+  if (options.stepBlockedReason !== void 0) {
+    step.blocked_reason = options.stepBlockedReason.trim() || void 0;
+  }
+  if (options.stepReplacement !== void 0) {
+    step.superseded_by = options.stepReplacement.trim() || void 0;
+  }
+}
+function applyStepCompletionTimestamp(step, desiredStatus, now) {
+  if (desiredStatus === "completed" && !step.completed_at) {
+    step.completed_at = now;
+    return;
+  }
+  if (desiredStatus !== "completed") {
+    step.completed_at = void 0;
+  }
+}
 async function planReorderStep(id, options, ctx, stepRef, newOrder) {
   const { document, itemId } = await mutatePlanSteps({
     id,
@@ -1090,6 +1144,65 @@ async function planApprove(id, options, ctx) {
     generated_at: nowIso()
   };
 }
+function buildMaterializeSkippedWarnings(materializeSkipped) {
+  return materializeSkipped.map((entry) => `plan_materialize_skipped:${entry.from_step}:${entry.reason}${entry.existing_id ? `:${entry.existing_id}` : ""}`);
+}
+function buildMaterializeNoopResult(planRead, materializeSkipped) {
+  const plan = projectPlan(planRead.document.metadata, "standard");
+  return {
+    action: "materialize",
+    plan,
+    materialized: [],
+    materialize_skipped: materializeSkipped,
+    next_actions: nextActionsFor(planRead.itemId, plan),
+    warnings: buildMaterializeSkippedWarnings(materializeSkipped),
+    generated_at: nowIso()
+  };
+}
+function buildMaterializeDependencies(parent, planItemId, step) {
+  const deps = [
+    `id=${parent},kind=parent`,
+    `id=${planItemId},kind=discovered_from`
+  ];
+  for (const link of step.linked_items ?? []) {
+    const realKind = link.kind === "blocked_by" || link.kind === "blocks" || link.kind === "related" || link.kind === "discovered_from" ? link.kind : "related";
+    deps.push(`id=${link.id},kind=${realKind}`);
+  }
+  return deps;
+}
+async function createMaterializedStepItems(params) {
+  const materialized = [];
+  for (const step of params.targets) {
+    const created = await runCreate({
+      title: step.title,
+      description: step.body?.trim() || step.title,
+      type: params.resolvedTypeName,
+      parent: params.parent,
+      tags: params.tags,
+      author: params.options.author,
+      message: params.options.message ?? `materialized from plan ${params.planItemId} step ${step.id}`,
+      dep: buildMaterializeDependencies(params.parent, params.planItemId, step)
+    }, { ...{}, path: params.pmRoot });
+    materialized.push({ id: created.item.id, type: params.resolvedTypeName, from_step: step.id });
+  }
+  return materialized;
+}
+function linkMaterializedStepItems(currentSteps, targets, materialized) {
+  for (const target of targets) {
+    const matched = materialized.find((entry) => entry.from_step === target.id);
+    if (!matched) {
+      continue;
+    }
+    const step = currentSteps.find((entry) => entry.id === target.id);
+    if (!step) {
+      continue;
+    }
+    const links = step.linked_items ?? [];
+    links.push({ id: matched.id, kind: "implements", note: `materialized as ${matched.type}` });
+    step.linked_items = links;
+    step.updated_at = nowIso();
+  }
+}
 async function planMaterialize(id, options, ctx) {
   const stepRefs = toArray(options.steps);
   if (stepRefs.length === 0) {
@@ -1108,60 +1221,27 @@ async function planMaterialize(id, options, ctx) {
   const { targets, skipped: materializeSkipped } = resolveMaterializeTargets(steps, stepRefs);
   if (targets.length === 0) {
     if (materializeSkipped.length > 0) {
-      const plan2 = projectPlan(planRead.document.metadata, "standard");
-      return {
-        action: "materialize",
-        plan: plan2,
-        materialized: [],
-        materialize_skipped: materializeSkipped,
-        next_actions: nextActionsFor(planRead.itemId, plan2),
-        warnings: materializeSkipped.map((entry) => `plan_materialize_skipped:${entry.from_step}:${entry.reason}${entry.existing_id ? `:${entry.existing_id}` : ""}`),
-        generated_at: nowIso()
-      };
+      return buildMaterializeNoopResult(planRead, materializeSkipped);
     }
     throw new PmCliError("No matching plan steps found for --steps", EXIT_CODE.NOT_FOUND);
   }
-  const materialized = [];
-  for (const step of targets) {
-    const deps = [
-      `id=${parent},kind=parent`,
-      `id=${planRead.itemId},kind=discovered_from`
-    ];
-    for (const link of step.linked_items ?? []) {
-      const realKind = link.kind === "blocked_by" || link.kind === "blocks" || link.kind === "related" || link.kind === "discovered_from" ? link.kind : "related";
-      deps.push(`id=${link.id},kind=${realKind}`);
-    }
-    const created = await runCreate({
-      title: step.title,
-      description: step.body?.trim() || step.title,
-      type: resolvedTypeName,
-      parent,
-      tags,
-      author: options.author,
-      message: options.message ?? `materialized from plan ${planRead.itemId} step ${step.id}`,
-      dep: deps
-    }, ctx.settings ? { ...{}, path: ctx.pmRoot } : {});
-    materialized.push({ id: created.item.id, type: resolvedTypeName, from_step: step.id });
-  }
+  const materialized = await createMaterializedStepItems({
+    targets,
+    parent,
+    planItemId: planRead.itemId,
+    resolvedTypeName,
+    tags,
+    options,
+    pmRoot: ctx.pmRoot
+  });
   const { document, itemId } = await mutatePlanSteps({
     id,
     options,
     ctx,
     op: "plan_materialize",
     message: options.message ?? `plan materialize ${stepRefs.join(",")}`,
-    mutator(currentSteps, doc) {
-      for (const target of targets) {
-        const matched = materialized.find((entry) => entry.from_step === target.id);
-        if (!matched)
-          continue;
-        const step = currentSteps.find((entry) => entry.id === target.id);
-        if (!step)
-          continue;
-        const links = step.linked_items ?? [];
-        links.push({ id: matched.id, kind: "implements", note: `materialized as ${matched.type}` });
-        step.linked_items = links;
-        step.updated_at = nowIso();
-      }
+    mutator(currentSteps) {
+      linkMaterializedStepItems(currentSteps, targets, materialized);
       return { changedSteps: targets.map((entry) => entry.id) };
     }
   });
@@ -1172,87 +1252,101 @@ async function planMaterialize(id, options, ctx) {
     materialized,
     ...materializeSkipped.length > 0 ? { materialize_skipped: materializeSkipped } : {},
     next_actions: nextActionsFor(itemId, plan),
-    warnings: materializeSkipped.map((entry) => `plan_materialize_skipped:${entry.from_step}:${entry.reason}${entry.existing_id ? `:${entry.existing_id}` : ""}`),
+    warnings: buildMaterializeSkippedWarnings(materializeSkipped),
     generated_at: nowIso()
   };
 }
-async function runPlan(input) {
-  const ctx = await loadContext(input.global);
-  if (input.subcommand !== "create") {
-    const stepValues = toOrderedStepTitles(input.options.step);
-    if (stepValues.length > 1) {
-      throw new PmCliError(`pm plan ${input.subcommand} accepts a single --step/--step-title value (repeated --step seeds ordered steps only on pm plan create)`, EXIT_CODE.USAGE);
-    }
-    if (stepValues.length === 1 && !input.options.stepTitle?.trim()) {
-      input = { ...input, options: { ...input.options, stepTitle: stepValues[0] } };
-    }
+function normalizePlanStepAliasInput(input) {
+  if (input.subcommand === "create") {
+    return input;
+  }
+  const stepValues = toOrderedStepTitles(input.options.step);
+  if (stepValues.length > 1) {
+    throw new PmCliError(`pm plan ${input.subcommand} accepts a single --step/--step-title value (repeated --step seeds ordered steps only on pm plan create)`, EXIT_CODE.USAGE);
+  }
+  if (stepValues.length === 1 && !input.options.stepTitle?.trim()) {
+    return { ...input, options: { ...input.options, stepTitle: stepValues[0] } };
+  }
+  return input;
+}
+function requirePlanId(input, label) {
+  if (!input.id) {
+    throw new PmCliError(`pm plan ${label} requires a plan id`, EXIT_CODE.USAGE);
   }
-  switch (input.subcommand) {
-    case "create":
-      return planCreate(input.options, input.global, ctx);
-    case "show":
-      if (!input.id)
-        throw new PmCliError("pm plan show requires a plan id", EXIT_CODE.USAGE);
-      return planShow(input.id, input.options, ctx);
-    case "add-step":
-      if (!input.id)
-        throw new PmCliError("pm plan add-step requires a plan id", EXIT_CODE.USAGE);
-      return planAddStep(input.id, input.options, ctx);
-    case "update-step":
-      if (!input.id || !input.stepRef)
-        throw new PmCliError("pm plan update-step requires <plan-id> <step>", EXIT_CODE.USAGE);
-      return planUpdateStep(input.id, input.options, ctx, { stepRef: input.stepRef, op: "plan_update_step" });
-    case "complete-step":
-      if (!input.id || !input.stepRef)
-        throw new PmCliError("pm plan complete-step requires <plan-id> <step>", EXIT_CODE.USAGE);
-      return planUpdateStep(input.id, input.options, ctx, { stepRef: input.stepRef, finalStatus: "completed", op: "plan_complete_step" });
-    case "block-step":
-      if (!input.id || !input.stepRef)
-        throw new PmCliError("pm plan block-step requires <plan-id> <step>", EXIT_CODE.USAGE);
-      return planUpdateStep(input.id, input.options, ctx, { stepRef: input.stepRef, finalStatus: "blocked", op: "plan_block_step" });
-    case "reorder-step":
-      if (!input.id || !input.stepRef || input.reorderTo === void 0)
-        throw new PmCliError("pm plan reorder-step requires <plan-id> <step> <new-order>", EXIT_CODE.USAGE);
-      return planReorderStep(input.id, input.options, ctx, input.stepRef, input.reorderTo);
-    case "remove-step":
-      if (!input.id || !input.stepRef)
-        throw new PmCliError("pm plan remove-step requires <plan-id> <step>", EXIT_CODE.USAGE);
-      return planRemoveStep(input.id, input.options, ctx, input.stepRef);
-    case "link":
-      if (!input.id || !input.stepRef)
-        throw new PmCliError("pm plan link requires <plan-id> <step>", EXIT_CODE.USAGE);
-      return planLink(input.id, input.options, ctx, input.stepRef);
-    case "unlink":
-      if (!input.id || !input.stepRef)
-        throw new PmCliError("pm plan unlink requires <plan-id> <step>", EXIT_CODE.USAGE);
-      return planUnlink(input.id, input.options, ctx, input.stepRef);
-    case "decision":
-      if (!input.id)
-        throw new PmCliError("pm plan decision requires a plan id", EXIT_CODE.USAGE);
-      return planAppendLog(input.id, input.options, ctx, "decision");
-    case "discovery":
-      if (!input.id)
-        throw new PmCliError("pm plan discovery requires a plan id", EXIT_CODE.USAGE);
-      return planAppendLog(input.id, input.options, ctx, "discovery");
-    case "validation":
-      if (!input.id)
-        throw new PmCliError("pm plan validation requires a plan id", EXIT_CODE.USAGE);
-      return planAppendLog(input.id, input.options, ctx, "validation");
-    case "resume":
-      if (!input.id)
-        throw new PmCliError("pm plan resume requires a plan id", EXIT_CODE.USAGE);
-      return planResume(input.id, input.options, ctx);
-    case "approve":
-      if (!input.id)
-        throw new PmCliError("pm plan approve requires a plan id", EXIT_CODE.USAGE);
-      return planApprove(input.id, input.options, ctx);
-    case "materialize":
-      if (!input.id)
-        throw new PmCliError("pm plan materialize requires a plan id", EXIT_CODE.USAGE);
-      return planMaterialize(input.id, input.options, ctx);
-    default:
-      throw new PmCliError(`Unknown pm plan subcommand "${input.subcommand}"`, EXIT_CODE.USAGE);
+  return input.id;
+}
+function requirePlanStepRef(input, label) {
+  const id = requirePlanId(input, label);
+  if (!input.stepRef) {
+    throw new PmCliError(`pm plan ${label} requires <plan-id> <step>`, EXIT_CODE.USAGE);
+  }
+  return { id, stepRef: input.stepRef };
+}
+function requireReorderTarget(input) {
+  const target = requirePlanStepRef(input, "reorder-step");
+  if (input.reorderTo === void 0) {
+    throw new PmCliError("pm plan reorder-step requires <plan-id> <step> <new-order>", EXIT_CODE.USAGE);
   }
+  return { ...target, reorderTo: input.reorderTo };
+}
+var PLAN_DISPATCHERS = {
+  create: (input, ctx) => planCreate(input.options, input.global, ctx),
+  show: (input, ctx) => planShow(requirePlanId(input, "show"), input.options, ctx),
+  "add-step": (input, ctx) => planAddStep(requirePlanId(input, "add-step"), input.options, ctx),
+  "update-step": (input, ctx) => {
+    const target = requirePlanStepRef(input, "update-step");
+    return planUpdateStep(target.id, input.options, ctx, { stepRef: target.stepRef, op: "plan_update_step" });
+  },
+  "complete-step": (input, ctx) => {
+    const target = requirePlanStepRef(input, "complete-step");
+    return planUpdateStep(target.id, input.options, ctx, {
+      stepRef: target.stepRef,
+      finalStatus: "completed",
+      op: "plan_complete_step"
+    });
+  },
+  "block-step": (input, ctx) => {
+    const target = requirePlanStepRef(input, "block-step");
+    return planUpdateStep(target.id, input.options, ctx, {
+      stepRef: target.stepRef,
+      finalStatus: "blocked",
+      op: "plan_block_step"
+    });
+  },
+  "reorder-step": (input, ctx) => {
+    const target = requireReorderTarget(input);
+    return planReorderStep(target.id, input.options, ctx, target.stepRef, target.reorderTo);
+  },
+  "remove-step": (input, ctx) => {
+    const target = requirePlanStepRef(input, "remove-step");
+    return planRemoveStep(target.id, input.options, ctx, target.stepRef);
+  },
+  link: (input, ctx) => {
+    const target = requirePlanStepRef(input, "link");
+    return planLink(target.id, input.options, ctx, target.stepRef);
+  },
+  unlink: (input, ctx) => {
+    const target = requirePlanStepRef(input, "unlink");
+    return planUnlink(target.id, input.options, ctx, target.stepRef);
+  },
+  decision: (input, ctx) => planAppendLog(requirePlanId(input, "decision"), input.options, ctx, "decision"),
+  discovery: (input, ctx) => planAppendLog(requirePlanId(input, "discovery"), input.options, ctx, "discovery"),
+  validation: (input, ctx) => planAppendLog(requirePlanId(input, "validation"), input.options, ctx, "validation"),
+  resume: (input, ctx) => planResume(requirePlanId(input, "resume"), input.options, ctx),
+  approve: (input, ctx) => planApprove(requirePlanId(input, "approve"), input.options, ctx),
+  materialize: (input, ctx) => planMaterialize(requirePlanId(input, "materialize"), input.options, ctx)
+};
+function resolvePlanDispatcher(subcommand) {
+  const dispatcher = PLAN_DISPATCHERS[subcommand];
+  if (!dispatcher) {
+    throw new PmCliError(`Unknown pm plan subcommand "${subcommand}"`, EXIT_CODE.USAGE);
+  }
+  return dispatcher;
+}
+async function runPlan(input) {
+  const ctx = await loadContext(input.global);
+  const normalizedInput = normalizePlanStepAliasInput(input);
+  return resolvePlanDispatcher(normalizedInput.subcommand)(normalizedInput, ctx);
 }
 export {
   PLAN_SHOW_DEPTH_VALUES,
@@ -1261,6 +1355,6 @@ export {
   resolvePlanTemplateSteps,
   runPlan
 };
-//# sourceMappingURL=plan-ZHKZ7JVF.js.map
+//# sourceMappingURL=plan-BGDR73Z6.js.map
 
-//# debugId=29e74621-056d-50a2-8168-18b5c3a20a97
+//# debugId=ef3dc07a-8c97-52e0-9665-6d7daf701594