@gh-symphony/cli 0.0.1 → 0.0.2

package/dist/commands/init.js

@@ -1,10 +1,33 @@
 import * as p from "@clack/prompts";
+import { parseWorkflowMarkdown } from "@gh-symphony/core";
 import { createHash } from "node:crypto";
-import { createClient, validateToken, checkRequiredScopes, listUserProjects, getProjectDetail, } from "../github/client.js";
-import { inferAllColumnRoles, toWorkflowLifecycleConfig, validateMapping, } from "../mapping/smart-defaults.js";
-import { loadGlobalConfig, saveGlobalConfig, saveWorkspaceConfig, saveWorkflowMapping, } from "../config.js";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createClient, validateToken, checkRequiredScopes, listUserProjects, getProjectDetail, GitHubScopeError, } from "../github/client.js";
+import { inferAllStateRoles, toWorkflowLifecycleConfig, validateStateMapping, } from "../mapping/smart-defaults.js";
+import { generateWorkflowMarkdown } from "../workflow/generate-workflow-md.js";
+import { loadGlobalConfig, loadTenantConfig, saveGlobalConfig, saveTenantConfig, saveWorkflowMapping, } from "../config.js";
+import { getGhToken, ensureGhAuth, GhAuthError } from "../github/gh-auth.js";
+import { detectEnvironment } from "../detection/environment-detector.js";
+import { buildContextYaml, writeContextYaml, } from "../context/generate-context-yaml.js";
+import { generateReferenceWorkflow } from "../workflow/generate-reference-workflow.js";
+import { resolveSkillsDir, writeAllSkills } from "../skills/skill-writer.js";
+import { ALL_SKILL_TEMPLATES } from "../skills/templates/index.js";
+// ── Scope error display ───────────────────────────────────────────────────────
+const 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}\n\nThen re-run: ${retryCommand}`, "Fix missing scope");
+}
 // ── Cancellation utility ─────────────────────────────────────────────────────
-async function abortIfCancelled(input) {
+export async function abortIfCancelled(input) {
     const result = await input;
     if (p.isCancel(result)) {
         p.cancel("Setup cancelled.");
@@ -13,7 +36,11 @@ async function abortIfCancelled(input) {
     return result;
 }
 function parseInitFlags(args) {
-    const flags = { nonInteractive: false };
+    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];
@@ -21,18 +48,20 @@ function parseInitFlags(args) {
             case "--non-interactive":
                 flags.nonInteractive = true;
                 break;
-            case "--token":
-                flags.token = next;
-                i += 1;
-                break;
             case "--project":
                 flags.project = next;
                 i += 1;
                 break;
-            case "--runtime":
-                flags.runtime = next;
+            case "--output":
+                flags.output = next;
                 i += 1;
                 break;
+            case "--skip-skills":
+                flags.skipSkills = true;
+                break;
+            case "--skip-context":
+                flags.skipContext = true;
+                break;
         }
     }
     return flags;
@@ -47,14 +76,168 @@ const handler = async (args, options) => {
     await runInteractive(options);
 };
 export default handler;
-// ── 4.8: Non-interactive mode ────────────────────────────────────────────────
+function inferAgentRuntimeFromCommand(command) {
+    if (!command) {
+        return null;
+    }
+    if (command.includes("claude-code")) {
+        return "claude-code";
+    }
+    if (command.includes("codex")) {
+        return "codex";
+    }
+    return null;
+}
+function isWorkerBootstrapCommand(command) {
+    return (command.includes("@gh-symphony/worker/dist/index.js") ||
+        command.includes("packages/worker/dist/index.js"));
+}
+function isMissingAgentEnvError(error) {
+    return (error instanceof Error &&
+        error.message.includes("Workflow front matter requires environment variable"));
+}
+export async function resolveTenantRuntime(configDir, tenantId, tenantWorkerCommand) {
+    const workflowPath = join(configDir, "tenants", tenantId, "WORKFLOW.md");
+    try {
+        const workflowMarkdown = await readFile(workflowPath, "utf8");
+        const agentCommand = parseWorkflowMarkdown(workflowMarkdown, {}).agentCommand;
+        if (!isWorkerBootstrapCommand(agentCommand)) {
+            return agentCommand;
+        }
+    }
+    catch (error) {
+        const err = error;
+        if (err.code !== "ENOENT" && !isMissingAgentEnvError(error)) {
+            throw error;
+        }
+    }
+    return inferAgentRuntimeFromCommand(tenantWorkerCommand) ?? "codex";
+}
+export async function writeEcosystem(opts) {
+    const { cwd, projectDetail, statusField, runtime, skipSkills, skipContext } = opts;
+    const ghSymphonyDir = join(cwd, ".gh-symphony");
+    await mkdir(ghSymphonyDir, { recursive: true });
+    // 1. Detect environment
+    const env = await detectEnvironment(cwd);
+    // 2. Write context.yaml (unless --skip-context)
+    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;
+    }
+    // 3. Write reference-workflow.md
+    const refWorkflow = generateReferenceWorkflow({
+        runtime,
+        statusColumns: statusField.options.map((o) => ({
+            name: o.name,
+            role: null,
+        })),
+        projectId: projectDetail.id,
+    });
+    const refPath = join(ghSymphonyDir, "reference-workflow.md");
+    const tmpRef = refPath + ".tmp";
+    await writeFile(tmpRef, refWorkflow, "utf8");
+    await rename(tmpRef, refPath);
+    // 4. Write skills (unless --skip-skills)
+    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,
+            projectTitle: 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((p) => basename(dirname(p)));
+        skillsSkipped = result.skipped.map((p) => basename(dirname(p)));
+    }
+    return {
+        projectId: projectDetail.id,
+        projectTitle: projectDetail.title,
+        runtime,
+        skillsDir,
+        contextYamlWritten,
+        referenceWorkflowWritten: true,
+        skillsWritten,
+        skillsSkipped,
+    };
+}
+// ── Ecosystem summary output ─────────────────────────────────────────────────
+function printEcosystemSummary(result, workflowPath, opts) {
+    const cwd = process.cwd();
+    const relWorkflow = relative(cwd, workflowPath) || "WORKFLOW.md";
+    const lines = [];
+    lines.push(`Project   ${result.projectTitle}  (${result.projectId})`);
+    lines.push(`Runtime   ${result.runtime}`);
+    lines.push("");
+    lines.push("Generated files");
+    lines.push(`  ✓ WORKFLOW.md                          ${relWorkflow}`);
+    if (result.contextYamlWritten) {
+        lines.push("  ✓ Context metadata                     .gh-symphony/context.yaml");
+    }
+    if (result.referenceWorkflowWritten) {
+        lines.push("  ✓ Reference workflow                   .gh-symphony/reference-workflow.md");
+    }
+    if (result.skillsDir) {
+        const relSkillsDir = relative(cwd, result.skillsDir);
+        lines.push("");
+        lines.push(`Skills  →  ${relSkillsDir}/`);
+        for (const name of result.skillsWritten) {
+            lines.push(`  ✓ ${name}`);
+        }
+        for (const name of result.skillsSkipped) {
+            lines.push(`  – ${name}  (already exists, skipped)`);
+        }
+    }
+    else if (result.runtime !== "codex" && result.runtime !== "claude-code") {
+        lines.push("");
+        lines.push("Skills  →  (skipped — 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");
+    }
+}
+// ── Non-interactive mode: WORKFLOW.md only ───────────────────────────────────
 async function runNonInteractive(flags, options) {
-    if (!flags.token) {
-        process.stderr.write("Error: --token is required in non-interactive mode.\n");
+    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(flags.token);
+    const client = createClient(token);
     // Validate token
     let viewer;
     try {
@@ -75,7 +258,7 @@ async function runNonInteractive(flags, options) {
     const projects = await listUserProjects(client);
     let project;
     if (flags.project) {
-        const match = projects.find((p) => p.id === flags.project || p.url === 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}\n`);
             process.exitCode = 1;
@@ -100,92 +283,179 @@ async function runNonInteractive(flags, options) {
         return;
     }
     const columnNames = statusField.options.map((o) => o.name);
-    const inferred = inferAllColumnRoles(columnNames);
-    const roles = {};
+    const inferred = inferAllStateRoles(columnNames);
+    const mappings = {};
     for (const mapping of inferred) {
         if (mapping.role) {
-            roles[mapping.columnName] = mapping.role;
+            mappings[mapping.columnName] = { role: mapping.role };
         }
     }
-    const validation = validateMapping(roles);
+    const validation = validateStateMapping(mappings);
     if (!validation.valid) {
         process.stderr.write(`Error: Cannot auto-map columns. ${validation.errors.join("; ")}\nRun without --non-interactive for manual mapping.\n`);
         process.exitCode = 1;
         return;
     }
-    const runtime = flags.runtime ?? "codex";
-    const workspaceId = generateWorkspaceId(project.title, project.id);
-    await writeConfig(options.configDir, {
-        workspaceId,
-        token: flags.token,
-        project,
-        repos: project.linkedRepositories,
+    const lifecycleConfig = toWorkflowLifecycleConfig(statusField.name, mappings);
+    const outputPath = resolve(flags.output ?? "WORKFLOW.md");
+    const workflowMd = generateWorkflowMarkdown({
+        projectId: project.id,
+        stateFieldName: statusField.name,
+        mappings,
+        lifecycle: lifecycleConfig,
+        runtime: "codex",
+    });
+    await writeFile(outputPath, workflowMd, "utf8");
+    const ecosystemResult = await writeEcosystem({
+        cwd: process.cwd(),
+        projectDetail: project,
         statusField,
-        roles,
-        humanReviewMode: "plan-and-pr",
-        runtime,
+        runtime: "codex",
+        skipSkills: flags.skipSkills,
+        skipContext: flags.skipContext,
     });
     if (options.json) {
-        process.stdout.write(JSON.stringify({ workspaceId, status: "created" }) + "\n");
+        process.stdout.write(JSON.stringify({ output: outputPath, status: "created" }) + "\n");
     }
     else {
-        process.stdout.write(`Workspace created: ${workspaceId}\n`);
-        process.stdout.write(`Run 'gh-symphony start' to begin orchestration.\n`);
+        printEcosystemSummary(ecosystemResult, outputPath, {
+            interactive: false,
+            nextSteps: "Run 'gh-symphony tenant add' to register a tenant.",
+        });
     }
 }
-// ── Interactive mode ─────────────────────────────────────────────────────────
+// ── Interactive mode: WORKFLOW.md generation ─────────────────────────────────
 async function runInteractive(options) {
-    p.intro("gh-symphony — Workspace Setup");
-    // 4.7: Detect existing config
-    const existingConfig = await loadGlobalConfig(options.configDir);
-    if (existingConfig) {
-        const action = await abortIfCancelled(p.select({
-            message: "Existing configuration detected. What would you like to do?",
-            options: [
-                { value: "add", label: "Add a new workspace" },
-                { value: "overwrite", label: "Start fresh (overwrite)" },
-            ],
+    p.intro("gh-symphony — WORKFLOW.md Setup");
+    // Case A: tenant(s) already configured
+    const globalConfig = await loadGlobalConfig(options.configDir);
+    if (globalConfig?.tenants?.length) {
+        await runInteractiveFromTenant(globalConfig, options);
+        return;
+    }
+    // Case B: no tenants — standalone WORKFLOW.md generation
+    await runInteractiveStandalone(options);
+}
+// ── Case A: Generate WORKFLOW.md from existing tenant config ─────────────────
+async function runInteractiveFromTenant(globalConfig, options) {
+    const tenants = globalConfig.tenants;
+    let tenantId;
+    if (tenants.length === 1) {
+        tenantId = tenants[0];
+    }
+    else {
+        // Multiple tenants: ask which one to base WORKFLOW.md on
+        const tenantConfigs = await Promise.all(tenants.map(async (id) => {
+            const cfg = await loadTenantConfig(options.configDir, id);
+            return { id, label: cfg?.slug ?? id };
         }));
-        if (action === "overwrite") {
-            // Continue with fresh setup — will overwrite config
-        }
-        // "add" continues to create a new workspace alongside existing ones
+        tenantId = await abortIfCancelled(p.select({
+            message: "Select a tenant to base WORKFLOW.md on:",
+            options: tenantConfigs.map((t) => ({
+                value: t.id,
+                label: t.label,
+                hint: globalConfig.activeTenant === t.id ? "active" : undefined,
+            })),
+        }));
+    }
+    const tenantConfig = await loadTenantConfig(options.configDir, tenantId);
+    if (!tenantConfig) {
+        p.log.error(`Tenant config not found for "${tenantId}".`);
+        process.exitCode = 1;
+        return;
     }
-    // ── Step 1: PAT input with async validation (4.1) ─────────────────────────
+    const lifecycle = tenantConfig.workflowMapping?.lifecycle;
+    if (!lifecycle) {
+        p.log.error(`Tenant "${tenantId}" has no workflow lifecycle config. Run 'gh-symphony tenant add' first.`);
+        process.exitCode = 1;
+        return;
+    }
+    const mappings = {};
+    const workflowMapping = tenantConfig.workflowMapping;
+    if (workflowMapping) {
+        Object.assign(mappings, workflowMapping.mappings);
+    }
+    const projectId = tenantConfig.tracker.settings?.projectId;
+    const stateFieldName = workflowMapping?.stateFieldName ?? lifecycle.stateFieldName;
+    const runtime = await resolveTenantRuntime(options.configDir, tenantId, tenantConfig.runtime.workerCommand);
+    const workflowMd = generateWorkflowMarkdown({
+        projectId: projectId ?? "",
+        stateFieldName,
+        mappings,
+        lifecycle,
+        runtime,
+    });
+    const outputPath = resolve("WORKFLOW.md");
+    await writeFile(outputPath, workflowMd, "utf8");
+    const projId = tenantConfig.tracker.settings?.projectId;
+    let ecosystemResult = null;
     let token;
-    let viewer;
-    let client;
-    while (true) {
-        const rawToken = await abortIfCancelled(p.password({
-            message: "Step 1/6 — Enter your GitHub Personal Access Token:",
-            validate: (v) => {
-                if (!v)
-                    return "Token is required.";
-                if (v.length < 40)
-                    return "Token too short.";
-            },
-        }));
-        client = createClient(rawToken);
-        const s = p.spinner();
-        s.start("Validating token...");
+    try {
+        token = getGhToken();
+    }
+    catch {
+        // getGhToken failed — token stays undefined; ecosystem write proceeds best-effort
+    }
+    if (token && projId) {
         try {
-            viewer = await validateToken(client);
-            const scopeCheck = checkRequiredScopes(viewer.scopes);
-            if (!scopeCheck.valid) {
-                s.stop(`Token valid (${viewer.login}), but missing scopes: ${scopeCheck.missing.join(", ")}`);
-                p.log.warn("Required scopes: repo, read:org, project. Please create a new token with these scopes.");
-                continue;
+            const client = createClient(token);
+            const fullProject = await getProjectDetail(client, projId);
+            const sf = fullProject.statusFields.find((f) => f.name.toLowerCase() === stateFieldName.toLowerCase()) ?? fullProject.statusFields[0];
+            if (sf) {
+                ecosystemResult = await writeEcosystem({
+                    cwd: process.cwd(),
+                    projectDetail: fullProject,
+                    statusField: sf,
+                    runtime,
+                    skipSkills: false,
+                    skipContext: false,
+                });
             }
-            s.stop(`Authenticated as ${viewer.login}${viewer.name ? ` (${viewer.name})` : ""}`);
-            token = rawToken;
-            break;
         }
-        catch (error) {
-            s.stop(`Token invalid: ${error instanceof Error ? error.message : "Unknown error"}`);
-            p.log.warn("Please try a different token.");
+        catch {
+            // best-effort: don't fail init if GitHub API is unreachable
         }
     }
-    // ── Step 2: Project selection (4.2) ────────────────────────────────────────
+    if (ecosystemResult) {
+        printEcosystemSummary(ecosystemResult, outputPath, { interactive: true });
+    }
+    else {
+        p.outro(`WORKFLOW.md generated at ${outputPath}`);
+    }
+}
+// ── Case B: Standalone WORKFLOW.md generation (no tenant) ────────────────────
+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가 설치되어 있지 않습니다. https://cli.github.com 에서 설치하세요.");
+            }
+            else if (error.code === "not_authenticated") {
+                p.log.error("gh auth login --scopes repo,read:org,project 를 실행하세요.");
+            }
+            else if (error.code === "missing_scopes") {
+                p.log.error("gh auth refresh --scopes repo,read:org,project 를 실행하세요.");
+            }
+            else {
+                p.log.error(error.message);
+            }
+        }
+        else {
+            p.log.error(error instanceof Error ? error.message : "Unknown error");
+        }
+        process.exitCode = 1;
+        return;
+    }
+    // Step 1/2: Project selection
     const s2 = p.spinner();
     s2.start("Loading projects...");
     let projects;
@@ -195,17 +465,22 @@ async function runInteractive(options) {
     }
     catch (error) {
         s2.stop("Failed to load projects.");
-        p.log.error(error instanceof Error ? error.message : "Unknown error");
+        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 init.");
+        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 selectedProjectId = await abortIfCancelled(p.select({
-        message: "Step 2/6 — Select a GitHub Project:",
+        message: "Step 1/2 — Select a GitHub Project:",
         options: projects.map((proj) => ({
             value: proj.id,
             label: `${proj.owner.login}/${proj.title}`,
@@ -226,21 +501,7 @@ async function runInteractive(options) {
         process.exitCode = 1;
         return;
     }
-    // ── Step 3: Repository selection (4.3) ─────────────────────────────────────
-    if (projectDetail.linkedRepositories.length === 0) {
-        p.log.warn("No linked repositories found in this project. Add issues from repositories to the project first.");
-        process.exitCode = 1;
-        return;
-    }
-    const selectedRepos = await abortIfCancelled(p.multiselect({
-        message: "Step 3/6 — Select repositories to orchestrate:",
-        options: projectDetail.linkedRepositories.map((repo) => ({
-            value: repo,
-            label: `${repo.owner}/${repo.name}`,
-        })),
-        required: true,
-    }));
-    // ── Step 4: Status column mapping (4.4) ────────────────────────────────────
+    // Step 3: Status column mapping
     const statusField = projectDetail.statusFields.find((f) => f.name.toLowerCase() === "status") ??
         projectDetail.statusFields[0];
     if (!statusField) {
@@ -249,33 +510,29 @@ async function runInteractive(options) {
         return;
     }
     const columnNames = statusField.options.map((o) => o.name);
-    const inferred = inferAllColumnRoles(columnNames);
+    const inferred = inferAllStateRoles(columnNames);
     p.log.info(`Found ${columnNames.length} status columns on field "${statusField.name}".`);
-    // Show smart defaults and let user adjust
-    const roles = {};
+    const mappings = {};
     for (const mapping of inferred) {
         const roleOptions = [
-            { value: "trigger", label: "Trigger (starts work)" },
-            { value: "working", label: "Working (implementation)" },
-            { value: "human-review", label: "Review (human approval)" },
-            { value: "done", label: "Done (completed)" },
-            { value: "ignored", label: "Ignored (skip)" },
+            { value: "active", label: "Active (agent works on this)" },
+            { value: "wait", label: "Wait (human review / hold)" },
+            { value: "terminal", label: "Terminal (completed)" },
         ];
-        const defaultRole = mapping.role ?? "ignored";
-        // Put default first
+        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 4/6 — Map column "${mapping.columnName}":${mapping.confidence === "high" ? " (auto-detected)" : ""}`,
+            message: `Step 2/2 — Map column "${mapping.columnName}":${mapping.confidence === "high" ? " (auto-detected)" : ""}`,
             options: sortedOptions,
         }));
         if (selectedRole !== "skip") {
-            roles[mapping.columnName] = selectedRole;
+            mappings[mapping.columnName] = { role: selectedRole };
         }
     }
-    const validation = validateMapping(roles);
+    const validation = validateStateMapping(mappings);
     if (!validation.valid) {
         p.log.error("Mapping validation failed:");
         for (const err of validation.errors) {
@@ -287,170 +544,53 @@ async function runInteractive(options) {
     for (const warn of validation.warnings) {
         p.log.warn(`  ⚠ ${warn}`);
     }
-    // Human review mode selection
-    const humanReviewMode = await abortIfCancelled(p.select({
-        message: "Human review mode:",
-        options: [
-            {
-                value: "plan-and-pr",
-                label: "Plan & PR review",
-                hint: "Human reviews both plans and PRs",
-            },
-            {
-                value: "plan-only",
-                label: "Plan review only",
-                hint: "Human reviews plans, PRs auto-merge",
-            },
-            {
-                value: "pr-only",
-                label: "PR review only",
-                hint: "No plan review, human reviews PRs",
-            },
-            {
-                value: "none",
-                label: "None (full auto)",
-                hint: "No human review at all",
-            },
-        ],
-    }));
-    // Show visual flow summary
-    const lifecycleConfig = toWorkflowLifecycleConfig(statusField.name, roles, humanReviewMode);
-    const flowParts = [];
-    if (lifecycleConfig.planningStates.length)
-        flowParts.push(`[Planning: ${lifecycleConfig.planningStates.join(", ")}]`);
-    if (lifecycleConfig.humanReviewStates.length)
-        flowParts.push(`[Review: ${lifecycleConfig.humanReviewStates.join(", ")}]`);
-    if (lifecycleConfig.implementationStates.length)
-        flowParts.push(`[Implementation: ${lifecycleConfig.implementationStates.join(", ")}]`);
-    if (lifecycleConfig.awaitingMergeStates.length)
-        flowParts.push(`[Awaiting Merge: ${lifecycleConfig.awaitingMergeStates.join(", ")}]`);
-    if (lifecycleConfig.completedStates.length)
-        flowParts.push(`[Done: ${lifecycleConfig.completedStates.join(", ")}]`);
-    p.note(flowParts.join(" → "), "Workflow Flow");
-    // ── Step 5: Runtime selection (4.5) ────────────────────────────────────────
-    const runtime = await abortIfCancelled(p.select({
-        message: "Step 5/6 — Select AI runtime:",
-        options: [
-            { value: "codex", label: "OpenAI Codex", hint: "recommended" },
-            { value: "claude-code", label: "Claude Code" },
-            { value: "custom", label: "Custom command" },
-        ],
-    }));
-    let workerCommand;
-    if (runtime === "custom") {
-        workerCommand = await abortIfCancelled(p.text({
-            message: "Custom worker command:",
-            placeholder: "node packages/worker/dist/index.js",
-        }));
-    }
-    // ── Step 6: Options (4.5) ──────────────────────────────────────────────────
-    const advancedOptions = await abortIfCancelled(p.confirm({
-        message: "Step 6/6 — Configure advanced options? (poll interval, concurrency)",
-        initialValue: false,
-    }));
-    let pollIntervalMs = 30_000;
-    let concurrency = 3;
-    let maxAttempts = 3;
-    if (advancedOptions) {
-        const pollStr = await abortIfCancelled(p.text({
-            message: "Poll interval (seconds):",
-            placeholder: "30",
-            initialValue: "30",
-            validate: (v) => {
-                const n = Number(v);
-                if (!v || isNaN(n) || n < 5)
-                    return "Must be at least 5 seconds.";
-            },
-        }));
-        pollIntervalMs = Number(pollStr) * 1000;
-        const concurrencyStr = await abortIfCancelled(p.text({
-            message: "Max concurrent workers:",
-            placeholder: "3",
-            initialValue: "3",
-            validate: (v) => {
-                const n = Number(v);
-                if (!v || isNaN(n) || n < 1)
-                    return "Must be at least 1.";
-            },
-        }));
-        concurrency = Number(concurrencyStr);
-        const attemptsStr = await abortIfCancelled(p.text({
-            message: "Max retry attempts per issue:",
-            placeholder: "3",
-            initialValue: "3",
-            validate: (v) => {
-                const n = Number(v);
-                if (!v || isNaN(n) || n < 1)
-                    return "Must be at least 1.";
-            },
-        }));
-        maxAttempts = Number(attemptsStr);
-    }
-    // ── Confirmation ───────────────────────────────────────────────────────────
-    p.note([
-        `User:       ${viewer.login}`,
-        `Project:    ${projectDetail.title}`,
-        `Repos:      ${selectedRepos.map((r) => `${r.owner}/${r.name}`).join(", ")}`,
-        `Runtime:    ${runtime}`,
-        `Review:     ${humanReviewMode}`,
-        `Poll:       ${pollIntervalMs / 1000}s`,
-        `Concurrency: ${concurrency}`,
-        `Max retries: ${maxAttempts}`,
-    ].join("\n"), "Configuration Summary");
-    const confirmed = await abortIfCancelled(p.confirm({ message: "Apply this configuration?" }));
-    if (!confirmed) {
-        p.cancel("Setup cancelled.");
-        process.exitCode = 130;
-        return;
-    }
-    // ── Write config files (4.6) ───────────────────────────────────────────────
-    const workspaceId = generateWorkspaceId(projectDetail.title, projectDetail.id);
-    const s6 = p.spinner();
-    s6.start("Writing configuration...");
+    const lifecycleConfig = toWorkflowLifecycleConfig(statusField.name, mappings);
+    // Generate WORKFLOW.md only — no config files written
+    const workflowMd = generateWorkflowMarkdown({
+        projectId: projectDetail.id,
+        stateFieldName: statusField.name,
+        mappings,
+        lifecycle: lifecycleConfig,
+        runtime: "codex",
+    });
+    const outputPath = resolve("WORKFLOW.md");
+    await writeFile(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 tenant add' to register a tenant.",
+    });
+}
+function resolveWorkerCommand() {
     try {
-        await writeConfig(options.configDir, {
-            workspaceId,
-            token,
-            project: projectDetail,
-            repos: selectedRepos,
-            statusField: {
-                name: statusField.name,
-                options: statusField.options,
-            },
-            roles,
-            humanReviewMode,
-            runtime,
-            workerCommand,
-            pollIntervalMs,
-            concurrency,
-            maxAttempts,
-        });
-        s6.stop("Configuration saved.");
+        const url = import.meta.resolve("@gh-symphony/worker/dist/index.js");
+        return `node ${fileURLToPath(url)}`;
     }
-    catch (error) {
-        s6.stop("Failed to write configuration.");
-        p.log.error(error instanceof Error ? error.message : "Unknown error");
-        process.exitCode = 1;
-        return;
+    catch {
+        return undefined;
     }
-    p.outro(`Workspace "${workspaceId}" created!\n  Run 'gh-symphony start' to begin orchestration.`);
 }
 export async function writeConfig(configDir, input) {
-    const lifecycleConfig = toWorkflowLifecycleConfig(input.statusField.name, input.roles, input.humanReviewMode);
+    const lifecycleConfig = toWorkflowLifecycleConfig(input.statusField.name, input.mappings);
     // Save workflow mapping
     const mappingConfig = {
         stateFieldName: input.statusField.name,
-        columnRoles: input.roles,
-        humanReviewMode: input.humanReviewMode,
+        mappings: input.mappings,
         lifecycle: lifecycleConfig,
     };
-    await saveWorkflowMapping(configDir, input.workspaceId, mappingConfig);
-    // Save workspace config (OrchestratorWorkspaceConfig shape)
-    const runtimeDir = `${configDir}/workspaces/${input.workspaceId}/runtime`;
-    await saveWorkspaceConfig(configDir, input.workspaceId, {
-        workspaceId: input.workspaceId,
-        slug: input.workspaceId,
-        promptGuidelines: "",
+    await saveWorkflowMapping(configDir, input.tenantId, mappingConfig);
+    // Save tenant config (OrchestratorTenantConfig shape)
+    const runtimeDir = `${configDir}/tenants/${input.tenantId}/runtime`;
+    await saveTenantConfig(configDir, input.tenantId, {
+        tenantId: input.tenantId,
+        slug: input.tenantId,
         repositories: input.repos.map((r) => ({
             owner: r.owner,
             name: r.name,
@@ -461,48 +601,45 @@ export async function writeConfig(configDir, input) {
             bindingId: input.project.id,
             settings: {
                 projectId: input.project.id,
-                token: input.token,
             },
         },
         runtime: {
             driver: "local",
             workspaceRuntimeDir: runtimeDir,
             projectRoot: process.cwd(),
-            workerCommand: input.workerCommand,
-        },
-        workflow: buildWorkflowOverrides(lifecycleConfig, input),
-        orchestrator: {
-            concurrency: input.concurrency,
-            maxAttempts: input.maxAttempts,
+            workerCommand: input.workerCommand ?? resolveWorkerCommand(),
         },
         workflowMapping: mappingConfig,
     });
     // Save/update global config
     const existing = await loadGlobalConfig(configDir);
     const globalConfig = {
-        activeWorkspace: input.workspaceId,
-        token: input.token,
-        workspaces: [
-            ...(existing?.workspaces ?? []).filter((w) => w !== input.workspaceId),
-            input.workspaceId,
+        activeTenant: input.tenantId,
+        tenants: [
+            ...(existing?.tenants ?? []).filter((t) => t !== input.tenantId),
+            input.tenantId,
         ],
     };
     await saveGlobalConfig(configDir, globalConfig);
+    // Generate WORKFLOW.md for tenant-level fallback
+    const workflowMd = generateWorkflowMarkdown({
+        projectId: input.project.id,
+        stateFieldName: input.statusField.name,
+        mappings: input.mappings,
+        lifecycle: lifecycleConfig,
+        runtime: input.agentCommand ?? input.runtime,
+        pollIntervalMs: input.pollIntervalMs,
+        concurrency: input.concurrency,
+    });
+    const workflowMdPath = join(configDir, "tenants", input.tenantId, "WORKFLOW.md");
+    await writeFile(workflowMdPath, workflowMd, "utf8");
 }
-function buildWorkflowOverrides(lifecycle, input) {
-    return {
-        lifecycle,
-        scheduler: {
-            pollIntervalMs: input.pollIntervalMs ?? 30_000,
-        },
-    };
-}
-export function generateWorkspaceId(projectTitle, uniqueKey) {
+export function generateTenantId(projectTitle, uniqueKey) {
     const slug = projectTitle
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-|-$/g, "")
         .slice(0, 32);
     const suffix = createHash("sha1").update(uniqueKey).digest("hex").slice(0, 8);
-    return [slug || "workspace", suffix].join("-");
+    return [slug || "tenant", suffix].join("-");
 }