@gh-symphony/cli 0.0.17 → 0.0.19

package/dist/{chunk-IWR4UQEJ.js → chunk-RN2PACNV.js}

@@ -1,9 +1,15 @@
 #!/usr/bin/env node
 import {
   GhAuthError,
-  ensureGhAuth,
-  getGhToken
-} from "./chunk-JO3AXHQI.js";
+  GitHubScopeError,
+  checkRequiredScopes,
+  createClient,
+  getGhTokenWithSource,
+  getProjectDetail,
+  listUserProjects,
+  resolveGitHubAuth,
+  validateToken
+} from "./chunk-TILHWBP6.js";
 import {
   loadGlobalConfig,
   saveGlobalConfig,
@@ -13,360 +19,9 @@ 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/github/client.ts
-var DEFAULT_API_URL = "https://api.github.com/graphql";
-var REST_API_URL = "https://api.github.com";
-var GitHubApiError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "GitHubApiError";
-  }
-};
-var GitHubScopeError = class extends GitHubApiError {
-  constructor(message, requiredScopes, currentScopes) {
-    super(message);
-    this.requiredScopes = requiredScopes;
-    this.currentScopes = currentScopes;
-    this.name = "GitHubScopeError";
-  }
-};
-function createClient(token, options) {
-  return {
-    token,
-    apiUrl: options?.apiUrl ?? DEFAULT_API_URL,
-    fetchImpl: options?.fetchImpl ?? fetch
-  };
-}
-async function validateToken(client) {
-  const restUrl = client.apiUrl.replace("/graphql", "");
-  const baseUrl = restUrl === client.apiUrl ? REST_API_URL : restUrl;
-  const response = await client.fetchImpl(`${baseUrl}/user`, {
-    headers: {
-      authorization: `Bearer ${client.token}`,
-      accept: "application/vnd.github+json"
-    }
-  });
-  if (!response.ok) {
-    if (response.status === 401) {
-      throw new GitHubApiError("Invalid token: authentication failed.", 401);
-    }
-    throw new GitHubApiError(
-      `GitHub API error: ${response.status} ${response.statusText}`,
-      response.status
-    );
-  }
-  const scopes = response.headers.get("x-oauth-scopes")?.split(",").map((s) => s.trim()).filter(Boolean) ?? [];
-  const user = await response.json();
-  return {
-    login: user.login,
-    name: user.name,
-    scopes
-  };
-}
-function checkRequiredScopes(scopes) {
-  const required = ["repo", "read:org", "project"];
-  const normalizedScopes = scopes.map((s) => s.toLowerCase());
-  const missing = required.filter((r) => !normalizedScopes.includes(r));
-  return { valid: missing.length === 0, missing };
-}
-async function listUserProjects(client) {
-  const data = await graphql(
-    client,
-    VIEWER_PROJECTS_QUERY
-  );
-  const projects = [];
-  for (const node of data.viewer.projectsV2?.nodes ?? []) {
-    if (!node) continue;
-    projects.push(
-      normalizeProjectSummary(node, {
-        login: data.viewer.login,
-        type: "User"
-      })
-    );
-  }
-  for (const orgNode of data.viewer.organizations?.nodes ?? []) {
-    if (!orgNode) continue;
-    for (const projNode of orgNode.projectsV2?.nodes ?? []) {
-      if (!projNode) continue;
-      projects.push(
-        normalizeProjectSummary(projNode, {
-          login: orgNode.login,
-          type: "Organization"
-        })
-      );
-    }
-  }
-  return projects;
-}
-function normalizeProjectSummary(node, owner) {
-  return {
-    id: node.id,
-    title: node.title,
-    shortDescription: node.shortDescription ?? "",
-    url: node.url,
-    openItemCount: node.items?.totalCount ?? 0,
-    owner
-  };
-}
-async function getProjectDetail(client, projectId) {
-  const data = await graphql(
-    client,
-    PROJECT_DETAIL_QUERY,
-    { projectId }
-  );
-  const project = data.node;
-  if (!project || project.__typename !== "ProjectV2") {
-    throw new GitHubApiError(`Project not found: ${projectId}`);
-  }
-  const statusFields = [];
-  const textFields = [];
-  for (const field of project.fields?.nodes ?? []) {
-    if (!field) continue;
-    if (field.__typename === "ProjectV2SingleSelectField") {
-      statusFields.push({
-        id: field.id,
-        name: field.name,
-        options: (field.options ?? []).map((opt) => ({
-          id: opt.id,
-          name: opt.name,
-          description: opt.description ?? null,
-          color: opt.color ?? null
-        }))
-      });
-    } else if (field.__typename === "ProjectV2Field" && field.dataType) {
-      textFields.push({
-        id: field.id,
-        name: field.name,
-        dataType: field.dataType
-      });
-    }
-  }
-  const repoMap = /* @__PURE__ */ new Map();
-  let cursor = null;
-  let hasMore = true;
-  for (const item of project.items?.nodes ?? []) {
-    const repo = item?.content?.repository;
-    if (!repo) continue;
-    const key = `${repo.owner.login}/${repo.name}`;
-    if (!repoMap.has(key)) {
-      repoMap.set(key, {
-        owner: repo.owner.login,
-        name: repo.name,
-        url: repo.url,
-        cloneUrl: repo.url.endsWith(".git") ? repo.url : `${repo.url}.git`
-      });
-    }
-  }
-  hasMore = project.items?.pageInfo?.hasNextPage ?? false;
-  cursor = project.items?.pageInfo?.endCursor ?? null;
-  while (hasMore && cursor) {
-    const pageData = await graphql(
-      client,
-      PROJECT_ITEMS_PAGE_QUERY,
-      { projectId, cursor }
-    );
-    const items = pageData.node?.items;
-    if (!items) break;
-    for (const item of items.nodes ?? []) {
-      const repo = item?.content?.repository;
-      if (!repo) continue;
-      const key = `${repo.owner.login}/${repo.name}`;
-      if (!repoMap.has(key)) {
-        repoMap.set(key, {
-          owner: repo.owner.login,
-          name: repo.name,
-          url: repo.url,
-          cloneUrl: repo.url.endsWith(".git") ? repo.url : `${repo.url}.git`
-        });
-      }
-    }
-    hasMore = items.pageInfo?.hasNextPage ?? false;
-    cursor = items.pageInfo?.endCursor ?? null;
-  }
-  return {
-    id: project.id,
-    title: project.title,
-    url: project.url,
-    statusFields,
-    textFields,
-    linkedRepositories: [...repoMap.values()]
-  };
-}
-async function graphql(client, query, variables) {
-  const response = await client.fetchImpl(client.apiUrl, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${client.token}`
-    },
-    body: JSON.stringify({ query, variables })
-  });
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    throw new GitHubApiError(
-      `GitHub GraphQL request failed: ${response.status} ${response.statusText}. ${text}`,
-      response.status
-    );
-  }
-  const payload = await response.json();
-  if (payload.errors?.length) {
-    const scopeMessages = payload.errors.map((e) => e.message).filter((m) => m.includes("has not been granted the required scopes"));
-    if (scopeMessages.length > 0) {
-      const requiredScopes = /* @__PURE__ */ new Set();
-      let currentScopes = [];
-      for (const msg of scopeMessages) {
-        for (const match of msg.matchAll(
-          /requires one of the following scopes: \['([^']+)'\]/g
-        )) {
-          requiredScopes.add(match[1]);
-        }
-        if (currentScopes.length === 0) {
-          const currMatch = /has only been granted the: \[([^\]]+)\]/.exec(msg);
-          if (currMatch) {
-            currentScopes = currMatch[1].split(",").map((s) => s.trim().replace(/'/g, "")).filter(Boolean);
-          }
-        }
-      }
-      throw new GitHubScopeError(
-        "Token is missing required GitHub scopes.",
-        [...requiredScopes],
-        currentScopes
-      );
-    }
-    throw new GitHubApiError(
-      `GraphQL errors: ${payload.errors.map((e) => e.message).join("; ")}`
-    );
-  }
-  if (!payload.data) {
-    throw new GitHubApiError("GraphQL response missing data.");
-  }
-  return payload.data;
-}
-var VIEWER_PROJECTS_QUERY = `
-  query ViewerProjects {
-    viewer {
-      login
-      projectsV2(first: 50) {
-        nodes {
-          id
-          title
-          shortDescription
-          url
-          items { totalCount }
-        }
-      }
-      organizations(first: 20) {
-        nodes {
-          login
-          projectsV2(first: 50) {
-            nodes {
-              id
-              title
-              shortDescription
-              url
-              items { totalCount }
-            }
-          }
-        }
-      }
-    }
-  }
-`;
-var PROJECT_DETAIL_QUERY = `
-  query ProjectDetail($projectId: ID!) {
-    node(id: $projectId) {
-      __typename
-      ... on ProjectV2 {
-        id
-        title
-        url
-        fields(first: 50) {
-          nodes {
-            __typename
-            ... on ProjectV2SingleSelectField {
-              id
-              name
-              options {
-                id
-                name
-                description
-                color
-              }
-            }
-            ... on ProjectV2Field {
-              id
-              name
-              dataType
-            }
-          }
-        }
-        items(first: 100) {
-          nodes {
-            content {
-              __typename
-              ... on Issue {
-                repository {
-                  name
-                  url
-                  owner { login }
-                }
-              }
-              ... on PullRequest {
-                repository {
-                  name
-                  url
-                  owner { login }
-                }
-              }
-            }
-          }
-          pageInfo {
-            endCursor
-            hasNextPage
-          }
-        }
-      }
-    }
-  }
-`;
-var PROJECT_ITEMS_PAGE_QUERY = `
-  query ProjectItemsPage($projectId: ID!, $cursor: String) {
-    node(id: $projectId) {
-      ... on ProjectV2 {
-        items(first: 100, after: $cursor) {
-          nodes {
-            content {
-              __typename
-              ... on Issue {
-                repository {
-                  name
-                  url
-                  owner { login }
-                }
-              }
-              ... on PullRequest {
-                repository {
-                  name
-                  url
-                  owner { login }
-                }
-              }
-            }
-          }
-          pageInfo {
-            endCursor
-            hasNextPage
-          }
-        }
-      }
-    }
-  }
-`;
-
 // src/mapping/smart-defaults.ts
 var ROLE_PATTERNS = [
   {
@@ -811,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);
@@ -1201,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")) {
@@ -1222,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
@@ -1797,6 +1416,7 @@ async function abortIfCancelled(input) {
 }
 function parseInitFlags(args) {
   const flags = {
+    dryRun: false,
     nonInteractive: false,
     skipSkills: false,
     skipContext: false
@@ -1805,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;
@@ -1832,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,
@@ -1862,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) {
@@ -1941,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"
@@ -1992,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(
@@ -2016,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,
@@ -2036,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, {
@@ -2045,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");
     }
@@ -2092,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");
     }
@@ -2129,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."
@@ -2137,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:");
@@ -2176,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,
@@ -2236,15 +2060,18 @@ function generateProjectId(githubProjectTitle, uniqueKey) {
 }
 
 export {
-  GitHubScopeError,
-  createClient,
-  validateToken,
-  checkRequiredScopes,
-  listUserProjects,
-  getProjectDetail,
+  validateStateMapping,
   abortIfCancelled,
   init_default,
+  resolveStatusField,
+  buildAutomaticStateMappings,
+  promptStateMappings,
+  planWorkflowArtifacts,
+  writeWorkflowPlan,
+  planEcosystem,
   writeEcosystem,
+  renderDryRunPreview,
+  buildDryRunJsonResult,
   writeConfig,
   generateProjectId
 };