@gh-symphony/cli 0.0.14 → 0.0.15

package/dist/chunk-IWR4UQEJ.js

@@ -0,0 +1,2250 @@
+#!/usr/bin/env node
+import {
+  GhAuthError,
+  ensureGhAuth,
+  getGhToken
+} from "./chunk-JO3AXHQI.js";
+import {
+  loadGlobalConfig,
+  saveGlobalConfig,
+  saveProjectConfig
+} from "./chunk-ROGRTUFI.js";
+
+// 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 { 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 = [
+  {
+    role: "active",
+    pattern: /^(todo|to.do|to-do|ready|queued|open|new|triage|in.progress|working|active|doing|in.development|developing|wip)$/i
+  },
+  {
+    role: "wait",
+    pattern: /^(review|in.review|pr.review|needs.review|plan.review|awaiting.review|code.review|icebox|someday|later|blocked|on.hold|paused|deferred|draft|backlog)$/i
+  },
+  {
+    role: "terminal",
+    pattern: /^(done|completed?|closed|merged|shipped|resolved|finished|won.?t.do|cancelled)$/i
+  }
+];
+function inferStateRole(columnName) {
+  const normalized = columnName.trim();
+  for (const { role, pattern } of ROLE_PATTERNS) {
+    if (pattern.test(normalized)) {
+      return { columnName: normalized, role, confidence: "high" };
+    }
+  }
+  return { columnName: normalized, role: null, confidence: "low" };
+}
+function inferAllStateRoles(columnNames) {
+  return columnNames.map(inferStateRole);
+}
+function toWorkflowLifecycleConfig(stateFieldName, mappings) {
+  const activeStates = [];
+  const terminalStates = [];
+  const blockerCheckStates = [];
+  for (const [columnName, mapping] of Object.entries(mappings)) {
+    switch (mapping.role) {
+      case "active":
+        activeStates.push(columnName);
+        break;
+      case "terminal":
+        terminalStates.push(columnName);
+        break;
+      case "wait":
+        break;
+    }
+  }
+  if (activeStates.length > 0) {
+    blockerCheckStates.push(activeStates[0]);
+  }
+  return {
+    stateFieldName,
+    activeStates,
+    terminalStates,
+    blockerCheckStates
+  };
+}
+function validateStateMapping(mappings) {
+  const errors = [];
+  const warnings = [];
+  const entries = Object.entries(mappings);
+  const activeEntries = entries.filter(([, m]) => m.role === "active");
+  const terminalEntries = entries.filter(([, m]) => m.role === "terminal");
+  if (activeEntries.length === 0) {
+    errors.push(
+      "Missing required role: 'active' \u2014 at least one state must be active."
+    );
+  }
+  if (terminalEntries.length === 0) {
+    errors.push(
+      "Missing required role: 'terminal' \u2014 at least one state must be terminal."
+    );
+  }
+  if (terminalEntries.length > 1) {
+    warnings.push(
+      `Multiple terminal states: ${terminalEntries.map(([n]) => n).join(", ")}. All will be treated as terminal states.`
+    );
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+// src/workflow/generate-workflow-md.ts
+function generateWorkflowMarkdown(input) {
+  const frontMatter = buildFrontMatter(input);
+  const promptBody = buildPromptBody(input.mappings);
+  return `---
+${frontMatter}---
+${promptBody}
+`;
+}
+function buildFrontMatter(input) {
+  const lines = [];
+  lines.push("tracker:");
+  lines.push("  kind: github-project");
+  lines.push(`  project_id: ${input.projectId}`);
+  lines.push(`  state_field: ${input.stateFieldName}`);
+  if (input.lifecycle.activeStates.length > 0) {
+    lines.push("  active_states:");
+    for (const state of input.lifecycle.activeStates) {
+      lines.push(`    - ${state}`);
+    }
+  }
+  if (input.lifecycle.terminalStates.length > 0) {
+    lines.push("  terminal_states:");
+    for (const state of input.lifecycle.terminalStates) {
+      lines.push(`    - ${state}`);
+    }
+  }
+  if (input.lifecycle.blockerCheckStates.length > 0) {
+    lines.push("  blocker_check_states:");
+    for (const state of input.lifecycle.blockerCheckStates) {
+      lines.push(`    - ${state}`);
+    }
+  }
+  const agentCommand = resolveAgentCommand(input.runtime);
+  lines.push("polling:");
+  lines.push(`  interval_ms: ${input.pollIntervalMs ?? 3e4}`);
+  lines.push("workspace:");
+  lines.push("  root: .runtime/symphony-workspaces");
+  lines.push("hooks:");
+  lines.push("  after_create: hooks/after_create.sh");
+  lines.push("agent:");
+  lines.push("  max_concurrent_agents: 10");
+  lines.push("  max_retry_backoff_ms: 30000");
+  lines.push("  retry_base_delay_ms: 10000");
+  lines.push("codex:");
+  lines.push(`  command: ${agentCommand}`);
+  lines.push("  read_timeout_ms: 5000");
+  lines.push("  turn_timeout_ms: 3600000");
+  return lines.join("\n") + "\n";
+}
+function resolveAgentCommand(runtime) {
+  switch (runtime) {
+    case "codex":
+      return "codex app-server";
+    case "claude-code":
+      return "claude-code";
+    default:
+      return runtime;
+  }
+}
+function buildPromptBody(mappings) {
+  const statusMap = generateStatusMapWithDescriptions(mappings);
+  const template = `${statusMap}
+
+## Agent Instructions
+
+You are an AI coding agent working on issue {{issue.identifier}}: "{{issue.title}}".
+
+**Repository:** {{issue.repository}}
+**Current state:** {{issue.state}}
+
+### Task
+
+{{issue.description}}
+
+### Default Posture
+
+1. This is an unattended orchestration session. Do not ask humans for follow-up actions.
+2. Only abort early if there is a genuine blocker (missing required credentials or secrets).
+3. In your final message, report only what was completed and any blockers. Do not include "next steps".
+
+### Workflow
+
+1. Read the issue description and understand the requirements.
+2. Explore the codebase to understand the relevant code structure.
+3. Implement the changes following the project's coding conventions.
+4. Write or update tests to cover the changes.
+5. Verify that all existing tests pass.
+6. Create a PR with a clear description of the changes.
+
+### Guardrails
+
+- Do not edit the issue body for planning or progress tracking.
+- If the issue is in a terminal state, do nothing and exit.
+- If you find out-of-scope improvements, open a separate issue rather than expanding the current scope.
+
+### Workpad Template
+
+Create a workpad comment on the issue with the following structure to track progress:
+
+\`\`\`md
+## Workpad
+
+### Plan
+
+- [ ] 1. Task item
+
+### Acceptance Criteria
+
+- [ ] Criterion 1
+
+### Validation
+
+- [ ] Test: \`command\`
+
+### Notes
+
+- Progress notes
+\`\`\``;
+  return template;
+}
+function generateStatusMapWithDescriptions(mappings) {
+  const roleDescriptions = {
+    active: "Agent starts work immediately",
+    wait: "PR created, awaiting human review",
+    terminal: "Completed, agent exits"
+  };
+  const lines = ["## Status Map", ""];
+  for (const [columnName, mapping] of Object.entries(mappings)) {
+    const rolePart = `[${mapping.role}]`;
+    const goalPart = mapping.goal ? ` \u2014 ${mapping.goal}` : "";
+    const descPart = roleDescriptions[mapping.role] ? ` *(${roleDescriptions[mapping.role]})*` : "";
+    lines.push(`- **${columnName}** ${rolePart}${goalPart}${descPart}`);
+  }
+  return lines.join("\n");
+}
+
+// src/detection/environment-detector.ts
+import { access, readFile } from "fs/promises";
+import { join } from "path";
+function isFileMissing(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
+  );
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch (error) {
+    if (isFileMissing(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function readJsonFile(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (isFileMissing(error)) {
+      return null;
+    }
+    if (error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function detectPackageManager(cwd) {
+  const lockfiles = [
+    { name: "pnpm-lock.yaml", manager: "pnpm" },
+    { name: "bun.lock", manager: "bun" },
+    { name: "bun.lockb", manager: "bun" },
+    { name: "yarn.lock", manager: "yarn" },
+    { name: "package-lock.json", manager: "npm" }
+  ];
+  for (const { name, manager } of lockfiles) {
+    const exists = await fileExists(join(cwd, name));
+    if (exists) {
+      return { packageManager: manager, lockfile: name };
+    }
+  }
+  return { packageManager: null, lockfile: null };
+}
+async function detectScripts(cwd) {
+  const packageJson = await readJsonFile(join(cwd, "package.json"));
+  if (!packageJson?.scripts) {
+    return { testCommand: null, buildCommand: null, lintCommand: null };
+  }
+  return {
+    testCommand: packageJson.scripts.test ?? null,
+    buildCommand: packageJson.scripts.build ?? null,
+    lintCommand: packageJson.scripts.lint ?? null
+  };
+}
+async function detectCiPlatform(cwd) {
+  const workflowsDir = join(cwd, ".github", "workflows");
+  const exists = await fileExists(workflowsDir);
+  return exists ? "github-actions" : null;
+}
+async function detectMonorepo(cwd) {
+  const hasPnpmWorkspace = await fileExists(join(cwd, "pnpm-workspace.yaml"));
+  if (hasPnpmWorkspace) {
+    return true;
+  }
+  const hasLerna = await fileExists(join(cwd, "lerna.json"));
+  if (hasLerna) {
+    return true;
+  }
+  const packageJson = await readJsonFile(join(cwd, "package.json"));
+  if (packageJson?.workspaces) {
+    return true;
+  }
+  return false;
+}
+async function detectExistingSkills(cwd) {
+  const skills = [];
+  const claudeSkillsDir = join(cwd, ".claude", "skills");
+  try {
+    const { readdirSync } = await import("fs");
+    const entries = readdirSync(claudeSkillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        skills.push(entry.name);
+      }
+    }
+  } catch (error) {
+    if (!isFileMissing(error)) {
+      throw error;
+    }
+  }
+  const codexSkillsDir = join(cwd, ".codex", "skills");
+  try {
+    const { readdirSync } = await import("fs");
+    const entries = readdirSync(codexSkillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        skills.push(entry.name);
+      }
+    }
+  } catch (error) {
+    if (!isFileMissing(error)) {
+      throw error;
+    }
+  }
+  return skills;
+}
+async function detectEnvironment(cwd) {
+  const [
+    { packageManager, lockfile },
+    { testCommand, buildCommand, lintCommand },
+    ciPlatform,
+    monorepo,
+    existingSkills
+  ] = await Promise.all([
+    detectPackageManager(cwd),
+    detectScripts(cwd),
+    detectCiPlatform(cwd),
+    detectMonorepo(cwd),
+    detectExistingSkills(cwd)
+  ]);
+  return {
+    packageManager,
+    lockfile,
+    testCommand,
+    buildCommand,
+    lintCommand,
+    ciPlatform,
+    monorepo,
+    existingSkills
+  };
+}
+
+// src/context/generate-context-yaml.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+function yamlQuote(value) {
+  const specialChars = /[:#{'"\]{}()\\[]|\n/;
+  if (specialChars.test(value)) {
+    return `"${value.replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
+function generateContextYamlString(context) {
+  const lines = [];
+  lines.push("schema_version: 1");
+  lines.push(`collected_at: ${context.collected_at}`);
+  lines.push("");
+  lines.push("project:");
+  lines.push(`  id: ${context.project.id}`);
+  lines.push(`  title: ${yamlQuote(context.project.title)}`);
+  lines.push(`  url: ${context.project.url}`);
+  lines.push("");
+  lines.push("status_field:");
+  lines.push(`  id: ${context.status_field.id}`);
+  lines.push(`  name: ${yamlQuote(context.status_field.name)}`);
+  lines.push("  columns:");
+  for (const column of context.status_field.columns) {
+    lines.push(`    - id: ${column.id}`);
+    lines.push(`      name: ${yamlQuote(column.name)}`);
+    lines.push(
+      `      color: ${column.color === null ? "null" : yamlQuote(column.color)}`
+    );
+    lines.push(
+      `      inferred_role: ${column.inferred_role === null ? "null" : column.inferred_role}`
+    );
+    lines.push(`      confidence: ${column.confidence}`);
+  }
+  lines.push("");
+  lines.push("text_fields:");
+  if (context.text_fields.length === 0) {
+    lines.push("  []");
+  } else {
+    for (const field of context.text_fields) {
+      lines.push(`  - id: ${field.id}`);
+      lines.push(`    name: ${yamlQuote(field.name)}`);
+      lines.push(`    data_type: ${field.data_type}`);
+    }
+  }
+  lines.push("");
+  lines.push("repositories:");
+  if (context.repositories.length === 0) {
+    lines.push("  []");
+  } else {
+    for (const repo of context.repositories) {
+      lines.push(`  - owner: ${repo.owner}`);
+      lines.push(`    name: ${repo.name}`);
+      lines.push(`    clone_url: ${repo.clone_url}`);
+    }
+  }
+  lines.push("");
+  lines.push("detected_environment:");
+  lines.push(
+    `  packageManager: ${context.detected_environment.packageManager === null ? "null" : yamlQuote(context.detected_environment.packageManager)}`
+  );
+  lines.push(
+    `  lockfile: ${context.detected_environment.lockfile === null ? "null" : yamlQuote(context.detected_environment.lockfile)}`
+  );
+  lines.push(
+    `  testCommand: ${context.detected_environment.testCommand === null ? "null" : yamlQuote(context.detected_environment.testCommand)}`
+  );
+  lines.push(
+    `  buildCommand: ${context.detected_environment.buildCommand === null ? "null" : yamlQuote(context.detected_environment.buildCommand)}`
+  );
+  lines.push(
+    `  lintCommand: ${context.detected_environment.lintCommand === null ? "null" : yamlQuote(context.detected_environment.lintCommand)}`
+  );
+  lines.push(
+    `  ciPlatform: ${context.detected_environment.ciPlatform === null ? "null" : yamlQuote(context.detected_environment.ciPlatform)}`
+  );
+  lines.push(`  monorepo: ${context.detected_environment.monorepo}`);
+  lines.push("  existingSkills:");
+  if (context.detected_environment.existingSkills.length === 0) {
+    lines.push("    []");
+  } else {
+    for (const skill of context.detected_environment.existingSkills) {
+      lines.push(`    - ${yamlQuote(skill)}`);
+    }
+  }
+  lines.push("");
+  lines.push("runtime:");
+  lines.push(`  agent: ${yamlQuote(context.runtime.agent)}`);
+  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);
+    return {
+      id: option.id,
+      name: option.name,
+      color: option.color,
+      inferred_role: roleMapping.role,
+      confidence: roleMapping.confidence
+    };
+  });
+  const textFields = params.projectDetail.textFields.map((field) => ({
+    id: field.id,
+    name: field.name,
+    data_type: field.dataType
+  }));
+  const repositories = params.projectDetail.linkedRepositories.map((repo) => ({
+    owner: repo.owner,
+    name: repo.name,
+    clone_url: repo.cloneUrl
+  }));
+  return {
+    schema_version: 1,
+    collected_at: (/* @__PURE__ */ new Date()).toISOString(),
+    project: {
+      id: params.projectDetail.id,
+      title: params.projectDetail.title,
+      url: params.projectDetail.url
+    },
+    status_field: {
+      id: params.statusField.id,
+      name: params.statusField.name,
+      columns
+    },
+    text_fields: textFields,
+    repositories,
+    detected_environment: params.detectedEnvironment,
+    runtime: params.runtime
+  };
+}
+
+// src/workflow/generate-reference-workflow.ts
+function generateReferenceWorkflow(input) {
+  const lines = [];
+  lines.push("# Reference WORKFLOW.md \u2014 gh-symphony");
+  lines.push("# This file is a reference template for authoring WORKFLOW.md.");
+  lines.push(
+    "# AI agents reference this file (via the /gh-symphony skill) when designing WORKFLOW.md."
+  );
+  lines.push("# Do not edit this file directly.");
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("# \u2550\u2550\u2550 FRONT MATTER FIELD REFERENCE \u2550\u2550\u2550");
+  lines.push(
+    "# All front matter fields supported by the gh-symphony parser are listed below."
+  );
+  lines.push("");
+  lines.push("tracker:");
+  lines.push("  kind: github-project");
+  lines.push(`  project_id: ${input.projectId}`);
+  lines.push("  state_field: Status");
+  lines.push("");
+  const activeColumns = input.statusColumns.filter((c) => c.role === "active");
+  const waitColumns = input.statusColumns.filter((c) => c.role === "wait");
+  const terminalColumns = input.statusColumns.filter(
+    (c) => c.role === "terminal"
+  );
+  const firstActive = activeColumns[0];
+  if (activeColumns.length > 0) {
+    lines.push("  active_states:");
+    for (const col of activeColumns) {
+      lines.push(`    - ${col.name}`);
+    }
+  } else {
+    lines.push("  active_states: [{active column names}]");
+  }
+  if (terminalColumns.length > 0) {
+    lines.push("  terminal_states:");
+    for (const col of terminalColumns) {
+      lines.push(`    - ${col.name}`);
+    }
+  } else {
+    lines.push("  terminal_states: [{terminal column names}]");
+  }
+  if (firstActive) {
+    lines.push("  blocker_check_states:");
+    lines.push(`    - ${firstActive.name}`);
+  } else {
+    lines.push("  blocker_check_states: [{first active state}]");
+  }
+  lines.push("");
+  const agentCommand = resolveAgentCommand2(input.runtime);
+  const hookComment = resolveHookComment(input.runtime);
+  lines.push("polling:");
+  lines.push("  interval_ms: 30000");
+  lines.push("");
+  lines.push("workspace:");
+  lines.push("  root: .runtime/symphony-workspaces");
+  lines.push("");
+  lines.push("hooks:");
+  lines.push(`  after_create: hooks/after_create.sh  # ${hookComment}`);
+  lines.push("  before_run: null");
+  lines.push("  after_run: null");
+  lines.push("  before_remove: null");
+  lines.push("  timeout_ms: 60000");
+  lines.push("");
+  lines.push("agent:");
+  lines.push("  max_concurrent_agents: 10");
+  lines.push("  max_retry_backoff_ms: 30000");
+  lines.push("  retry_base_delay_ms: 10000");
+  lines.push("  max_turns: 20");
+  lines.push("");
+  lines.push("codex:");
+  lines.push(`  command: ${agentCommand}`);
+  lines.push("  read_timeout_ms: 5000");
+  lines.push("  turn_timeout_ms: 3600000");
+  lines.push("  stall_timeout_ms: 300000");
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("# \u2550\u2550\u2550 PROMPT BODY REFERENCE \u2550\u2550\u2550");
+  lines.push(
+    "# GitHub Project adaptation of the Elixir Symphony reference prompt."
+  );
+  lines.push("");
+  lines.push("## Status Map");
+  lines.push("");
+  lines.push("| Status | Role | Agent Action |");
+  lines.push("| ------ | ---- | ------------ |");
+  for (const col of input.statusColumns) {
+    const roleLabel = col.role ?? "unset";
+    const action = resolveRoleAction(col.role);
+    lines.push(`| ${col.name} | ${roleLabel} | ${action} |`);
+  }
+  if (waitColumns.length > 0) {
+    lines.push("");
+    lines.push("**Wait States (awaiting PR review):**");
+    for (const col of waitColumns) {
+      lines.push(
+        `- **${col.name}**: PR created. Awaiting human review. Agent is idle.`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("## Default Posture");
+  lines.push("");
+  lines.push(
+    "1. This is an unattended orchestration session. Do not ask humans for follow-up tasks."
+  );
+  lines.push(
+    "2. Exit early only for genuine blockers (missing required credentials or secrets)."
+  );
+  lines.push(
+    '3. In your final message, report only completed work and blockers. Do not include "next steps".'
+  );
+  lines.push(
+    "4. Do not modify the issue body for planning or progress-tracking purposes."
+  );
+  lines.push(
+    "5. If the issue is in a terminal state, do nothing and exit immediately."
+  );
+  lines.push(
+    "6. If you discover out-of-scope improvements, open a separate issue rather than expanding the current scope."
+  );
+  lines.push(
+    "7. Keep all commits as logical units and follow conventional commit format."
+  );
+  lines.push("8. Do not make commits that break existing tests.");
+  lines.push("9. Verify all existing tests pass before creating a PR.");
+  lines.push("10. Create a workpad as an issue comment to track progress.");
+  lines.push("11. Use the gh-project skill to manage issue status.");
+  lines.push(
+    "12. When a blocker is found, record it in an issue comment and transition the status appropriately."
+  );
+  lines.push(
+    "13. Once your work is complete and the PR is merged, transition the issue to the Done state."
+  );
+  lines.push("");
+  lines.push("## Related Skills");
+  lines.push("");
+  lines.push(
+    "- **gh-project**: Manage GitHub Project v2 issue status and update fields"
+  );
+  lines.push(
+    "- **commit**: Create logical-unit commits (conventional commit format)"
+  );
+  lines.push("- **push**: Push branch and sync with the remote repository");
+  lines.push("- **pull**: Fetch latest changes and resolve conflicts");
+  lines.push("- **land**: Create PR, request review, and handle merge");
+  lines.push("");
+  lines.push("## Step 0: Determine current state and route");
+  lines.push("");
+  lines.push(
+    "Check the current issue state and route to the appropriate step:"
+  );
+  lines.push("");
+  if (terminalColumns.length > 0) {
+    const terminalNames = terminalColumns.map((c) => c.name).join(", ");
+    lines.push(`- **${terminalNames}** \u2192 Exit immediately. Do nothing.`);
+  }
+  if (waitColumns.length > 0) {
+    const waitNames = waitColumns.map((c) => c.name).join(", ");
+    lines.push(`- **${waitNames}** \u2192 Go to Step 3 (handle awaiting review).`);
+  }
+  if (activeColumns.length > 0) {
+    const activeNames = activeColumns.map((c) => c.name).join(", ");
+    lines.push(
+      `- **${activeNames}** \u2192 Go to Step 1 (start or continue execution).`
+    );
+  }
+  lines.push(
+    "- **Other states** \u2192 Log the unclear state in an issue comment and exit."
+  );
+  lines.push("");
+  lines.push("## Step 1: Start/continue execution");
+  lines.push("");
+  lines.push(
+    "1. Read the issue body and comments to understand current progress."
+  );
+  lines.push(
+    "2. If an existing workpad comment is found, continue from it; otherwise create a new workpad."
+  );
+  lines.push(
+    "3. See the 'Workpad Template' section below for the workpad format."
+  );
+  lines.push(
+    "4. If no branch exists, create a feature branch based on `{issue.repository}`."
+  );
+  lines.push("5. Proceed to Step 2.");
+  lines.push("");
+  lines.push("## Step 2: Execution phase");
+  lines.push("");
+  lines.push("1. Implement according to the issue description.");
+  lines.push(
+    "2. Commit changes in logical units (conventional commit format)."
+  );
+  lines.push("3. Verify all existing tests pass.");
+  lines.push("4. Write tests for new functionality.");
+  lines.push("5. Once all Completion Bar criteria are met, create a PR.");
+  lines.push(
+    "6. After creating the PR, transition the issue status to the Human Review state."
+  );
+  lines.push("7. Proceed to Step 3.");
+  lines.push("");
+  lines.push("## Step 3: Human Review and merge handling");
+  lines.push("");
+  lines.push("1. If a PR already exists, check for review comments.");
+  lines.push(
+    "2. If no review comments are present, remain in the waiting state."
+  );
+  lines.push(
+    "3. If the PR is merged, transition the issue to a terminal state."
+  );
+  lines.push("4. If review changes are requested, proceed to Step 4.");
+  lines.push("");
+  lines.push("## Step 4: Rework handling");
+  lines.push("");
+  lines.push(
+    "1. Read all PR review comments and identify the requested changes."
+  );
+  lines.push(
+    "2. Process the changes following the PR Feedback Sweep Protocol."
+  );
+  lines.push("3. After implementing changes, commit and update the PR.");
+  lines.push("4. Transition the issue status back to the Human Review state.");
+  lines.push("5. Return to Step 3.");
+  lines.push("");
+  lines.push("## PR Feedback Sweep Protocol");
+  lines.push("");
+  lines.push("Order for processing PR review feedback:");
+  lines.push("");
+  lines.push(
+    "1. **Collect all comments**: List all unresolved review comments."
+  );
+  lines.push(
+    "2. **Triage by priority**: Handle blocking comments before non-blocking ones."
+  );
+  lines.push(
+    "3. **Implement changes**: Make the code changes corresponding to each comment."
+  );
+  lines.push(
+    "4. **Reply to comments**: Respond to each review comment with a description of what was done."
+  );
+  lines.push(
+    "5. **Commit**: Commit changes in `fix: address PR review feedback` format."
+  );
+  lines.push("6. **Request re-review**: Ask the reviewer for a re-review.");
+  lines.push("");
+  lines.push("## Completion Bar");
+  lines.push("");
+  lines.push("All of the following must be satisfied before creating a PR:");
+  lines.push("");
+  lines.push(
+    "- [ ] All requirements from the issue description are implemented."
+  );
+  lines.push("- [ ] All existing tests pass.");
+  lines.push("- [ ] Tests are written for new functionality.");
+  lines.push("- [ ] Code style follows project conventions.");
+  lines.push("- [ ] The PR description clearly explains the changes.");
+  lines.push("- [ ] Related documentation is updated (if applicable).");
+  lines.push("");
+  lines.push("## Guardrails");
+  lines.push("");
+  lines.push("- **Scope**: Never make changes outside the scope of the issue.");
+  lines.push(
+    "- **Secrets**: Never hardcode tokens, passwords, or API keys in code."
+  );
+  lines.push(
+    "- **Breaking changes**: Do not modify existing APIs or interfaces without explicit authorization."
+  );
+  lines.push("- **Force push**: Do not force-push to the main/master branch.");
+  lines.push(
+    "- **Issue body**: Do not modify the issue body for progress tracking."
+  );
+  lines.push(
+    "- **Infinite loops**: If the same task fails 3 or more consecutive times, log it as a blocker and exit."
+  );
+  lines.push("");
+  lines.push("## Workpad Template");
+  lines.push("");
+  lines.push("Workpad format to create as an issue comment:");
+  lines.push("");
+  lines.push("```markdown");
+  lines.push("## Workpad \u2014 {issue.identifier}");
+  lines.push("");
+  lines.push("**Status**: {current phase}");
+  lines.push("**Branch**: {branch name}");
+  lines.push("**PR**: {PR URL or not created}");
+  lines.push("");
+  lines.push("### Plan");
+  lines.push("");
+  lines.push("- [ ] {task 1}");
+  lines.push("- [ ] {task 2}");
+  lines.push("");
+  lines.push("### Progress Log");
+  lines.push("");
+  lines.push("- {timestamp}: {action taken}");
+  lines.push("");
+  lines.push("### Blockers");
+  lines.push("");
+  lines.push("None");
+  lines.push("```");
+  lines.push("");
+  return lines.join("\n");
+}
+function resolveAgentCommand2(runtime) {
+  switch (runtime) {
+    case "codex":
+      return "codex app-server";
+    case "claude-code":
+      return "claude-code";
+    default:
+      return runtime;
+  }
+}
+function resolveHookComment(runtime) {
+  switch (runtime) {
+    case "codex":
+      return "npm/yarn/pnpm install script";
+    case "claude-code":
+      return "npm/yarn/pnpm install script";
+    default:
+      return "package-manager-specific script";
+  }
+}
+function resolveRoleAction(role) {
+  switch (role) {
+    case "active":
+      return "Agent starts work immediately. Creates workpad and proceeds with implementation.";
+    case "wait":
+      return "PR created. Awaiting human review. Agent is idle.";
+    case "terminal":
+      return "Completed state. Agent exits.";
+    case null:
+      return "Role unset. Must be explicitly configured in WORKFLOW.md.";
+  }
+}
+
+// src/skills/skill-writer.ts
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+function normalizeRuntimeForSkills(runtime) {
+  if (runtime === "claude-code" || runtime.includes("claude-code")) {
+    return "claude-code";
+  }
+  if (runtime === "codex" || runtime.includes("codex")) {
+    return "codex";
+  }
+  return null;
+}
+function resolveSkillsDir(repoRoot, runtime) {
+  const normalizedRuntime = normalizeRuntimeForSkills(runtime);
+  if (normalizedRuntime === "claude-code") {
+    return join2(repoRoot, ".claude", "skills");
+  }
+  if (normalizedRuntime === "codex") {
+    return join2(repoRoot, ".codex", "skills");
+  }
+  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) {
+  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 { written, skipped };
+}
+
+// src/skills/templates/document.ts
+function renderSkillDocument(options) {
+  const { name, description, bodyLines } = options;
+  return [
+    "---",
+    `name: ${name}`,
+    `description: ${description}`,
+    "license: MIT",
+    "metadata:",
+    "  author: gh-symphony",
+    '  version: "1.0"',
+    '  generatedBy: "gh-symphony"',
+    "---",
+    "",
+    ...bodyLines
+  ].join("\n");
+}
+
+// src/skills/templates/gh-symphony.ts
+function generateGhSymphonySkill(ctx) {
+  const lines = [];
+  lines.push("# /gh-symphony \u2014 WORKFLOW.md Design & Refinement");
+  lines.push("");
+  lines.push("## Trigger");
+  lines.push("");
+  lines.push("Use this skill when you want to:");
+  lines.push("- Create a new WORKFLOW.md for a GitHub Symphony project");
+  lines.push("- Refine or improve an existing WORKFLOW.md");
+  lines.push("- Validate that a WORKFLOW.md is correctly structured");
+  lines.push("");
+  lines.push("## Prerequisites");
+  lines.push("");
+  lines.push(
+    `- \`${ctx.contextYamlPath}\` must exist (contains GitHub Project metadata)`
+  );
+  lines.push(
+    `- \`${ctx.referenceWorkflowPath}\` must exist (annotated reference template)`
+  );
+  lines.push("- `gh` CLI must be authenticated");
+  lines.push("");
+  lines.push("## Mode Detection");
+  lines.push("");
+  lines.push("Check if `WORKFLOW.md` exists in the current directory:");
+  lines.push("- **Not found** \u2192 enter **Design Mode** (create from scratch)");
+  lines.push("- **Found** \u2192 ask user: refine existing or validate only?");
+  lines.push("  - Refine \u2192 enter **Refine Mode**");
+  lines.push("  - Validate \u2192 enter **Validate Mode**");
+  lines.push("");
+  lines.push("## Design Mode");
+  lines.push("");
+  lines.push(
+    `1. Read \`${ctx.contextYamlPath}\` to understand the project structure`
+  );
+  lines.push(
+    `2. Read \`${ctx.referenceWorkflowPath}\` as the annotated reference`
+  );
+  lines.push("3. Ask the user these key questions:");
+  lines.push("   - Which status columns should be **active** (agent works)?");
+  lines.push("   - Which should be **wait** (agent pauses for human)?");
+  lines.push("   - Which should be **terminal** (agent stops)?");
+  lines.push("   - What runtime is being used? (codex / claude-code / custom)");
+  lines.push("   - Any custom hooks needed? (after_create, before_run, etc.)");
+  lines.push(
+    "4. Generate WORKFLOW.md using the reference as a structural guide"
+  );
+  lines.push("5. Validate the generated file (see Validate Mode)");
+  lines.push("");
+  lines.push("## Refine Mode");
+  lines.push("");
+  lines.push("1. Read the current `WORKFLOW.md`");
+  lines.push(`2. Read \`${ctx.referenceWorkflowPath}\` for comparison`);
+  lines.push("3. Identify missing or incomplete sections:");
+  lines.push("   - Status Map with role annotations");
+  lines.push("   - Default Posture / Agent Instructions");
+  lines.push("   - Guardrails section");
+  lines.push("   - Workpad Template");
+  lines.push("   - Step 0 routing logic");
+  lines.push("4. Propose improvements and apply with user confirmation");
+  lines.push("5. Validate the refined file");
+  lines.push("");
+  lines.push("## Validate Mode");
+  lines.push("");
+  lines.push("Check the WORKFLOW.md for:");
+  lines.push("- Front matter is valid YAML");
+  lines.push(
+    "- Required fields are present (see Supported Front Matter Fields)"
+  );
+  lines.push(
+    "- Template variables use only supported names (see Supported Template Variables)"
+  );
+  lines.push("- Status Map matches the lifecycle configuration");
+  lines.push(
+    "- No unsupported double-brace variable patterns (only the 8 listed below are valid)"
+  );
+  lines.push("");
+  lines.push("## Supported Front Matter Fields");
+  lines.push("");
+  lines.push("```yaml");
+  lines.push("tracker:");
+  lines.push("  kind: github-project");
+  lines.push("  project_id: PVT_xxx");
+  lines.push("  state_field: Status");
+  lines.push("  active_states: [Todo, In Progress]");
+  lines.push("  terminal_states: [Done, Cancelled]");
+  lines.push("  blocker_check_states: [Blocked]");
+  lines.push("polling:");
+  lines.push("  interval_ms: 30000");
+  lines.push("workspace:");
+  lines.push("  root: .runtime/symphony-workspaces");
+  lines.push("hooks:");
+  lines.push("  after_create: |");
+  lines.push("    git clone --depth 1 https://github.com/owner/repo .");
+  lines.push("  before_run: null");
+  lines.push("  after_run: null");
+  lines.push("  before_remove: null");
+  lines.push("  timeout_ms: 60000");
+  lines.push("agent:");
+  lines.push("  max_concurrent_agents: 10");
+  lines.push("  max_retry_backoff_ms: 30000");
+  lines.push("  retry_base_delay_ms: 10000");
+  lines.push("  max_turns: 20");
+  lines.push("codex:");
+  lines.push("  command: codex app-server");
+  lines.push("  read_timeout_ms: 5000");
+  lines.push("  turn_timeout_ms: 3600000");
+  lines.push("  stall_timeout_ms: 300000");
+  lines.push("```");
+  lines.push("");
+  lines.push("## Supported Template Variables");
+  lines.push("");
+  lines.push("Use these in the WORKFLOW.md prompt body (double-brace syntax):");
+  lines.push("");
+  lines.push("| Variable | Description |");
+  lines.push("|----------|-------------|");
+  lines.push("| `issue.identifier` | e.g. `acme/platform#42` |");
+  lines.push("| `issue.title` | Issue title |");
+  lines.push("| `issue.state` | Current tracker state |");
+  lines.push("| `issue.description` | Issue body |");
+  lines.push("| `issue.url` | Issue URL |");
+  lines.push("| `issue.repository` | `owner/name` |");
+  lines.push("| `issue.number` | Issue number |");
+  lines.push("| `attempt` | Retry attempt number (null on first run) |");
+  lines.push("");
+  lines.push(
+    "**Important**: Only these 8 variables are supported. Using any other variable"
+  );
+  lines.push("will cause a runtime error (strict mode validation).");
+  lines.push("");
+  lines.push("## Related Skills");
+  lines.push("");
+  lines.push(
+    "- `/gh-project` \u2014 interact with GitHub Project v2 board (status transitions, workpad comments)"
+  );
+  lines.push(
+    "- `/commit` \u2014 produce clean, logical commits during implementation"
+  );
+  lines.push("- `/push` \u2014 keep remote branch current and publish updates");
+  lines.push("- `/pull` \u2014 sync branch with latest origin/main before handoff");
+  lines.push("- `/land` \u2014 merge approved PR and transition issue to Done");
+  return renderSkillDocument({
+    name: "gh-symphony",
+    description: "Design, refine, and validate repository WORKFLOW.md files for GitHub Symphony projects.",
+    bodyLines: lines
+  });
+}
+
+// src/skills/templates/gh-project.ts
+function generateGhProjectSkill(ctx) {
+  const lines = [];
+  lines.push("# /gh-project \u2014 GitHub Project v2 Status Management");
+  lines.push("");
+  lines.push("## Purpose");
+  lines.push("");
+  lines.push(
+    "Interact with the GitHub Project v2 board to manage issue status,"
+  );
+  lines.push("create workpad comments, and handle follow-up issues.");
+  lines.push("");
+  lines.push("## Prerequisites");
+  lines.push("");
+  lines.push("- `gh` CLI is authenticated (`gh auth status`)");
+  lines.push(
+    `- \`${ctx.contextYamlPath}\` exists with field IDs and option IDs`
+  );
+  lines.push("");
+  lines.push("## Column ID Quick Reference");
+  lines.push("");
+  lines.push(`Status Field ID: \`${ctx.statusFieldId}\``);
+  lines.push("");
+  lines.push("| Column Name | Role | Option ID |");
+  lines.push("|-------------|------|-----------|");
+  for (const col of ctx.statusColumns) {
+    const role = col.role ?? "unknown";
+    lines.push(`| ${col.name} | ${role} | \`${col.id}\` |`);
+  }
+  lines.push("");
+  lines.push("## Operations");
+  lines.push("");
+  lines.push("### Change Issue Status");
+  lines.push("");
+  lines.push(
+    "Use `gh project item-edit` with the field ID and option ID from the table above:"
+  );
+  lines.push("");
+  lines.push("```bash");
+  lines.push("# Get the project item ID for an issue");
+  lines.push(
+    "gh project item-list <project-number> --owner <owner> --format json \\"
+  );
+  lines.push(
+    "  | jq '.items[] | select(.content.number == <issue-number>) | .id'"
+  );
+  lines.push("");
+  lines.push("# Update the status field");
+  lines.push(`gh project item-edit \\`);
+  lines.push(`  --project-id ${ctx.projectId} \\`);
+  lines.push(`  --id <item-id> \\`);
+  lines.push(`  --field-id ${ctx.statusFieldId} \\`);
+  lines.push(`  --single-select-option-id <option-id-from-table-above>`);
+  lines.push("```");
+  lines.push("");
+  lines.push("### Create Workpad Comment");
+  lines.push("");
+  lines.push("```bash");
+  lines.push(
+    'gh issue comment <issue-number> --repo <owner>/<repo> --body "## Workpad\\n\\n### Plan\\n- [ ] Task 1"'
+  );
+  lines.push("```");
+  lines.push("");
+  lines.push("### Update Existing Comment");
+  lines.push("");
+  lines.push("```bash");
+  lines.push(
+    "gh api -X PATCH /repos/<owner>/<repo>/issues/comments/<comment-id> \\"
+  );
+  lines.push('  -f body="## Workpad\\n\\n### Plan\\n- [x] Task 1 (done)"');
+  lines.push("```");
+  lines.push("");
+  lines.push("### Create Follow-up Issue");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("gh issue create --repo <owner>/<repo> \\");
+  lines.push('  --title "Follow-up: <title>" \\');
+  lines.push('  --body "<description>" \\');
+  lines.push('  --label "backlog"');
+  lines.push("```");
+  lines.push("");
+  lines.push("### Add Label");
+  lines.push("");
+  lines.push("```bash");
+  lines.push(
+    'gh issue edit <issue-number> --repo <owner>/<repo> --add-label "<label>"'
+  );
+  lines.push("```");
+  lines.push("");
+  lines.push("## Rules");
+  lines.push("");
+  lines.push(
+    "- Always follow the WORKFLOW.md status map flow for state transitions"
+  );
+  lines.push(
+    "- Before transitioning to a terminal state, verify the Completion Bar is satisfied:"
+  );
+  lines.push("  - All acceptance criteria checked");
+  lines.push("  - All tests passing");
+  lines.push("  - PR merged (if applicable)");
+  lines.push(
+    "- Use the Column ID Quick Reference table above for all status transitions"
+  );
+  lines.push(
+    "- Do not transition issues to terminal states without explicit completion verification"
+  );
+  return renderSkillDocument({
+    name: "gh-project",
+    description: "Manage GitHub Project v2 issue states, workpad comments, and related follow-up actions.",
+    bodyLines: lines
+  });
+}
+
+// src/skills/templates/commit.ts
+function generateCommitSkill(_ctx) {
+  const lines = [];
+  lines.push("# /commit \u2014 Clean Commit Workflow");
+  lines.push("");
+  lines.push("## Trigger");
+  lines.push("");
+  lines.push("Use this skill when creating commits during implementation.");
+  lines.push("");
+  lines.push("## Rules");
+  lines.push("");
+  lines.push("- Commit in logical units \u2014 one concern per commit");
+  lines.push("- Never commit a broken intermediate state (tests must pass)");
+  lines.push("- Never commit temporary debug code or commented-out blocks");
+  lines.push("- Run tests before every commit");
+  lines.push("");
+  lines.push("## Format");
+  lines.push("");
+  lines.push("Use Conventional Commit format:");
+  lines.push("");
+  lines.push("```");
+  lines.push("<type>(<scope>): <description>");
+  lines.push("");
+  lines.push("[optional body \u2014 explain WHY, not WHAT, 72 chars/line]");
+  lines.push("");
+  lines.push("[optional footer: Closes #N]");
+  lines.push("```");
+  lines.push("");
+  lines.push("**Types**: `feat`, `fix`, `refactor`, `test`, `docs`, `chore`");
+  lines.push("");
+  lines.push(
+    "**Description**: imperative mood, 50 chars max, no period at end"
+  );
+  lines.push("");
+  lines.push("## Examples");
+  lines.push("");
+  lines.push("```");
+  lines.push("feat(auth): add OAuth2 token refresh");
+  lines.push("fix(api): handle null response from upstream");
+  lines.push("test(worker): add retry exhaustion coverage");
+  lines.push("```");
+  return renderSkillDocument({
+    name: "commit",
+    description: "Create clean, logically scoped commits that keep the repository in a shippable state.",
+    bodyLines: lines
+  });
+}
+
+// src/skills/templates/push.ts
+function generatePushSkill(_ctx) {
+  const lines = [];
+  lines.push("# /push \u2014 Git Push Workflow");
+  lines.push("");
+  lines.push("## Trigger");
+  lines.push("");
+  lines.push(
+    "Use this skill when publishing local commits to the remote branch."
+  );
+  lines.push("");
+  lines.push("## Flow");
+  lines.push("");
+  lines.push("1. Run local tests and lint \u2014 ensure they pass before pushing");
+  lines.push("2. Push to remote:");
+  lines.push("   ```bash");
+  lines.push("   git push origin <branch>        # subsequent pushes");
+  lines.push("   git push -u origin <branch>     # first push (sets upstream)");
+  lines.push("   ```");
+  lines.push("3. If push is rejected (non-fast-forward):");
+  lines.push("   - Run `git fetch origin && git merge origin/main`");
+  lines.push("   - Resolve any conflicts");
+  lines.push("   - Re-run tests");
+  lines.push("   - Push again");
+  lines.push("4. Record push result in workpad Notes");
+  lines.push("");
+  lines.push("## Rules");
+  lines.push("");
+  lines.push("- Never use `--force` (destructive)");
+  lines.push(
+    "- Only use `--force-with-lease` if absolutely necessary \u2014 record the reason in workpad"
+  );
+  lines.push("- Verify CI starts after push (check GitHub Actions tab)");
+  lines.push("- Do not push directly to `main` or `master`");
+  return renderSkillDocument({
+    name: "push",
+    description: "Publish verified local commits to the remote branch without unsafe force pushes.",
+    bodyLines: lines
+  });
+}
+
+// src/skills/templates/pull.ts
+function generatePullSkill(_ctx) {
+  const lines = [];
+  lines.push("# /pull \u2014 Git Pull / Sync Workflow");
+  lines.push("");
+  lines.push("## Trigger");
+  lines.push("");
+  lines.push(
+    "Use this skill to sync the current branch with the latest `origin/main`"
+  );
+  lines.push("before starting work or before creating a PR.");
+  lines.push("");
+  lines.push("## Flow");
+  lines.push("");
+  lines.push("1. Fetch latest from remote:");
+  lines.push("   ```bash");
+  lines.push("   git fetch origin");
+  lines.push("   ```");
+  lines.push("2. Merge into current branch:");
+  lines.push("   ```bash");
+  lines.push("   git merge origin/main");
+  lines.push("   ```");
+  lines.push("3. If conflicts arise:");
+  lines.push("   - Resolve each conflict file");
+  lines.push("   - Run tests to confirm nothing broke");
+  lines.push(
+    "   - Commit the merge: `git commit` (merge commit message is auto-generated)"
+  );
+  lines.push(
+    "4. Re-run tests after merge to confirm the integrated state is clean"
+  );
+  lines.push("5. Record pull skill evidence in workpad Notes:");
+  lines.push("   - merge source (e.g. `origin/main`)");
+  lines.push("   - result: `clean` or `conflicts resolved`");
+  lines.push("   - resulting HEAD short SHA: `git rev-parse --short HEAD`");
+  lines.push("");
+  lines.push("## Rules");
+  lines.push("");
+  lines.push("- Always pull before creating a PR");
+  lines.push("- Always pull at the start of a new work session");
+  lines.push("- Record the pull evidence in the workpad before proceeding");
+  return renderSkillDocument({
+    name: "pull",
+    description: "Sync the current branch with the latest remote base before implementation or review handoff.",
+    bodyLines: lines
+  });
+}
+
+// src/skills/templates/land.ts
+function generateLandSkill(_ctx) {
+  const lines = [];
+  lines.push("# /land \u2014 PR Merge Workflow");
+  lines.push("");
+  lines.push("## Trigger");
+  lines.push("");
+  lines.push(
+    "Use this skill when the issue is in the Merging state (PR approved by human)."
+  );
+  lines.push(
+    "Do NOT call `gh pr merge` directly \u2014 always go through this flow."
+  );
+  lines.push("");
+  lines.push("## Pre-flight Checks");
+  lines.push("");
+  lines.push("Before merging, verify ALL of the following:");
+  lines.push("");
+  lines.push("1. **PR is approved**:");
+  lines.push("   ```bash");
+  lines.push(
+    `   gh pr view --json reviews --jq '.reviews[] | select(.state == "APPROVED")'`
+  );
+  lines.push("   ```");
+  lines.push("2. **All CI checks are green**:");
+  lines.push("   ```bash");
+  lines.push("   gh pr checks");
+  lines.push("   ```");
+  lines.push("3. **Branch is up-to-date with base**:");
+  lines.push("   ```bash");
+  lines.push(
+    "   git fetch origin && git merge-base --is-ancestor origin/main HEAD"
+  );
+  lines.push("   ```");
+  lines.push("   If not up-to-date, run the `/pull` skill first.");
+  lines.push("");
+  lines.push("## Flow");
+  lines.push("");
+  lines.push("1. Run all pre-flight checks above");
+  lines.push("2. If all checks pass, merge the PR:");
+  lines.push("   ```bash");
+  lines.push("   gh pr merge --squash    # squash merge (default)");
+  lines.push("   # or: gh pr merge --merge   # merge commit");
+  lines.push("   # or: gh pr merge --rebase  # rebase merge");
+  lines.push("   ```");
+  lines.push("   Choose the merge strategy per project policy.");
+  lines.push("3. On merge success:");
+  lines.push(
+    "   - Use the **gh-project skill** to transition the issue status to Done"
+  );
+  lines.push("   - Do NOT call status APIs directly \u2014 delegate to gh-project");
+  lines.push("4. On merge failure:");
+  lines.push("   - Record the failure reason in workpad Notes");
+  lines.push("   - Resolve the blocking issue (re-run pre-flight checks)");
+  lines.push("   - Retry the merge");
+  lines.push("5. Loop until merged or blocked by an unresolvable issue");
+  lines.push("");
+  lines.push("## Rules");
+  lines.push("");
+  lines.push("- Never call `gh pr merge` without completing pre-flight checks");
+  lines.push(
+    "- Status transition to Done MUST go through the gh-project skill"
+  );
+  lines.push(
+    "- If any pre-flight check fails, do not merge \u2014 fix the issue first"
+  );
+  lines.push("- Record all merge attempts and outcomes in the workpad");
+  return renderSkillDocument({
+    name: "land",
+    description: "Merge approved pull requests safely after verifying approvals, CI, and branch freshness.",
+    bodyLines: lines
+  });
+}
+
+// src/skills/templates/index.ts
+var ALL_SKILL_TEMPLATES = [
+  {
+    name: "gh-symphony",
+    fileName: "SKILL.md",
+    generate: generateGhSymphonySkill
+  },
+  {
+    name: "gh-project",
+    fileName: "SKILL.md",
+    generate: generateGhProjectSkill
+  },
+  { name: "commit", fileName: "SKILL.md", generate: generateCommitSkill },
+  { name: "push", fileName: "SKILL.md", generate: generatePushSkill },
+  { name: "pull", fileName: "SKILL.md", generate: generatePullSkill },
+  { name: "land", fileName: "SKILL.md", generate: generateLandSkill }
+];
+
+// src/commands/init.ts
+var KNOWN_REQUIRED_SCOPES = ["repo", "read:org", "project"];
+function displayScopeError(error, retryCommand) {
+  const plural = error.requiredScopes.length === 1 ? "" : "s";
+  p.log.error(
+    `Token is missing required scope${plural}: ${error.requiredScopes.join(", ")}`
+  );
+  const currentSet = new Set(error.currentScopes.map((s) => s.toLowerCase()));
+  const scopesToAdd = KNOWN_REQUIRED_SCOPES.filter((s) => !currentSet.has(s));
+  const scopeArg = scopesToAdd.length > 0 ? scopesToAdd.join(",") : error.requiredScopes.join(",");
+  p.note(
+    `gh auth refresh --scopes ${scopeArg}
+
+Then re-run: ${retryCommand}`,
+    "Fix missing scope"
+  );
+}
+async function abortIfCancelled(input) {
+  const result = await input;
+  if (p.isCancel(result)) {
+    p.cancel("Setup cancelled.");
+    process.exit(130);
+  }
+  return result;
+}
+function parseInitFlags(args) {
+  const flags = {
+    nonInteractive: false,
+    skipSkills: false,
+    skipContext: false
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    const next = args[i + 1];
+    switch (arg) {
+      case "--non-interactive":
+        flags.nonInteractive = true;
+        break;
+      case "--project":
+        flags.project = next;
+        i += 1;
+        break;
+      case "--output":
+        flags.output = next;
+        i += 1;
+        break;
+      case "--skip-skills":
+        flags.skipSkills = true;
+        break;
+      case "--skip-context":
+        flags.skipContext = true;
+        break;
+    }
+  }
+  return flags;
+}
+var handler = async (args, options) => {
+  const flags = parseInitFlags(args);
+  if (flags.nonInteractive) {
+    await runNonInteractive(flags, options);
+    return;
+  }
+  await runInteractive(options);
+};
+var init_default = handler;
+async function writeEcosystem(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;
+  if (!skipContext) {
+    const contextYaml = buildContextYaml({
+      projectDetail,
+      statusField,
+      detectedEnvironment: env,
+      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;
+  }
+  const refWorkflow = generateReferenceWorkflow({
+    runtime,
+    statusColumns: statusField.options.map((o) => ({
+      name: o.name,
+      role: null
+    })),
+    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 = [];
+  if (!skipSkills && skillsDir) {
+    const result = await writeAllSkills(cwd, runtime, 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"
+    });
+    skillsWritten = result.written.map((p2) => basename(dirname2(p2)));
+    skillsSkipped = result.skipped.map((p2) => basename(dirname2(p2)));
+  }
+  return {
+    projectId: projectDetail.id,
+    githubProjectTitle: projectDetail.title,
+    runtime,
+    skillsDir,
+    contextYamlWritten,
+    referenceWorkflowWritten: true,
+    skillsWritten,
+    skillsSkipped
+  };
+}
+function printEcosystemSummary(result, workflowPath, opts) {
+  const cwd = process.cwd();
+  const relWorkflow = relative(cwd, workflowPath) || "WORKFLOW.md";
+  const lines = [];
+  lines.push(`GitHub Project   ${result.githubProjectTitle}  (${result.projectId})`);
+  lines.push(`Runtime   ${result.runtime}`);
+  lines.push("");
+  lines.push("Generated files");
+  lines.push(`  \u2713 WORKFLOW.md                          ${relWorkflow}`);
+  if (result.contextYamlWritten) {
+    lines.push(
+      "  \u2713 Context metadata                     .gh-symphony/context.yaml"
+    );
+  }
+  if (result.referenceWorkflowWritten) {
+    lines.push(
+      "  \u2713 Reference workflow                   .gh-symphony/reference-workflow.md"
+    );
+  }
+  if (result.skillsDir) {
+    const relSkillsDir = relative(cwd, result.skillsDir);
+    lines.push("");
+    lines.push(`Skills  \u2192  ${relSkillsDir}/`);
+    for (const name of result.skillsWritten) {
+      lines.push(`  \u2713 ${name}`);
+    }
+    for (const name of result.skillsSkipped) {
+      lines.push(`  \u2013 ${name}  (already exists, skipped)`);
+    }
+  } else if (result.runtime !== "codex" && result.runtime !== "claude-code") {
+    lines.push("");
+    lines.push("Skills  \u2192  (skipped \u2014 custom runtime)");
+  }
+  if (opts.interactive) {
+    p.note(lines.join("\n"), "Setup complete");
+    p.outro(opts.nextSteps ?? "Ready.");
+  } else {
+    process.stdout.write(lines.map((l) => `  ${l}`).join("\n") + "\n");
+  }
+}
+async function runNonInteractive(flags, options) {
+  let token;
+  try {
+    token = getGhToken();
+  } catch {
+    process.stderr.write(
+      "Error: GitHub token not found. Run 'gh auth login --scopes repo,read:org,project' or set GITHUB_GRAPHQL_TOKEN.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const client = createClient(token);
+  let viewer;
+  try {
+    viewer = await validateToken(client);
+  } catch {
+    process.stderr.write("Error: Invalid GitHub token.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const scopeCheck = checkRequiredScopes(viewer.scopes);
+  if (!scopeCheck.valid) {
+    process.stderr.write(
+      `Error: Missing required PAT scopes: ${scopeCheck.missing.join(", ")}
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const projects = await listUserProjects(client);
+  let githubProject;
+  if (flags.project) {
+    const match = projects.find(
+      (proj) => proj.id === flags.project || proj.url === flags.project
+    );
+    if (!match) {
+      process.stderr.write(`Error: Project not found: ${flags.project}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    githubProject = await getProjectDetail(client, match.id);
+  } else if (projects.length === 1) {
+    githubProject = await getProjectDetail(client, projects[0].id);
+  } else {
+    process.stderr.write(
+      "Error: --project is required when multiple projects exist.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const statusField = githubProject.statusFields.find((f) => f.name.toLowerCase() === "status") ?? githubProject.statusFields[0];
+  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 validation = validateStateMapping(mappings);
+  if (!validation.valid) {
+    process.stderr.write(
+      `Error: Cannot auto-map columns. ${validation.errors.join("; ")}
+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,
+    mappings,
+    lifecycle: lifecycleConfig,
+    runtime: "codex"
+  });
+  await writeFile3(outputPath, workflowMd, "utf8");
+  const ecosystemResult = await writeEcosystem({
+    cwd: process.cwd(),
+    projectDetail: githubProject,
+    statusField,
+    runtime: "codex",
+    skipSkills: flags.skipSkills,
+    skipContext: flags.skipContext
+  });
+  if (options.json) {
+    process.stdout.write(
+      JSON.stringify({ output: outputPath, status: "created" }) + "\n"
+    );
+  } else {
+    printEcosystemSummary(ecosystemResult, outputPath, {
+      interactive: false,
+      nextSteps: "Run 'gh-symphony project add' to register a project."
+    });
+  }
+}
+async function runInteractive(options) {
+  p.intro("gh-symphony \u2014 WORKFLOW.md Setup");
+  await runInteractiveStandalone(options);
+}
+async function runInteractiveStandalone(_options) {
+  const s1 = p.spinner();
+  s1.start("Checking gh CLI authentication...");
+  let client;
+  try {
+    const { token } = ensureGhAuth();
+    client = createClient(token);
+    s1.stop("Authenticated via gh CLI");
+  } 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);
+      }
+    } else {
+      p.log.error(error instanceof Error ? error.message : "Unknown error");
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const s2 = p.spinner();
+  s2.start("Loading projects...");
+  let projects;
+  try {
+    projects = await listUserProjects(client);
+    s2.stop(
+      `Found ${projects.length} project${projects.length === 1 ? "" : "s"}`
+    );
+  } catch (error) {
+    s2.stop("Failed to load projects.");
+    if (error instanceof GitHubScopeError) {
+      displayScopeError(error, "gh-symphony init");
+    } else {
+      p.log.error(error instanceof Error ? error.message : "Unknown error");
+    }
+    process.exitCode = 1;
+    return;
+  }
+  if (projects.length === 0) {
+    p.log.error(
+      "No GitHub Projects found. Create a project at https://github.com/orgs/YOUR_ORG/projects and re-run."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const selectedGithubProjectId = await abortIfCancelled(
+    p.select({
+      message: "Step 1/2 \u2014 Select a GitHub Project board:",
+      options: projects.map((proj) => ({
+        value: proj.id,
+        label: `${proj.owner.login}/${proj.title}`,
+        hint: `${proj.openItemCount} items`
+      })),
+      maxItems: 15
+    })
+  );
+  const s2d = p.spinner();
+  s2d.start("Loading project details...");
+  let projectDetail;
+  try {
+    projectDetail = await getProjectDetail(client, selectedGithubProjectId);
+    s2d.stop(`Loaded: ${projectDetail.title}`);
+  } catch (error) {
+    s2d.stop("Failed to load project details.");
+    p.log.error(error instanceof Error ? error.message : "Unknown error");
+    process.exitCode = 1;
+    return;
+  }
+  const statusField = projectDetail.statusFields.find((f) => f.name.toLowerCase() === "status") ?? projectDetail.statusFields[0];
+  if (!statusField) {
+    p.log.error(
+      "No status field found on the project. The project needs a single-select 'Status' field."
+    );
+    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 validation = validateStateMapping(mappings);
+  if (!validation.valid) {
+    p.log.error("Mapping validation failed:");
+    for (const err of validation.errors) {
+      p.log.error(`  \u2022 ${err}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  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,
+    mappings,
+    lifecycle: lifecycleConfig,
+    runtime: "codex"
+  });
+  const outputPath = resolve("WORKFLOW.md");
+  await writeFile3(outputPath, workflowMd, "utf8");
+  const ecosystemResult = await writeEcosystem({
+    cwd: process.cwd(),
+    projectDetail,
+    statusField,
+    runtime: "codex",
+    skipSkills: false,
+    skipContext: false
+  });
+  printEcosystemSummary(ecosystemResult, outputPath, {
+    interactive: true,
+    nextSteps: "Run 'gh-symphony project add' to register a project."
+  });
+}
+async function writeConfig(configDir, input) {
+  await saveProjectConfig(configDir, input.projectId, {
+    projectId: input.projectId,
+    slug: input.projectId,
+    displayName: input.project.title,
+    workspaceDir: input.workspaceDir,
+    repositories: input.repos.map((r) => ({
+      owner: r.owner,
+      name: r.name,
+      cloneUrl: r.cloneUrl
+    })),
+    tracker: {
+      adapter: "github-project",
+      bindingId: input.project.id,
+      settings: {
+        projectId: input.project.id,
+        ...input.assignedOnly ? { assignedOnly: true } : {}
+      }
+    }
+  });
+  const existing = await loadGlobalConfig(configDir);
+  const globalConfig = {
+    activeProject: input.projectId,
+    projects: [
+      ...(existing?.projects ?? []).filter((t) => t !== input.projectId),
+      input.projectId
+    ]
+  };
+  await saveGlobalConfig(configDir, globalConfig);
+}
+function generateProjectId(githubProjectTitle, uniqueKey) {
+  const slug = githubProjectTitle.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32);
+  const suffix = createHash("sha1").update(uniqueKey).digest("hex").slice(0, 8);
+  return [slug || "project", suffix].join("-");
+}
+
+export {
+  GitHubScopeError,
+  createClient,
+  validateToken,
+  checkRequiredScopes,
+  listUserProjects,
+  getProjectDetail,
+  abortIfCancelled,
+  init_default,
+  writeEcosystem,
+  writeConfig,
+  generateProjectId
+};