@gh-symphony/cli 0.0.1 → 0.0.3

package/dist/commands/status.js

@@ -1,32 +1,9 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { resolveRuntimeRoot, resolveWorkspaceConfig, syncWorkspaceToRuntime, } from "../orchestrator-runtime.js";
-// ANSI color helpers
-function bold(s) {
-    return `\x1b[1m${s}\x1b[0m`;
-}
-function dim(s) {
-    return `\x1b[2m${s}\x1b[0m`;
-}
-function green(s) {
-    return `\x1b[32m${s}\x1b[0m`;
-}
-function red(s) {
-    return `\x1b[31m${s}\x1b[0m`;
-}
-function yellow(s) {
-    return `\x1b[33m${s}\x1b[0m`;
-}
-function cyan(s) {
-    return `\x1b[36m${s}\x1b[0m`;
-}
-function white(s) {
-    return `\x1b[37m${s}\x1b[0m`;
-}
-function stripAnsi(s) {
-    // eslint-disable-next-line no-control-regex
-    return s.replace(/\x1b\[[0-9;]*m/g, "");
-}
+import { resolveRuntimeRoot, resolveTenantConfig, syncTenantToRuntime, } from "../orchestrator-runtime.js";
+import { bold, dim, green, red, yellow, cyan, stripAnsi } from "../ansi.js";
+import { clearScreen, showCursor, hideCursor } from "../ansi.js";
+import { renderDashboard } from "../dashboard/renderer.js";
 function healthIcon(health) {
     switch (health) {
         case "idle":
@@ -54,7 +31,7 @@ function truncate(s, len) {
         return s;
     return s.slice(0, len - 3) + "...";
 }
-function renderDashboard(snapshot, noColor) {
+function renderLegacyStatus(snapshot, noColor) {
     const apply = noColor ? (s) => stripAnsi(s) : (s) => s;
     const lines = [];
     // Header
@@ -83,16 +60,7 @@ function renderDashboard(snapshot, noColor) {
         lines.push("  Active Runs:");
         for (const run of snapshot.activeRuns) {
             const runIdDisplay = truncate(run.runId, 12);
-            const phaseColor = run.phase === "planning"
-                ? cyan
-                : run.phase === "human-review"
-                    ? yellow
-                    : run.phase === "implementation"
-                        ? cyan
-                        : run.phase === "awaiting-merge"
-                            ? yellow
-                            : white;
-            const phaseStr = apply(phaseColor(run.phase));
+            const stateStr = apply(cyan(run.issueState));
             const statusColor = run.status === "running"
                 ? green
                 : run.status === "failed"
@@ -101,7 +69,7 @@ function renderDashboard(snapshot, noColor) {
                         ? green
                         : dim;
             const statusStr = apply(statusColor(run.status));
-            lines.push(`    ${runIdDisplay}  ${run.issueIdentifier}  ${phaseStr}  ${statusStr}`);
+            lines.push(`    ${runIdDisplay}  ${run.issueIdentifier}  ${stateStr}  ${statusStr}`);
         }
         lines.push("");
     }
@@ -143,16 +111,16 @@ function parseStatusArgs(args) {
         if (arg === "--watch" || arg === "-w") {
             parsed.watch = true;
         }
-        if (arg === "--workspace" || arg === "--workspace-id") {
-            parsed.workspaceId = args[i + 1];
+        if (arg === "--tenant" || arg === "--tenant-id") {
+            parsed.tenantId = args[i + 1];
             i += 1;
         }
     }
     return parsed;
 }
-async function readStatusSnapshot(runtimeRoot, workspaceId) {
+async function readStatusSnapshot(runtimeRoot, tenantId) {
     try {
-        const statusPath = join(runtimeRoot, "orchestrator", "workspaces", workspaceId, "status.json");
+        const statusPath = join(runtimeRoot, "orchestrator", "tenants", tenantId, "status.json");
         const content = await readFile(statusPath, "utf-8");
         return JSON.parse(content);
     }
@@ -160,54 +128,83 @@ async function readStatusSnapshot(runtimeRoot, workspaceId) {
         return null;
     }
 }
+async function readAllStatusSnapshots(runtimeRoot) {
+    try {
+        const tenantsDir = join(runtimeRoot, "orchestrator", "tenants");
+        const { readdir } = await import("node:fs/promises");
+        const entries = await readdir(tenantsDir, { withFileTypes: true });
+        const snapshots = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const statusPath = join(tenantsDir, entry.name, "status.json");
+            try {
+                const content = await readFile(statusPath, "utf-8");
+                snapshots.push(JSON.parse(content));
+            }
+            catch {
+                // skip missing/invalid files
+            }
+        }
+        return snapshots;
+    }
+    catch {
+        return [];
+    }
+}
 const handler = async (args, options) => {
     const parsed = parseStatusArgs(args);
-    const wsConfig = await resolveWorkspaceConfig(options.configDir, parsed.workspaceId);
-    if (!wsConfig) {
-        process.stderr.write("No workspace configured. Run 'gh-symphony init' first.\n");
+    const tenantConfig = await resolveTenantConfig(options.configDir, parsed.tenantId);
+    if (!tenantConfig) {
+        process.stderr.write("No tenant configured. Run 'gh-symphony init' first.\n");
         process.exitCode = 1;
         return;
     }
     const runtimeRoot = resolveRuntimeRoot(options.configDir);
-    const workspaceId = wsConfig.workspaceId;
-    await syncWorkspaceToRuntime(options.configDir, wsConfig);
+    const tenantId = tenantConfig.tenantId;
+    await syncTenantToRuntime(options.configDir, tenantConfig);
     if (parsed.watch) {
-        // Watch mode: poll every 2 seconds
-        const clear = () => process.stdout.write("\x1b[2J\x1b[H");
+        const isTTY = process.stdout.isTTY === true;
+        let terminalWidth = process.stdout.columns ?? 115;
         const run = async () => {
-            clear();
-            const snapshot = await readStatusSnapshot(runtimeRoot, workspaceId);
-            if (snapshot) {
-                if (options.json) {
-                    process.stdout.write(JSON.stringify(snapshot, null, 2) + "\n");
-                }
-                else {
-                    process.stdout.write(renderDashboard(snapshot, options.noColor) + "\n");
-                }
+            const snapshots = await readAllStatusSnapshots(runtimeRoot);
+            if (options.json || !isTTY) {
+                process.stdout.write(JSON.stringify(snapshots, null, 2) + "\n");
             }
             else {
-                process.stdout.write("Unable to read status snapshot.\n");
+                process.stdout.write(clearScreen() +
+                    renderDashboard(snapshots, {
+                        terminalWidth,
+                        noColor: options.noColor,
+                    }) +
+                    "\n");
             }
         };
+        if (isTTY) {
+            process.stdout.write(hideCursor());
+        }
         await run();
         const interval = setInterval(() => void run(), 2000);
+        process.on("SIGWINCH", () => {
+            terminalWidth = process.stdout.columns ?? terminalWidth;
+        });
         const shutdown = () => {
             clearInterval(interval);
+            process.stdout.write(showCursor() + "\n");
             process.exit(0);
         };
         process.on("SIGINT", shutdown);
         process.on("SIGTERM", shutdown);
-        // Keep alive
         await new Promise(() => { });
     }
     // Single status query
-    const snapshot = await readStatusSnapshot(runtimeRoot, workspaceId);
+    const snapshot = await readStatusSnapshot(runtimeRoot, tenantId);
     if (snapshot) {
         if (options.json) {
             process.stdout.write(JSON.stringify(snapshot, null, 2) + "\n");
         }
         else {
-            process.stdout.write(renderDashboard(snapshot, options.noColor) + "\n");
+            process.stdout.write(renderLegacyStatus(snapshot, options.noColor) + "\n");
         }
     }
     else {

package/dist/commands/tenant.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalOptions } from "../index.js";
+declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
+export default handler;

package/dist/commands/tenant.js

@@ -0,0 +1,402 @@
+import * as p from "@clack/prompts";
+import { createClient, validateToken, checkRequiredScopes, listUserProjects, getProjectDetail, GitHubScopeError, } from "../github/client.js";
+import { ensureGhAuth, getGhToken, GhAuthError } from "../github/gh-auth.js";
+import { inferAllStateRoles, toWorkflowLifecycleConfig, validateStateMapping, } from "../mapping/smart-defaults.js";
+import { loadGlobalConfig, saveGlobalConfig, loadTenantConfig, tenantConfigDir, } from "../config.js";
+import { writeConfig, generateTenantId, abortIfCancelled } from "./init.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");
+}
+function parseTenantAddFlags(args) {
+    const flags = { nonInteractive: 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 "--runtime":
+                flags.runtime = next;
+                i += 1;
+                break;
+        }
+    }
+    return flags;
+}
+// ── Tenant command handler ────────────────────────────────────────────────────
+const handler = async (args, options) => {
+    const [subcommand, ...rest] = args;
+    switch (subcommand) {
+        case "add":
+            await tenantAdd(rest, options);
+            return;
+        case "list":
+            await tenantList(options);
+            return;
+        case "remove":
+            await tenantRemove(rest, options);
+            return;
+        default:
+            process.stdout.write("Usage: gh-symphony tenant <add|list|remove>\n");
+    }
+};
+export default handler;
+// ── tenant add ───────────────────────────────────────────────────────────────
+async function tenantAdd(args, options) {
+    const flags = parseTenantAddFlags(args);
+    if (flags.nonInteractive) {
+        await tenantAddNonInteractive(flags, options);
+        return;
+    }
+    await tenantAddInteractive(options);
+}
+// ── Non-interactive tenant add ───────────────────────────────────────────────
+async function tenantAddNonInteractive(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);
+    // Validate 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(", ")}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    // Find project
+    const projects = await listUserProjects(client);
+    let project;
+    if (flags.project) {
+        const match = projects.find((p) => p.id === flags.project || p.url === flags.project);
+        if (!match) {
+            process.stderr.write(`Error: Project not found: ${flags.project}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        project = await getProjectDetail(client, match.id);
+    }
+    else if (projects.length === 1) {
+        project = await getProjectDetail(client, projects[0].id);
+    }
+    else {
+        process.stderr.write("Error: --project is required when multiple projects exist.\n");
+        process.exitCode = 1;
+        return;
+    }
+    // Auto-map with smart defaults
+    const statusField = project.statusFields.find((f) => f.name.toLowerCase() === "status") ??
+        project.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("; ")}\nRun without --non-interactive for manual mapping.\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const runtime = flags.runtime ?? "codex";
+    const tenantId = generateTenantId(project.title, project.id);
+    await writeConfig(options.configDir, {
+        tenantId,
+        project,
+        repos: project.linkedRepositories,
+        statusField,
+        mappings,
+        runtime,
+    });
+    if (options.json) {
+        process.stdout.write(JSON.stringify({ tenantId, status: "created" }) + "\n");
+    }
+    else {
+        process.stdout.write(`Tenant created: ${tenantId}\n`);
+        process.stdout.write(`Run 'gh-symphony start' to begin orchestration.\n`);
+    }
+}
+// ── Interactive tenant add ───────────────────────────────────────────────────
+async function tenantAddInteractive(options) {
+    p.intro("gh-symphony — Tenant Setup");
+    // 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 tenant" },
+                { value: "overwrite", label: "Start fresh (overwrite)" },
+            ],
+        }));
+        if (action === "overwrite") {
+            // Continue with fresh setup — will overwrite config
+        }
+        // "add" continues to create a new tenant alongside existing ones
+    }
+    // ── Step 1: gh CLI authentication ─────────────────────────────────────────────
+    const s1 = p.spinner();
+    s1.start("Checking gh CLI authentication...");
+    let login;
+    let client;
+    try {
+        const { login: ghLogin, token } = ensureGhAuth();
+        login = ghLogin;
+        client = createClient(token);
+        s1.stop(`Authenticated as ${login}`);
+    }
+    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 2: Project selection ───────────────────────────────────────────────
+    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 tenant add");
+        }
+        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 selectedProjectId = await abortIfCancelled(p.select({
+        message: "Step 1/3 — Select a GitHub Project:",
+        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, selectedProjectId);
+        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;
+    }
+    // ── Step 3: Repository selection ────────────────────────────────────────────
+    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 2/3 — Select repositories to orchestrate:",
+        options: projectDetail.linkedRepositories.map((repo) => ({
+            value: repo,
+            label: `${repo.owner}/${repo.name}`,
+        })),
+        required: true,
+    }));
+    // ── Step 4: Status column auto-detection ─────────────────────────────────────
+    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);
+    const mappings = {};
+    for (const mapping of inferred) {
+        if (mapping.role) {
+            mappings[mapping.columnName] = { role: mapping.role };
+        }
+    }
+    const validation = validateStateMapping(mappings);
+    if (!validation.valid) {
+        p.log.error(`Cannot auto-map status columns: ${validation.errors.join("; ")}\nRun 'gh-symphony init' to manually configure WORKFLOW.md.`);
+        process.exitCode = 1;
+        return;
+    }
+    const lifecycleConfig = toWorkflowLifecycleConfig(statusField.name, mappings);
+    p.log.info(`Auto-detected workflow: Active=[${lifecycleConfig.activeStates.join(", ")}] Terminal=[${lifecycleConfig.terminalStates.join(", ")}]`);
+    // ── Step 4: Runtime selection ────────────────────────────────────────────────
+    const runtime = await abortIfCancelled(p.select({
+        message: "Step 3/3 — Select AI runtime:",
+        options: [
+            { value: "codex", label: "OpenAI Codex", hint: "recommended" },
+            { value: "claude-code", label: "Claude Code" },
+            { value: "custom", label: "Custom command" },
+        ],
+    }));
+    let agentCommand;
+    if (runtime === "custom") {
+        agentCommand = await abortIfCancelled(p.text({
+            message: "Custom agent command:",
+            placeholder: "bash -lc my-agent",
+        }));
+    }
+    // ── Confirmation ─────────────────────────────────────────────────────────────
+    p.note([
+        `User:       ${login}`,
+        `Project:    ${projectDetail.title}`,
+        `Repos:      ${selectedRepos.map((r) => `${r.owner}/${r.name}`).join(", ")}`,
+        `Runtime:    ${runtime}`,
+        `Active:     ${lifecycleConfig.activeStates.join(", ")}`,
+        `Terminal:   ${lifecycleConfig.terminalStates.join(", ")}`,
+    ].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 ────────────────────────────────────────────────────────
+    const tenantId = generateTenantId(projectDetail.title, projectDetail.id);
+    const s6 = p.spinner();
+    s6.start("Writing configuration...");
+    try {
+        await writeConfig(options.configDir, {
+            tenantId,
+            project: projectDetail,
+            repos: selectedRepos,
+            statusField: {
+                id: statusField.id,
+                name: statusField.name,
+                options: statusField.options,
+            },
+            mappings,
+            runtime,
+            agentCommand,
+        });
+        s6.stop("Configuration saved.");
+    }
+    catch (error) {
+        s6.stop("Failed to write configuration.");
+        p.log.error(error instanceof Error ? error.message : "Unknown error");
+        process.exitCode = 1;
+        return;
+    }
+    p.log.info(`WORKFLOW.md generated at ${tenantId}/WORKFLOW.md — edit it to customize your team policy.`);
+    p.outro(`Tenant "${tenantId}" created!\n  Run 'gh-symphony start' to begin orchestration.`);
+}
+// ── tenant list ───────────────────────────────────────────────────────────────
+async function tenantList(options) {
+    const global = await loadGlobalConfig(options.configDir);
+    if (!global?.tenants?.length) {
+        process.stdout.write("No tenants configured.\n");
+        return;
+    }
+    process.stdout.write("Configured tenants:\n");
+    const configs = await Promise.all(global.tenants.map((id) => loadTenantConfig(options.configDir, id)));
+    for (let i = 0; i < global.tenants.length; i++) {
+        const tenantId = global.tenants[i];
+        const config = configs[i];
+        const active = global.activeTenant === tenantId ? " (active)" : "";
+        const slug = config?.slug ?? tenantId;
+        process.stdout.write(`  ${slug}${active}\n`);
+    }
+}
+// ── tenant remove ─────────────────────────────────────────────────────────────
+async function tenantRemove(args, options) {
+    const tenantId = args[0];
+    if (!tenantId) {
+        process.stderr.write("Usage: gh-symphony tenant remove <tenant-id>\n");
+        process.exitCode = 1;
+        return;
+    }
+    const global = await loadGlobalConfig(options.configDir);
+    if (!global) {
+        process.stderr.write("No configuration found.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const updatedTenants = (global.tenants ?? []).filter((t) => t !== tenantId);
+    if (updatedTenants.length === global.tenants.length) {
+        process.stderr.write(`Tenant "${tenantId}" not found.\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const updatedConfig = {
+        ...global,
+        tenants: updatedTenants,
+        activeTenant: global.activeTenant === tenantId ? null : global.activeTenant,
+    };
+    await saveGlobalConfig(options.configDir, updatedConfig);
+    const { rm } = await import("node:fs/promises");
+    const dir = tenantConfigDir(options.configDir, tenantId);
+    try {
+        await rm(dir, { recursive: true, force: true });
+    }
+    catch {
+        // Directory may not exist
+    }
+    process.stdout.write(`Tenant "${tenantId}" removed.\n`);
+}

package/dist/config.d.ts

@@ -1,36 +1,37 @@
-import type { OrchestratorWorkspaceConfig, WorkflowLifecycleConfig } from "@hojinzs/gh-symphony-core";
+import type { OrchestratorTenantConfig, WorkflowLifecycleConfig } from "@gh-symphony/core";
 export declare const DEFAULT_CONFIG_DIR: string;
 export declare const CONFIG_FILE = "config.json";
 export declare const DAEMON_PID_FILE = "daemon.pid";
 export declare const LOGS_DIR = "logs";
 export type CliGlobalConfig = {
-    activeWorkspace: string | null;
-    token: string | null;
-    workspaces: string[];
+    activeTenant: string | null;
+    tenants: string[];
 };
-export type CliWorkspaceConfig = OrchestratorWorkspaceConfig & {
-    workflowMapping?: WorkflowMappingConfig;
+export type CliTenantConfig = OrchestratorTenantConfig & {
+    workflowMapping?: WorkflowStateConfig;
 };
-export type WorkflowMappingConfig = {
+export type StateRole = "active" | "wait" | "terminal";
+export type StateMapping = {
+    role: StateRole;
+    goal?: string;
+};
+export type WorkflowStateConfig = {
     stateFieldName: string;
-    columnRoles: Record<string, ColumnRole>;
-    humanReviewMode: HumanReviewMode;
+    mappings: Record<string, StateMapping>;
     lifecycle: WorkflowLifecycleConfig;
 };
-export type ColumnRole = "trigger" | "working" | "human-review" | "done" | "ignored";
-export type HumanReviewMode = "plan-and-pr" | "plan-only" | "pr-only" | "none";
 export declare function resolveConfigDir(override?: string): string;
 export declare function configFilePath(configDir: string): string;
-export declare function workspaceConfigDir(configDir: string, workspaceId: string): string;
-export declare function workspaceConfigPath(configDir: string, workspaceId: string): string;
-export declare function workflowMappingPath(configDir: string, workspaceId: string): string;
+export declare function tenantConfigDir(configDir: string, tenantId: string): string;
+export declare function tenantConfigPath(configDir: string, tenantId: string): string;
+export declare function workflowMappingPath(configDir: string, tenantId: string): string;
 export declare function daemonPidPath(configDir: string): string;
 export declare function logsDir(configDir: string): string;
 export declare function orchestratorLogPath(configDir: string): string;
 export declare function loadGlobalConfig(configDir: string): Promise<CliGlobalConfig | null>;
 export declare function saveGlobalConfig(configDir: string, config: CliGlobalConfig): Promise<void>;
-export declare function loadWorkspaceConfig(configDir: string, workspaceId: string): Promise<CliWorkspaceConfig | null>;
-export declare function saveWorkspaceConfig(configDir: string, workspaceId: string, config: CliWorkspaceConfig): Promise<void>;
-export declare function loadWorkflowMapping(configDir: string, workspaceId: string): Promise<WorkflowMappingConfig | null>;
-export declare function saveWorkflowMapping(configDir: string, workspaceId: string, mapping: WorkflowMappingConfig): Promise<void>;
-export declare function loadActiveWorkspaceConfig(configDir: string): Promise<CliWorkspaceConfig | null>;
+export declare function loadTenantConfig(configDir: string, tenantId: string): Promise<CliTenantConfig | null>;
+export declare function saveTenantConfig(configDir: string, tenantId: string, config: CliTenantConfig): Promise<void>;
+export declare function loadWorkflowMapping(configDir: string, tenantId: string): Promise<WorkflowStateConfig | null>;
+export declare function saveWorkflowMapping(configDir: string, tenantId: string, mapping: WorkflowStateConfig): Promise<void>;
+export declare function loadActiveTenantConfig(configDir: string): Promise<CliTenantConfig | null>;