@gh-symphony/cli 0.0.5 → 0.0.7

package/dist/commands/status.js

@@ -1,10 +1,12 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { resolveRuntimeRoot, resolveTenantConfig, syncTenantToRuntime, } from "../orchestrator-runtime.js";
+import { resolveRuntimeRoot, resolveProjectConfig, syncProjectToRuntime, } 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";
+import { resolveProjectOrchestratorStatusBaseUrl } from "../orchestrator-status-endpoint.js";
 import { requestOrchestratorRefresh } from "./status-refresh.js";
+import { parseCliArgs } from "./parse-cli-args.js";
 const WATCH_REFRESH_TIMEOUT_MS = 1_500;
 function healthIcon(health) {
     switch (health) {
@@ -107,22 +109,22 @@ function renderLegacyStatus(snapshot, noColor) {
     return lines.join("\n");
 }
 function parseStatusArgs(args) {
-    const parsed = { watch: false };
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        if (arg === "--watch" || arg === "-w") {
-            parsed.watch = true;
-        }
-        if (arg === "--tenant" || arg === "--tenant-id") {
-            parsed.tenantId = args[i + 1];
-            i += 1;
-        }
-    }
-    return parsed;
+    const parsed = parseCliArgs(args, {
+        watch: { type: "boolean", short: "w" },
+        project: { type: "string" },
+        "project-id": { type: "string" },
+    });
+    if ("error" in parsed) {
+        return { watch: false, error: parsed.error };
+    }
+    return {
+        watch: Boolean(parsed.values.watch),
+        projectId: (parsed.values["project-id"] ?? parsed.values.project),
+    };
 }
-async function readStatusSnapshot(runtimeRoot, tenantId) {
+async function readStatusSnapshot(runtimeRoot, projectId) {
     try {
-        const statusPath = join(runtimeRoot, "orchestrator", "tenants", tenantId, "status.json");
+        const statusPath = join(runtimeRoot, "orchestrator", "projects", projectId, "status.json");
         const content = await readFile(statusPath, "utf-8");
         return JSON.parse(content);
     }
@@ -130,56 +132,47 @@ async function readStatusSnapshot(runtimeRoot, tenantId) {
         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 tenantConfig = await resolveTenantConfig(options.configDir, parsed.tenantId);
-    if (!tenantConfig) {
-        process.stderr.write("No tenant configured. Run 'gh-symphony init' first.\n");
+    if (parsed.error) {
+        process.stderr.write(`${parsed.error}\n`);
+        process.stderr.write("Usage: gh-symphony status [--project-id <project-id>] [--watch]\n");
+        process.exitCode = 2;
+        return;
+    }
+    const projectConfig = await resolveProjectConfig(options.configDir, parsed.projectId);
+    if (!projectConfig) {
+        process.stderr.write("No project configured. Run 'gh-symphony project add' first.\n");
         process.exitCode = 1;
         return;
     }
     const runtimeRoot = resolveRuntimeRoot(options.configDir);
-    const tenantId = tenantConfig.tenantId;
-    await syncTenantToRuntime(options.configDir, tenantConfig);
+    const projectId = projectConfig.projectId;
+    await syncProjectToRuntime(options.configDir, projectConfig);
     if (parsed.watch) {
         const isTTY = process.stdout.isTTY === true;
         let terminalWidth = process.stdout.columns ?? 115;
         let runPromise = null;
         const run = async () => {
+            const baseUrl = await resolveProjectOrchestratorStatusBaseUrl({
+                configDir: options.configDir,
+                projectId,
+            });
             await requestOrchestratorRefresh({
+                baseUrl,
                 timeoutMs: WATCH_REFRESH_TIMEOUT_MS,
             });
-            const snapshots = await readAllStatusSnapshots(runtimeRoot);
+            const snapshot = await readStatusSnapshot(runtimeRoot, projectId);
             if (options.json || !isTTY) {
-                process.stdout.write(JSON.stringify(snapshots, null, 2) + "\n");
+                process.stdout.write(JSON.stringify(snapshot, null, 2) + "\n");
             }
             else {
+                if (!snapshot) {
+                    process.stdout.write(clearScreen() + "Unable to read status snapshot.\n");
+                    return;
+                }
                 process.stdout.write(clearScreen() +
-                    renderDashboard(snapshots, {
+                    renderDashboard([snapshot], {
                         terminalWidth,
                         noColor: options.noColor,
                     }) +
@@ -213,7 +206,7 @@ const handler = async (args, options) => {
         await new Promise(() => { });
     }
     // Single status query
-    const snapshot = await readStatusSnapshot(runtimeRoot, tenantId);
+    const snapshot = await readStatusSnapshot(runtimeRoot, projectId);
     if (snapshot) {
         if (options.json) {
             process.stdout.write(JSON.stringify(snapshot, null, 2) + "\n");

package/dist/commands/stop.js

@@ -1,17 +1,43 @@
 import { readFile, rm } from "node:fs/promises";
-import { daemonPidPath } from "../config.js";
+import { daemonPidPath, orchestratorPortPath } from "../config.js";
+import { parseCliArgs } from "./parse-cli-args.js";
 function parseStopArgs(args) {
-    return { force: args.includes("--force") };
+    const parsed = parseCliArgs(args, {
+        force: { type: "boolean" },
+        project: { type: "string" },
+        "project-id": { type: "string" },
+    });
+    if ("error" in parsed) {
+        return { force: false, error: parsed.error };
+    }
+    return {
+        force: Boolean(parsed.values.force),
+        projectId: (parsed.values["project-id"] ?? parsed.values.project),
+    };
 }
 const handler = async (args, options) => {
-    const { force } = parseStopArgs(args);
-    const pidPath = daemonPidPath(options.configDir);
+    const parsed = parseStopArgs(args);
+    if (parsed.error) {
+        process.stderr.write(`${parsed.error}\n`);
+        process.stderr.write("Usage: gh-symphony stop --project-id <project-id> [--force]\n");
+        process.exitCode = 2;
+        return;
+    }
+    if (!parsed.projectId) {
+        process.stderr.write("Usage: gh-symphony stop --project-id <project-id> [--force]\n");
+        process.exitCode = 2;
+        return;
+    }
+    const resolvedForce = parsed.force;
+    const resolvedProjectId = parsed.projectId;
+    const pidPath = daemonPidPath(options.configDir, resolvedProjectId);
+    const portPath = orchestratorPortPath(options.configDir, resolvedProjectId);
     let pidStr;
     try {
         pidStr = await readFile(pidPath, "utf8");
     }
     catch {
-        process.stderr.write("No running daemon found (PID file missing).\n");
+        process.stderr.write(`No running daemon found for project "${resolvedProjectId}" (PID file missing).\n`);
         process.exitCode = 1;
         return;
     }
@@ -26,11 +52,12 @@ const handler = async (args, options) => {
         process.kill(pid, 0);
     }
     catch {
-        process.stdout.write(`Daemon (PID ${pid}) is not running. Cleaning up PID file.\n`);
+        process.stdout.write(`Daemon for project "${resolvedProjectId}" (PID ${pid}) is not running. Cleaning up PID file.\n`);
         await rm(pidPath, { force: true });
+        await rm(portPath, { force: true });
         return;
     }
-    const signal = force ? "SIGKILL" : "SIGTERM";
+    const signal = resolvedForce ? "SIGKILL" : "SIGTERM";
     try {
         process.kill(pid, signal);
         process.stdout.write(`Sent ${signal} to orchestrator (PID ${pid}).\n`);
@@ -41,6 +68,9 @@ const handler = async (args, options) => {
         return;
     }
     await rm(pidPath, { force: true });
+    if (resolvedForce) {
+        await rm(portPath, { force: true });
+    }
     process.stdout.write("Daemon stopped.\n");
 };
 export default handler;

package/dist/commands/tenant.js

@@ -1,7 +1,6 @@
 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 ───────────────────────────────────────────────────────
@@ -29,8 +28,8 @@ function parseTenantAddFlags(args) {
                 flags.project = next;
                 i += 1;
                 break;
-            case "--runtime":
-                flags.runtime = next;
+            case "--workspace-dir":
+                flags.workspaceDir = next;
                 i += 1;
                 break;
             case "--assigned-only":
@@ -115,37 +114,13 @@ async function tenantAddNonInteractive(flags, options) {
         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);
+    const workspaceDir = flags.workspaceDir ?? `${options.configDir}/workspaces`;
     await writeConfig(options.configDir, {
         tenantId,
         project,
         repos: project.linkedRepositories,
-        statusField,
-        mappings,
-        runtime,
+        workspaceDir,
         assignedOnly: flags.assignedOnly,
     });
     if (options.json) {
@@ -253,7 +228,7 @@ async function tenantAddInteractive(options) {
         process.exitCode = 1;
         return;
     }
-    // ── Step 3: Repository selection ────────────────────────────────────────────
+    // ── Step 2: 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;
@@ -267,60 +242,28 @@ async function tenantAddInteractive(options) {
         })),
         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: Assignment filter ────────────────────────────────────────────────
+    // ── Step 3: Assignment filter ────────────────────────────────────────────────
     const assignedOnly = await abortIfCancelled(p.confirm({
-        message: `Step 3/4 — Only process issues assigned to the authenticated GitHub user?`,
+        message: "Step 3/4 — Only process issues assigned to the authenticated GitHub user?",
         initialValue: false,
     }));
-    // ── Step 5: Runtime selection ────────────────────────────────────────────────
-    const runtime = await abortIfCancelled(p.select({
-        message: "Step 4/4 — Select AI runtime:",
-        options: [
-            { value: "codex", label: "OpenAI Codex", hint: "recommended" },
-            { value: "claude-code", label: "Claude Code" },
-            { value: "custom", label: "Custom command" },
-        ],
+    const workspaceDir = await abortIfCancelled(p.text({
+        message: "Step 4/4 — Workspace root directory:",
+        placeholder: `${options.configDir}/workspaces`,
+        defaultValue: `${options.configDir}/workspaces`,
+        validate(value) {
+            return value.trim().length > 0
+                ? undefined
+                : "Workspace directory is required.";
+        },
     }));
-    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(", ")}`,
         `Assigned:   ${assignedOnly ? `Only issues assigned to ${login}` : "All project issues"}`,
-        `Runtime:    ${runtime}`,
-        `Active:     ${lifecycleConfig.activeStates.join(", ")}`,
-        `Terminal:   ${lifecycleConfig.terminalStates.join(", ")}`,
+        `Workspace:  ${workspaceDir}`,
     ].join("\n"), "Configuration Summary");
     const confirmed = await abortIfCancelled(p.confirm({ message: "Apply this configuration?" }));
     if (!confirmed) {
@@ -337,14 +280,7 @@ async function tenantAddInteractive(options) {
             tenantId,
             project: projectDetail,
             repos: selectedRepos,
-            statusField: {
-                id: statusField.id,
-                name: statusField.name,
-                options: statusField.options,
-            },
-            mappings,
-            runtime,
-            agentCommand,
+            workspaceDir,
             assignedOnly,
         });
         s6.stop("Configuration saved.");
@@ -355,7 +291,6 @@ async function tenantAddInteractive(options) {
         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 ───────────────────────────────────────────────────────────────

package/dist/config.d.ts

@@ -1,44 +1,37 @@
-import type { OrchestratorTenantConfig, WorkflowLifecycleConfig } from "@gh-symphony/core";
+import type { OrchestratorProjectConfig } 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 declare const ORCHESTRATOR_LOG_FILE = "orchestrator.log";
+export declare const ORCHESTRATOR_PORT_FILE = "port";
 export type CliGlobalConfig = {
-    activeTenant: string | null;
-    tenants: string[];
+    activeProject: string | null;
+    projects: string[];
 };
-export type CliTenantTrackerSettings = Record<string, string | boolean> & {
+export type CliProjectTrackerSettings = Record<string, string | boolean> & {
     projectId?: string;
     assignedOnly?: boolean;
 };
-export type CliTenantConfig = Omit<OrchestratorTenantConfig, "tracker"> & {
-    tracker: Omit<OrchestratorTenantConfig["tracker"], "settings"> & {
-        settings?: CliTenantTrackerSettings;
+export type CliProjectConfig = Omit<OrchestratorProjectConfig, "tracker"> & {
+    displayName?: string;
+    tracker: Omit<OrchestratorProjectConfig["tracker"], "settings"> & {
+        settings?: CliProjectTrackerSettings;
     };
-    workflowMapping?: WorkflowStateConfig;
 };
 export type StateRole = "active" | "wait" | "terminal";
 export type StateMapping = {
     role: StateRole;
     goal?: string;
 };
-export type WorkflowStateConfig = {
-    stateFieldName: string;
-    mappings: Record<string, StateMapping>;
-    lifecycle: WorkflowLifecycleConfig;
-};
 export declare function resolveConfigDir(override?: string): string;
 export declare function configFilePath(configDir: 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 projectConfigDir(configDir: string, projectId: string): string;
+export declare function projectConfigPath(configDir: string, projectId: string): string;
+export declare function daemonPidPath(configDir: string, projectId: string): string;
+export declare function orchestratorLogPath(configDir: string, projectId: string): string;
+export declare function orchestratorPortPath(configDir: string, projectId: string): string;
 export declare function loadGlobalConfig(configDir: string): Promise<CliGlobalConfig | null>;
 export declare function saveGlobalConfig(configDir: string, config: CliGlobalConfig): Promise<void>;
-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>;
+export declare function loadProjectConfig(configDir: string, projectId: string): Promise<CliProjectConfig | null>;
+export declare function saveProjectConfig(configDir: string, projectId: string, config: CliProjectConfig): Promise<void>;
+export declare function loadActiveProjectConfig(configDir: string): Promise<CliProjectConfig | null>;

package/dist/config.js

@@ -4,55 +4,56 @@ import { homedir } from "node:os";
 export const DEFAULT_CONFIG_DIR = join(homedir(), ".gh-symphony");
 export const CONFIG_FILE = "config.json";
 export const DAEMON_PID_FILE = "daemon.pid";
-export const LOGS_DIR = "logs";
+export const ORCHESTRATOR_LOG_FILE = "orchestrator.log";
+export const ORCHESTRATOR_PORT_FILE = "port";
 export function resolveConfigDir(override) {
     return override ?? process.env.GH_SYMPHONY_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
 }
 export function configFilePath(configDir) {
     return join(configDir, CONFIG_FILE);
 }
-export function tenantConfigDir(configDir, tenantId) {
-    return join(configDir, "tenants", tenantId);
+export function projectConfigDir(configDir, projectId) {
+    return join(configDir, "projects", projectId);
 }
-export function tenantConfigPath(configDir, tenantId) {
-    return join(tenantConfigDir(configDir, tenantId), "tenant.json");
+export function projectConfigPath(configDir, projectId) {
+    return join(projectConfigDir(configDir, projectId), "project.json");
 }
-export function workflowMappingPath(configDir, tenantId) {
-    return join(tenantConfigDir(configDir, tenantId), "workflow-mapping.json");
+export function daemonPidPath(configDir, projectId) {
+    return join(projectConfigDir(configDir, projectId), DAEMON_PID_FILE);
 }
-export function daemonPidPath(configDir) {
-    return join(configDir, DAEMON_PID_FILE);
+export function orchestratorLogPath(configDir, projectId) {
+    return join(projectConfigDir(configDir, projectId), ORCHESTRATOR_LOG_FILE);
 }
-export function logsDir(configDir) {
-    return join(configDir, LOGS_DIR);
-}
-export function orchestratorLogPath(configDir) {
-    return join(logsDir(configDir), "orchestrator.log");
+export function orchestratorPortPath(configDir, projectId) {
+    return join(projectConfigDir(configDir, projectId), ORCHESTRATOR_PORT_FILE);
 }
 export async function loadGlobalConfig(configDir) {
-    return readJsonFile(configFilePath(configDir));
+    const raw = await readJsonFile(configFilePath(configDir));
+    if (!raw) {
+        return null;
+    }
+    return {
+        activeProject: typeof raw.activeProject === "string" ? raw.activeProject : null,
+        projects: Array.isArray(raw.projects)
+            ? raw.projects.filter((projectId) => typeof projectId === "string")
+            : [],
+    };
 }
 export async function saveGlobalConfig(configDir, config) {
     await writeJsonFile(configFilePath(configDir), config);
 }
-export async function loadTenantConfig(configDir, tenantId) {
-    return readJsonFile(tenantConfigPath(configDir, tenantId));
-}
-export async function saveTenantConfig(configDir, tenantId, config) {
-    await writeJsonFile(tenantConfigPath(configDir, tenantId), config);
-}
-export async function loadWorkflowMapping(configDir, tenantId) {
-    return readJsonFile(workflowMappingPath(configDir, tenantId));
+export async function loadProjectConfig(configDir, projectId) {
+    return readJsonFile(projectConfigPath(configDir, projectId));
 }
-export async function saveWorkflowMapping(configDir, tenantId, mapping) {
-    await writeJsonFile(workflowMappingPath(configDir, tenantId), mapping);
+export async function saveProjectConfig(configDir, projectId, config) {
+    await writeJsonFile(projectConfigPath(configDir, projectId), config);
 }
-export async function loadActiveTenantConfig(configDir) {
+export async function loadActiveProjectConfig(configDir) {
     const global = await loadGlobalConfig(configDir);
-    if (!global?.activeTenant) {
+    if (!global?.activeProject) {
         return null;
     }
-    return loadTenantConfig(configDir, global.activeTenant);
+    return loadProjectConfig(configDir, global.activeProject);
 }
 async function readJsonFile(path) {
     try {

package/dist/dashboard/renderer.d.ts

@@ -1,4 +1,4 @@
-import type { TenantStatusSnapshot } from "@gh-symphony/core";
+import type { ProjectStatusSnapshot } from "@gh-symphony/core";
 export type DashboardOptions = {
     terminalWidth: number;
     noColor: boolean;
@@ -6,4 +6,4 @@ export type DashboardOptions = {
     /** Override Date.now() for deterministic testing */
     now?: number;
 };
-export declare function renderDashboard(snapshots: TenantStatusSnapshot[], options: DashboardOptions): string;
+export declare function renderDashboard(snapshots: ProjectStatusSnapshot[], options: DashboardOptions): string;

package/dist/dashboard/renderer.js

@@ -2,7 +2,7 @@
 import { bold, dim, green, red, yellow, cyan, magenta, blue, stripAnsi, } from "../ansi.js";
 // ── Column widths (from Elixir spec) ─────────────────────────────────────────
 const COL_ID = 24;
-const COL_STAGE = 14;
+const COL_STATUS = 14;
 const COL_PID = 8;
 const COL_AGE_TURN = 12;
 const COL_TOKENS = 10;
@@ -81,7 +81,7 @@ const COL_SEPARATORS = 6;
 function eventColWidth(termWidth) {
     const fixed = 2 +
         COL_ID_HEADER +
-        COL_STAGE +
+        COL_STATUS +
         COL_PID +
         COL_AGE_TURN +
         COL_TOKENS +
@@ -140,7 +140,7 @@ function buildSummaryLines(snapshots, options, c) {
 function tableHeaderRow(c) {
     const cols = [
         pad("ID", COL_ID_HEADER),
-        pad("STAGE", COL_STAGE),
+        pad("STATUS", COL_STATUS),
         pad("PID", COL_PID),
         pad("AGE/TURN", COL_AGE_TURN),
         pad("TOKENS", COL_TOKENS),
@@ -152,7 +152,7 @@ function tableHeaderRow(c) {
 function activeRunRow(run, now, evtWidth, c) {
     const dot = statusDot(run, c);
     const id = pad(run.issueIdentifier, COL_ID);
-    const stage = pad(run.issueState || "\u2014", COL_STAGE);
+    const status = pad(run.issueState ?? run.executionPhase ?? "\u2014", COL_STATUS);
     const pid = pad(run.processId != null ? String(run.processId) : "\u2014", COL_PID);
     const age = fmtAge(run.startedAt, now);
     const turn = run.turnCount ?? 0;
@@ -161,7 +161,7 @@ function activeRunRow(run, now, evtWidth, c) {
     const sessionId = run.runtimeSession?.sessionId ?? run.runtimeSession?.threadId ?? null;
     const session = pad(compactSessionId(sessionId), COL_SESSION);
     const event = pad(run.lastEvent ?? "\u2014", evtWidth);
-    const columns = [id, stage, pid, ageTurn, tokens, session, event].join(" ");
+    const columns = [id, status, pid, ageTurn, tokens, session, event].join(" ");
     return `  ${dot} ${columns}`;
 }
 function retryRow(entry, snapshot, now, c) {

package/dist/index.js

@@ -49,7 +49,6 @@ const COMMANDS = {
     logs: () => import("./commands/logs.js"),
     project: () => import("./commands/project.js"),
     repo: () => import("./commands/repo.js"),
-    tenant: () => import("./commands/tenant.js"),
     config: () => import("./commands/config-cmd.js"),
     help: () => import("./commands/help.js"),
     version: () => import("./commands/version.js"),

package/dist/orchestrator-runtime.d.ts

@@ -1,5 +1,5 @@
-import { type CliTenantConfig } from "./config.js";
+import { type CliProjectConfig } from "./config.js";
 export declare function resolveRuntimeRoot(configDir: string): string;
-export declare function resolveTenantConfig(configDir: string, requestedTenantId?: string): Promise<CliTenantConfig | null>;
-export declare function orchestratorTenantConfigPath(runtimeRoot: string, tenantId: string): string;
-export declare function syncTenantToRuntime(configDir: string, tenantConfig: CliTenantConfig): Promise<string>;
+export declare function resolveProjectConfig(configDir: string, requestedProjectId?: string): Promise<CliProjectConfig | null>;
+export declare function orchestratorProjectConfigPath(runtimeRoot: string, projectId: string): string;
+export declare function syncProjectToRuntime(configDir: string, projectConfig: CliProjectConfig): Promise<string>;