@gh-symphony/cli 0.0.18 → 0.0.20

package/dist/{chunk-5YLETHMR.js → chunk-RN2PACNV.js}

@@ -1,17 +1,15 @@
 #!/usr/bin/env node
 import {
+  GhAuthError,
   GitHubScopeError,
   checkRequiredScopes,
   createClient,
+  getGhTokenWithSource,
   getProjectDetail,
   listUserProjects,
+  resolveGitHubAuth,
   validateToken
-} from "./chunk-62L6QQE6.js";
-import {
-  GhAuthError,
-  ensureGhAuth,
-  getGhToken
-} from "./chunk-7UBUBSMH.js";
+} from "./chunk-TILHWBP6.js";
 import {
   loadGlobalConfig,
   saveGlobalConfig,
@@ -21,7 +19,7 @@ import {
 // src/commands/init.ts
 import * as p from "@clack/prompts";
 import { createHash } from "crypto";
-import { mkdir as mkdir3, rename, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "fs/promises";
 import { basename, dirname as dirname2, join as join3, relative, resolve } from "path";
 
 // src/mapping/smart-defaults.ts
@@ -468,16 +466,6 @@ function generateContextYamlString(context) {
   lines.push(`  agent_command: ${yamlQuote(context.runtime.agent_command)}`);
   return lines.join("\n") + "\n";
 }
-async function writeContextYaml(outputDir, context) {
-  await mkdir(outputDir, { recursive: true });
-  const contextPath = `${outputDir}/.gh-symphony/context.yaml`;
-  await mkdir(dirname(contextPath), { recursive: true });
-  const temporaryPath = `${contextPath}.tmp`;
-  const yamlContent = generateContextYamlString(context);
-  await writeFile(temporaryPath, yamlContent, "utf8");
-  const { rename: rename2 } = await import("fs/promises");
-  await rename2(temporaryPath, contextPath);
-}
 function buildContextYaml(params) {
   const columns = params.statusField.options.map((option) => {
     const roleMapping = inferStateRole(option.name);
@@ -858,7 +846,7 @@ function resolveRoleAction(role) {
 }
 
 // src/skills/skill-writer.ts
-import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile2 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile2, rename, writeFile as writeFile2 } from "fs/promises";
 import { join as join2 } from "path";
 function normalizeRuntimeForSkills(runtime) {
   if (runtime === "claude-code" || runtime.includes("claude-code")) {
@@ -879,44 +867,18 @@ function resolveSkillsDir(repoRoot, runtime) {
   }
   return null;
 }
-async function writeSkillFile(skillsDir, template, context, options) {
-  const skillDir = join2(skillsDir, template.name);
-  const filePath = join2(skillDir, template.fileName);
-  if (!options?.overwrite) {
-    try {
-      await readFile2(filePath, "utf8");
-      return { written: false, path: filePath };
-    } catch (error) {
-      const err = error;
-      if (err.code !== "ENOENT") {
-        throw error;
-      }
-    }
-  }
-  await mkdir2(skillDir, { recursive: true });
-  const content = template.generate(context);
-  const temporaryPath = `${filePath}.tmp`;
-  await writeFile2(temporaryPath, content, "utf8");
-  const { rename: rename2 } = await import("fs/promises");
-  await rename2(temporaryPath, filePath);
-  return { written: true, path: filePath };
-}
-async function writeAllSkills(repoRoot, runtime, templates, context, options) {
+function buildSkillFilePlans(repoRoot, runtime, templates, context) {
   const skillsDir = resolveSkillsDir(repoRoot, runtime);
   if (!skillsDir) {
-    return { written: [], skipped: [] };
-  }
-  const written = [];
-  const skipped = [];
-  for (const template of templates) {
-    const result = await writeSkillFile(skillsDir, template, context, options);
-    if (result.written) {
-      written.push(result.path);
-    } else {
-      skipped.push(result.path);
-    }
+    return { skillsDir: null, files: [] };
   }
-  return { written, skipped };
+  return {
+    skillsDir,
+    files: templates.map((template) => ({
+      path: join2(skillsDir, template.name, template.fileName),
+      content: template.generate(context)
+    }))
+  };
 }
 
 // src/skills/templates/document.ts
@@ -1454,6 +1416,7 @@ async function abortIfCancelled(input) {
 }
 function parseInitFlags(args) {
   const flags = {
+    dryRun: false,
     nonInteractive: false,
     skipSkills: false,
     skipContext: false
@@ -1462,6 +1425,9 @@ function parseInitFlags(args) {
     const arg = args[i];
     const next = args[i + 1];
     switch (arg) {
+      case "--dry-run":
+        flags.dryRun = true;
+        break;
       case "--non-interactive":
         flags.nonInteractive = true;
         break;
@@ -1489,29 +1455,145 @@ var handler = async (args, options) => {
     await runNonInteractive(flags, options);
     return;
   }
-  await runInteractive(options);
+  await runInteractive(flags, options);
 };
 var init_default = handler;
-async function writeEcosystem(opts) {
+async function resolveChangeStatus(path, content, mode) {
+  try {
+    const existing = await readFile3(path, "utf8");
+    if (mode === "create-only") {
+      return "unchanged";
+    }
+    return existing === content ? "unchanged" : "update";
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") {
+      return "create";
+    }
+    throw error;
+  }
+}
+async function planFileChange(input) {
+  return {
+    ...input,
+    status: await resolveChangeStatus(input.path, input.content, input.mode)
+  };
+}
+async function writePlannedFile(file) {
+  if (file.status === "unchanged") {
+    return false;
+  }
+  await mkdir3(dirname2(file.path), { recursive: true });
+  const temporaryPath = `${file.path}.tmp`;
+  await writeFile3(temporaryPath, file.content, "utf8");
+  await rename2(temporaryPath, file.path);
+  return true;
+}
+function resolveStatusField(projectDetail) {
+  return projectDetail.statusFields.find((f) => f.name.toLowerCase() === "status") ?? projectDetail.statusFields[0] ?? null;
+}
+function buildAutomaticStateMappings(statusField) {
+  const mappings = {};
+  for (const mapping of inferAllStateRoles(statusField.options.map((o) => o.name))) {
+    if (mapping.role) {
+      mappings[mapping.columnName] = { role: mapping.role };
+    }
+  }
+  return mappings;
+}
+async function promptStateMappings(statusField, options) {
+  const mappings = {};
+  const inferred = inferAllStateRoles(statusField.options.map((o) => o.name));
+  p.log.info(
+    `Found ${statusField.options.length} status columns on field "${statusField.name}".`
+  );
+  for (const mapping of inferred) {
+    const roleOptions = [
+      { value: "active", label: "Active (agent works on this)" },
+      { value: "wait", label: "Wait (human review / hold)" },
+      { value: "terminal", label: "Terminal (completed)" }
+    ];
+    const defaultRole = mapping.role ?? "wait";
+    const sortedOptions = [
+      roleOptions.find((o) => o.value === defaultRole),
+      ...roleOptions.filter((o) => o.value !== defaultRole)
+    ];
+    const selectedRole = await abortIfCancelled(
+      p.select({
+        message: `${options?.stepLabel ?? "Step 2/2"} \u2014 Map column "${mapping.columnName}":${mapping.confidence === "high" ? " (auto-detected)" : ""}`,
+        options: sortedOptions
+      })
+    );
+    mappings[mapping.columnName] = { role: selectedRole };
+  }
+  return mappings;
+}
+async function planWorkflowArtifacts(opts) {
+  const workflowMd = generateWorkflowMarkdown({
+    projectId: opts.projectDetail.id,
+    stateFieldName: opts.statusField.name,
+    mappings: opts.mappings,
+    lifecycle: toWorkflowLifecycleConfig(opts.statusField.name, opts.mappings),
+    runtime: opts.runtime
+  });
+  const workflowPlan = await planFileChange({
+    path: opts.outputPath,
+    label: "WORKFLOW.md",
+    content: workflowMd,
+    mode: "overwrite"
+  });
+  const ecosystemPlan = await planEcosystem({
+    cwd: opts.cwd,
+    projectDetail: opts.projectDetail,
+    statusField: opts.statusField,
+    runtime: opts.runtime,
+    skipSkills: opts.skipSkills,
+    skipContext: opts.skipContext
+  });
+  return {
+    outputPath: opts.outputPath,
+    workflowMd,
+    workflowPlan,
+    ecosystemPlan
+  };
+}
+async function writeWorkflowPlan(workflowPlan) {
+  return writePlannedFile(workflowPlan);
+}
+function summarizeEnvironment(env) {
+  return [
+    `Package manager   ${env.packageManager ?? "none"}${env.lockfile ? ` (${env.lockfile})` : ""}`,
+    `Scripts   test=${env.testCommand ?? "none"} | lint=${env.lintCommand ?? "none"} | build=${env.buildCommand ?? "none"}`,
+    `CI   ${env.ciPlatform ?? "none"}`,
+    `Monorepo   ${env.monorepo ? "yes" : "no"}`,
+    `Existing skills   ${env.existingSkills.length === 0 ? "none" : env.existingSkills.join(", ")}`
+  ];
+}
+async function planEcosystem(opts) {
   const { cwd, projectDetail, statusField, runtime, skipSkills, skipContext } = opts;
   const ghSymphonyDir = join3(cwd, ".gh-symphony");
-  await mkdir3(ghSymphonyDir, { recursive: true });
-  const env = await detectEnvironment(cwd);
-  let contextYamlWritten = false;
+  const environment = await detectEnvironment(cwd);
+  const files = [];
   if (!skipContext) {
     const contextYaml = buildContextYaml({
       projectDetail,
       statusField,
-      detectedEnvironment: env,
+      detectedEnvironment: environment,
       runtime: {
         agent: runtime,
         agent_command: runtime === "codex" ? "bash -lc codex app-server" : runtime === "claude-code" ? "bash -lc claude-code" : runtime
       }
     });
-    await writeContextYaml(cwd, contextYaml);
-    contextYamlWritten = true;
+    files.push(
+      await planFileChange({
+        path: join3(ghSymphonyDir, "context.yaml"),
+        label: "Context metadata",
+        content: generateContextYamlString(contextYaml),
+        mode: "overwrite"
+      })
+    );
   }
-  const refWorkflow = generateReferenceWorkflow({
+  const referenceWorkflow = generateReferenceWorkflow({
     runtime,
     statusColumns: statusField.options.map((o) => ({
       name: o.name,
@@ -1519,43 +1601,99 @@ async function writeEcosystem(opts) {
     })),
     projectId: projectDetail.id
   });
-  const refPath = join3(ghSymphonyDir, "reference-workflow.md");
-  const tmpRef = refPath + ".tmp";
-  await writeFile3(tmpRef, refWorkflow, "utf8");
-  await rename(tmpRef, refPath);
-  const skillsDir = resolveSkillsDir(cwd, runtime);
-  let skillsWritten = [];
-  let skillsSkipped = [];
+  files.push(
+    await planFileChange({
+      path: join3(ghSymphonyDir, "reference-workflow.md"),
+      label: "Reference workflow",
+      content: referenceWorkflow,
+      mode: "overwrite"
+    })
+  );
+  const skillsDir = skipSkills ? null : resolveSkillsDir(cwd, runtime);
   if (!skipSkills && skillsDir) {
-    const result = await writeAllSkills(cwd, runtime, ALL_SKILL_TEMPLATES, {
+    const { files: plannedSkills } = buildSkillFilePlans(
+      cwd,
       runtime,
-      projectId: projectDetail.id,
-      githubProjectTitle: projectDetail.title,
-      repositories: projectDetail.linkedRepositories.map((r) => ({
-        owner: r.owner,
-        name: r.name
-      })),
-      statusColumns: statusField.options.map((o) => ({
-        id: o.id,
-        name: o.name,
-        role: null
-      })),
-      statusFieldId: statusField.id,
-      contextYamlPath: ".gh-symphony/context.yaml",
-      referenceWorkflowPath: ".gh-symphony/reference-workflow.md"
-    });
-    skillsWritten = result.written.map((p2) => basename(dirname2(p2)));
-    skillsSkipped = result.skipped.map((p2) => basename(dirname2(p2)));
+      ALL_SKILL_TEMPLATES,
+      {
+        runtime,
+        projectId: projectDetail.id,
+        githubProjectTitle: projectDetail.title,
+        repositories: projectDetail.linkedRepositories.map((r) => ({
+          owner: r.owner,
+          name: r.name
+        })),
+        statusColumns: statusField.options.map((o) => ({
+          id: o.id,
+          name: o.name,
+          role: null
+        })),
+        statusFieldId: statusField.id,
+        contextYamlPath: ".gh-symphony/context.yaml",
+        referenceWorkflowPath: ".gh-symphony/reference-workflow.md"
+      }
+    );
+    for (const plannedSkill of plannedSkills) {
+      files.push(
+        await planFileChange({
+          path: plannedSkill.path,
+          label: `Skill ${basename(dirname2(plannedSkill.path))}`,
+          content: plannedSkill.content,
+          mode: "create-only"
+        })
+      );
+    }
   }
   return {
     projectId: projectDetail.id,
     githubProjectTitle: projectDetail.title,
     runtime,
     skillsDir,
+    environment,
+    files
+  };
+}
+async function writeEcosystem(opts) {
+  const plan = await planEcosystem(opts);
+  await mkdir3(join3(opts.cwd, ".gh-symphony"), { recursive: true });
+  const contextYamlPath = join3(opts.cwd, ".gh-symphony", "context.yaml");
+  const referenceWorkflowPath = join3(
+    opts.cwd,
+    ".gh-symphony",
+    "reference-workflow.md"
+  );
+  let contextYamlWritten = false;
+  let referenceWorkflowWritten = false;
+  const skillsWritten = [];
+  const skillsSkipped = [];
+  for (const file of plan.files) {
+    const written = await writePlannedFile(file);
+    if (file.path === contextYamlPath) {
+      contextYamlWritten = written;
+      continue;
+    }
+    if (file.path === referenceWorkflowPath) {
+      referenceWorkflowWritten = written;
+      continue;
+    }
+    if (file.label.startsWith("Skill ")) {
+      const skillName = basename(dirname2(file.path));
+      if (written) {
+        skillsWritten.push(skillName);
+      } else {
+        skillsSkipped.push(skillName);
+      }
+    }
+  }
+  return {
+    projectId: plan.projectId,
+    githubProjectTitle: plan.githubProjectTitle,
+    runtime: plan.runtime,
+    skillsDir: plan.skillsDir,
     contextYamlWritten,
-    referenceWorkflowWritten: true,
-    skillsWritten,
-    skillsSkipped
+    referenceWorkflowWritten,
+    skillsWritten: skillsWritten.sort(),
+    skillsSkipped: skillsSkipped.sort()
   };
 }
 function printEcosystemSummary(result, workflowPath, opts) {
@@ -1598,10 +1736,65 @@ function printEcosystemSummary(result, workflowPath, opts) {
     process.stdout.write(lines.map((l) => `  ${l}`).join("\n") + "\n");
   }
 }
+function renderDryRunPreview(workflowPath, workflowPlan, ecosystemPlan) {
+  const cwd = process.cwd();
+  const relWorkflow = relative(cwd, workflowPath) || "WORKFLOW.md";
+  const statusIcon = {
+    create: "+",
+    update: "~",
+    unchanged: "="
+  };
+  const lines = [];
+  lines.push("Init dry-run preview");
+  lines.push(
+    `GitHub Project   ${ecosystemPlan.githubProjectTitle}  (${ecosystemPlan.projectId})`
+  );
+  lines.push(`Runtime   ${ecosystemPlan.runtime}`);
+  lines.push("");
+  lines.push("Planned file changes");
+  lines.push(
+    `  ${statusIcon[workflowPlan.status]} ${workflowPlan.status.padEnd(9)} WORKFLOW.md                          ${relWorkflow}`
+  );
+  for (const file of ecosystemPlan.files) {
+    const relPath = relative(cwd, file.path) || file.path;
+    lines.push(
+      `  ${statusIcon[file.status]} ${file.status.padEnd(9)} ${file.label.padEnd(36)} ${relPath}`
+    );
+  }
+  lines.push("");
+  lines.push("Detected environment inputs");
+  for (const line of summarizeEnvironment(ecosystemPlan.environment)) {
+    lines.push(`  ${line}`);
+  }
+  lines.push("");
+  lines.push("Dry run only. No files were written.");
+  return lines.join("\n") + "\n";
+}
+function buildDryRunJsonResult(workflowPath, workflowPlan, ecosystemPlan) {
+  return {
+    dryRun: true,
+    output: workflowPath,
+    projectId: ecosystemPlan.projectId,
+    githubProjectTitle: ecosystemPlan.githubProjectTitle,
+    runtime: ecosystemPlan.runtime,
+    files: [workflowPlan, ...ecosystemPlan.files].map((file) => ({
+      path: file.path,
+      label: file.label,
+      status: file.status,
+      mode: file.mode
+    })),
+    environment: ecosystemPlan.environment
+  };
+}
+function printDryRunPreview(workflowPath, workflowPlan, ecosystemPlan) {
+  process.stdout.write(
+    renderDryRunPreview(workflowPath, workflowPlan, ecosystemPlan)
+  );
+}
 async function runNonInteractive(flags, options) {
   let token;
   try {
-    token = getGhToken();
+    token = getGhTokenWithSource().token;
   } catch {
     process.stderr.write(
       "Error: GitHub token not found. Run 'gh auth login --scopes repo,read:org,project' or set GITHUB_GRAPHQL_TOKEN.\n"
@@ -1649,20 +1842,13 @@ async function runNonInteractive(flags, options) {
     process.exitCode = 1;
     return;
   }
-  const statusField = githubProject.statusFields.find((f) => f.name.toLowerCase() === "status") ?? githubProject.statusFields[0];
+  const statusField = resolveStatusField(githubProject);
   if (!statusField) {
     process.stderr.write("Error: No status field found on the project.\n");
     process.exitCode = 1;
     return;
   }
-  const columnNames = statusField.options.map((o) => o.name);
-  const inferred = inferAllStateRoles(columnNames);
-  const mappings = {};
-  for (const mapping of inferred) {
-    if (mapping.role) {
-      mappings[mapping.columnName] = { role: mapping.role };
-    }
-  }
+  const mappings = buildAutomaticStateMappings(statusField);
   const validation = validateStateMapping(mappings);
   if (!validation.valid) {
     process.stderr.write(
@@ -1673,16 +1859,30 @@ Run without --non-interactive for manual mapping.
     process.exitCode = 1;
     return;
   }
-  const lifecycleConfig = toWorkflowLifecycleConfig(statusField.name, mappings);
   const outputPath = resolve(flags.output ?? "WORKFLOW.md");
-  const workflowMd = generateWorkflowMarkdown({
-    projectId: githubProject.id,
-    stateFieldName: statusField.name,
+  const { workflowPlan, ecosystemPlan } = await planWorkflowArtifacts({
+    cwd: process.cwd(),
+    outputPath,
+    projectDetail: githubProject,
+    statusField,
     mappings,
-    lifecycle: lifecycleConfig,
-    runtime: "codex"
+    runtime: "codex",
+    skipSkills: flags.skipSkills,
+    skipContext: flags.skipContext
   });
-  await writeFile3(outputPath, workflowMd, "utf8");
+  if (flags.dryRun) {
+    if (options.json) {
+      process.stdout.write(
+        JSON.stringify(
+          buildDryRunJsonResult(outputPath, workflowPlan, ecosystemPlan)
+        ) + "\n"
+      );
+      return;
+    }
+    printDryRunPreview(outputPath, workflowPlan, ecosystemPlan);
+    return;
+  }
+  await writeWorkflowPlan(workflowPlan);
   const ecosystemResult = await writeEcosystem({
     cwd: process.cwd(),
     projectDetail: githubProject,
@@ -1693,7 +1893,7 @@ Run without --non-interactive for manual mapping.
   });
   if (options.json) {
     process.stdout.write(
-      JSON.stringify({ output: outputPath, status: "created" }) + "\n"
+      JSON.stringify({ output: outputPath, status: workflowPlan.status }) + "\n"
     );
   } else {
     printEcosystemSummary(ecosystemResult, outputPath, {
@@ -1702,36 +1902,23 @@ Run without --non-interactive for manual mapping.
     });
   }
 }
-async function runInteractive(options) {
+async function runInteractive(flags, options) {
   p.intro("gh-symphony \u2014 WORKFLOW.md Setup");
-  await runInteractiveStandalone(options);
+  await runInteractiveStandalone(flags, options);
 }
-async function runInteractiveStandalone(_options) {
+async function runInteractiveStandalone(flags, _options) {
   const s1 = p.spinner();
-  s1.start("Checking gh CLI authentication...");
+  s1.start("Checking GitHub authentication...");
   let client;
   try {
-    const { token } = ensureGhAuth();
-    client = createClient(token);
-    s1.stop("Authenticated via gh CLI");
+    const auth = await resolveGitHubAuth();
+    const sourceLabel = auth.source === "env" ? "GITHUB_GRAPHQL_TOKEN" : "gh CLI";
+    client = createClient(auth.token);
+    s1.stop(`Authenticated via ${sourceLabel} as ${auth.login}`);
   } catch (error) {
     s1.stop("Authentication failed.");
     if (error instanceof GhAuthError) {
-      if (error.code === "not_installed") {
-        p.log.error(
-          "gh CLI\uAC00 \uC124\uCE58\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. https://cli.github.com \uC5D0\uC11C \uC124\uCE58\uD558\uC138\uC694."
-        );
-      } else if (error.code === "not_authenticated") {
-        p.log.error(
-          "gh auth login --scopes repo,read:org,project \uB97C \uC2E4\uD589\uD558\uC138\uC694."
-        );
-      } else if (error.code === "missing_scopes") {
-        p.log.error(
-          "gh auth refresh --scopes repo,read:org,project \uB97C \uC2E4\uD589\uD558\uC138\uC694."
-        );
-      } else {
-        p.log.error(error.message);
-      }
+      p.log.error(error.message);
     } else {
       p.log.error(error instanceof Error ? error.message : "Unknown error");
     }
@@ -1749,7 +1936,7 @@ async function runInteractiveStandalone(_options) {
   } catch (error) {
     s2.stop("Failed to load projects.");
     if (error instanceof GitHubScopeError) {
-      displayScopeError(error, "gh-symphony init");
+      displayScopeError(error, "gh-symphony workflow init");
     } else {
       p.log.error(error instanceof Error ? error.message : "Unknown error");
     }
@@ -1786,7 +1973,7 @@ async function runInteractiveStandalone(_options) {
     process.exitCode = 1;
     return;
   }
-  const statusField = projectDetail.statusFields.find((f) => f.name.toLowerCase() === "status") ?? projectDetail.statusFields[0];
+  const statusField = resolveStatusField(projectDetail);
   if (!statusField) {
     p.log.error(
       "No status field found on the project. The project needs a single-select 'Status' field."
@@ -1794,33 +1981,7 @@ async function runInteractiveStandalone(_options) {
     process.exitCode = 1;
     return;
   }
-  const columnNames = statusField.options.map((o) => o.name);
-  const inferred = inferAllStateRoles(columnNames);
-  p.log.info(
-    `Found ${columnNames.length} status columns on field "${statusField.name}".`
-  );
-  const mappings = {};
-  for (const mapping of inferred) {
-    const roleOptions = [
-      { value: "active", label: "Active (agent works on this)" },
-      { value: "wait", label: "Wait (human review / hold)" },
-      { value: "terminal", label: "Terminal (completed)" }
-    ];
-    const defaultRole = mapping.role ?? "wait";
-    const sortedOptions = [
-      roleOptions.find((o) => o.value === defaultRole),
-      ...roleOptions.filter((o) => o.value !== defaultRole)
-    ];
-    const selectedRole = await abortIfCancelled(
-      p.select({
-        message: `Step 2/2 \u2014 Map column "${mapping.columnName}":${mapping.confidence === "high" ? " (auto-detected)" : ""}`,
-        options: sortedOptions
-      })
-    );
-    if (selectedRole !== "skip") {
-      mappings[mapping.columnName] = { role: selectedRole };
-    }
-  }
+  const mappings = await promptStateMappings(statusField);
   const validation = validateStateMapping(mappings);
   if (!validation.valid) {
     p.log.error("Mapping validation failed:");
@@ -1833,23 +1994,29 @@ async function runInteractiveStandalone(_options) {
   for (const warn of validation.warnings) {
     p.log.warn(`  \u26A0 ${warn}`);
   }
-  const lifecycleConfig = toWorkflowLifecycleConfig(statusField.name, mappings);
-  const workflowMd = generateWorkflowMarkdown({
-    projectId: projectDetail.id,
-    stateFieldName: statusField.name,
+  const outputPath = resolve(flags.output ?? "WORKFLOW.md");
+  const { workflowPlan, ecosystemPlan } = await planWorkflowArtifacts({
+    cwd: process.cwd(),
+    outputPath,
+    projectDetail,
+    statusField,
     mappings,
-    lifecycle: lifecycleConfig,
-    runtime: "codex"
+    runtime: "codex",
+    skipSkills: flags.skipSkills,
+    skipContext: flags.skipContext
   });
-  const outputPath = resolve("WORKFLOW.md");
-  await writeFile3(outputPath, workflowMd, "utf8");
+  if (flags.dryRun) {
+    printDryRunPreview(outputPath, workflowPlan, ecosystemPlan);
+    return;
+  }
+  await writeWorkflowPlan(workflowPlan);
   const ecosystemResult = await writeEcosystem({
     cwd: process.cwd(),
     projectDetail,
     statusField,
     runtime: "codex",
-    skipSkills: false,
-    skipContext: false
+    skipSkills: flags.skipSkills,
+    skipContext: flags.skipContext
   });
   printEcosystemSummary(ecosystemResult, outputPath, {
     interactive: true,
@@ -1893,9 +2060,18 @@ function generateProjectId(githubProjectTitle, uniqueKey) {
 }
 
 export {
+  validateStateMapping,
   abortIfCancelled,
   init_default,
+  resolveStatusField,
+  buildAutomaticStateMappings,
+  promptStateMappings,
+  planWorkflowArtifacts,
+  writeWorkflowPlan,
+  planEcosystem,
   writeEcosystem,
+  renderDryRunPreview,
+  buildDryRunJsonResult,
   writeConfig,
   generateProjectId
 };