@gh-symphony/cli 0.0.6 → 0.0.8

package/dist/commands/status.js

@@ -1,9 +1,11 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { resolveRuntimeRoot, resolveTenantConfig, syncTenantToRuntime, } from "../orchestrator-runtime.js";
+import { resolveRuntimeRoot, syncProjectToRuntime, } from "../orchestrator-runtime.js";
+import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.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";
 const WATCH_REFRESH_TIMEOUT_MS = 1_500;
 function healthIcon(health) {
@@ -107,22 +109,35 @@ function renderLegacyStatus(snapshot, noColor) {
     return lines.join("\n");
 }
 function parseStatusArgs(args) {
-    const parsed = { watch: false };
+    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;
+            continue;
         }
-        if (arg === "--tenant" || arg === "--tenant-id") {
-            parsed.tenantId = args[i + 1];
+        if (arg === "--project" || arg === "--project-id") {
+            const value = args[i + 1];
+            if (!value || value.startsWith("-")) {
+                parsed.error = `Option '${arg}' argument missing`;
+                return parsed;
+            }
+            parsed.projectId = value;
             i += 1;
+            continue;
+        }
+        if (arg?.startsWith("-")) {
+            parsed.error = `Unknown option '${arg}'`;
+            return parsed;
         }
     }
     return parsed;
 }
-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 +145,49 @@ 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");
-        process.exitCode = 1;
+    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 resolveManagedProjectConfig({
+        configDir: options.configDir,
+        requestedProjectId: parsed.projectId,
+    });
+    if (!projectConfig) {
+        handleMissingManagedProjectConfig();
         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 +221,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,59 @@
 import { readFile, rm } from "node:fs/promises";
-import { daemonPidPath } from "../config.js";
+import { daemonPidPath, orchestratorPortPath } from "../config.js";
+import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.js";
 function parseStopArgs(args) {
-    return { force: args.includes("--force") };
+    const parsed = {
+        force: false,
+    };
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--force") {
+            parsed.force = true;
+            continue;
+        }
+        if (arg === "--project" || arg === "--project-id") {
+            const value = args[i + 1];
+            if (!value || value.startsWith("-")) {
+                parsed.error = `Option '${arg}' argument missing`;
+                return parsed;
+            }
+            parsed.projectId = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("-")) {
+            parsed.error = `Unknown option '${arg}'`;
+            return parsed;
+        }
+    }
+    return parsed;
 }
 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;
+    }
+    const resolvedForce = parsed.force;
+    const projectConfig = await resolveManagedProjectConfig({
+        configDir: options.configDir,
+        requestedProjectId: parsed.projectId,
+    });
+    if (!projectConfig) {
+        handleMissingManagedProjectConfig();
+        return;
+    }
+    const resolvedProjectId = projectConfig.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 +68,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 +84,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/completion.d.ts

@@ -0,0 +1 @@
+export declare function renderCompletionScript(shell: "bash" | "zsh" | "fish"): string;

package/dist/completion.js

@@ -0,0 +1,204 @@
+const TOP_LEVEL_COMMANDS = [
+    "init",
+    "start",
+    "stop",
+    "status",
+    "run",
+    "recover",
+    "logs",
+    "project",
+    "repo",
+    "config",
+    "completion",
+    "help",
+    "version",
+];
+const GLOBAL_OPTIONS = [
+    "--config",
+    "--config-dir",
+    "--verbose",
+    "-v",
+    "--json",
+    "--no-color",
+    "--help",
+    "-h",
+    "--version",
+    "-V",
+];
+const GLOBAL_OPTIONS_WITH_VALUES = ["--config", "--config-dir"];
+const COMMAND_OPTIONS = {
+    completion: ["bash", "zsh", "fish"],
+    start: ["--project-id", "--project", "--daemon", "-d", ...GLOBAL_OPTIONS],
+    stop: ["--project-id", "--project", "--force", ...GLOBAL_OPTIONS],
+    status: ["--project-id", "--project", "--watch", "-w", ...GLOBAL_OPTIONS],
+    run: ["--project-id", "--project", "--watch", "-w", ...GLOBAL_OPTIONS],
+    recover: ["--project-id", "--project", "--dry-run", ...GLOBAL_OPTIONS],
+    logs: [
+        "--project-id",
+        "--project",
+        "--follow",
+        "-f",
+        "--issue",
+        "--run",
+        "--level",
+        ...GLOBAL_OPTIONS,
+    ],
+    project: ["add", "list", "remove", "start", "stop", "switch", "status"],
+    "project:add": [
+        "--non-interactive",
+        "--project",
+        "--workspace-dir",
+        "--assigned-only",
+        ...GLOBAL_OPTIONS,
+    ],
+    "project:list": [...GLOBAL_OPTIONS],
+    "project:remove": [...GLOBAL_OPTIONS],
+    "project:start": [
+        "--project-id",
+        "--project",
+        "--daemon",
+        "-d",
+        ...GLOBAL_OPTIONS,
+    ],
+    "project:stop": ["--project-id", "--project", "--force", ...GLOBAL_OPTIONS],
+    "project:switch": [...GLOBAL_OPTIONS],
+    "project:status": [
+        "--project-id",
+        "--project",
+        "--watch",
+        "-w",
+        ...GLOBAL_OPTIONS,
+    ],
+    repo: ["list", "add", "remove"],
+    "repo:list": [...GLOBAL_OPTIONS],
+    "repo:add": [...GLOBAL_OPTIONS],
+    "repo:remove": [...GLOBAL_OPTIONS],
+    config: ["show", "set", "edit"],
+    "config:show": [...GLOBAL_OPTIONS],
+    "config:set": [...GLOBAL_OPTIONS],
+    "config:edit": [...GLOBAL_OPTIONS],
+};
+function quoteWords(values) {
+    return values.join(" ");
+}
+function renderBashCasePatterns() {
+    return Object.entries(COMMAND_OPTIONS)
+        .map(([key, values]) => {
+        const [command, subcommand] = key.split(":");
+        if (!subcommand) {
+            if (command === "completion") {
+                return `    completion)\n      COMPREPLY=( $(compgen -W "${quoteWords(values)}" -- "$cur") )\n      return\n      ;;`;
+            }
+            if (command === "project" ||
+                command === "repo" ||
+                command === "config") {
+                return `    ${command})\n      COMPREPLY=( $(compgen -W "${quoteWords(values)}" -- "$cur") )\n      return\n      ;;`;
+            }
+            return `    ${command})\n      COMPREPLY=( $(compgen -W "${quoteWords(values)}" -- "$cur") )\n      return\n      ;;`;
+        }
+        return `    ${command}:${subcommand})\n      COMPREPLY=( $(compgen -W "${quoteWords(values)}" -- "$cur") )\n      return\n      ;;`;
+    })
+        .join("\n");
+}
+function renderFishLines() {
+    const lines = GLOBAL_OPTIONS.map((option) => option.startsWith("--")
+        ? `complete -c gh-symphony -f -l ${option.slice(2)}`
+        : `complete -c gh-symphony -f -s ${option.slice(1)}`);
+    for (const command of TOP_LEVEL_COMMANDS) {
+        lines.push(`complete -c gh-symphony -f -n '__fish_use_subcommand' -a '${command}'`);
+    }
+    for (const subcommand of COMMAND_OPTIONS.project ?? []) {
+        lines.push(`complete -c gh-symphony -f -n '__fish_seen_subcommand_from project' -a '${subcommand}'`);
+    }
+    for (const subcommand of COMMAND_OPTIONS.repo ?? []) {
+        lines.push(`complete -c gh-symphony -f -n '__fish_seen_subcommand_from repo' -a '${subcommand}'`);
+    }
+    for (const subcommand of COMMAND_OPTIONS.config ?? []) {
+        lines.push(`complete -c gh-symphony -f -n '__fish_seen_subcommand_from config' -a '${subcommand}'`);
+    }
+    for (const shell of COMMAND_OPTIONS.completion ?? []) {
+        lines.push(`complete -c gh-symphony -f -n '__fish_seen_subcommand_from completion' -a '${shell}'`);
+    }
+    return lines.join("\n");
+}
+export function renderCompletionScript(shell) {
+    if (shell === "fish") {
+        return `${renderFishLines()}\n`;
+    }
+    const bashFunction = `# shellcheck shell=bash
+_gh_symphony_find_context() {
+  GH_SYMPHONY_COMMAND=""
+  GH_SYMPHONY_SUBCOMMAND=""
+
+  local idx=1
+  local token=""
+  local expects_value=0
+
+  while (( idx < COMP_CWORD )); do
+    token="\${COMP_WORDS[idx]}"
+
+    if (( expects_value )); then
+      expects_value=0
+      (( idx++ ))
+      continue
+    fi
+
+    case "\${token}" in
+      ${GLOBAL_OPTIONS_WITH_VALUES.map((option) => `${option}`).join("|")})
+        expects_value=1
+        ;;
+      ${GLOBAL_OPTIONS_WITH_VALUES.map((option) => `${option}=*`).join("|")})
+        ;;
+      ${GLOBAL_OPTIONS.filter((option) => !GLOBAL_OPTIONS_WITH_VALUES.includes(option)).join("|")})
+        ;;
+      -*)
+        ;;
+      *)
+        if [[ -z "\${GH_SYMPHONY_COMMAND}" ]]; then
+          GH_SYMPHONY_COMMAND="\${token}"
+        elif [[ -z "\${GH_SYMPHONY_SUBCOMMAND}" ]]; then
+          GH_SYMPHONY_SUBCOMMAND="\${token}"
+        fi
+        ;;
+    esac
+
+    (( idx++ ))
+  done
+}
+
+_gh_symphony_completion() {
+  local cur prev path
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev=""
+  if (( COMP_CWORD > 0 )); then
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  fi
+
+  _gh_symphony_find_context
+  path="\${GH_SYMPHONY_COMMAND}"
+
+  if [[ -z "\${path}" ]]; then
+    COMPREPLY=( $(compgen -W "${quoteWords(TOP_LEVEL_COMMANDS)} ${quoteWords(GLOBAL_OPTIONS)}" -- "$cur") )
+    return
+  fi
+
+  if [[ "\${path}" == "project" || "\${path}" == "repo" || "\${path}" == "config" || "\${path}" == "completion" ]]; then
+    if [[ -n "\${GH_SYMPHONY_SUBCOMMAND}" ]]; then
+      path="\${path}:\${GH_SYMPHONY_SUBCOMMAND}"
+    fi
+  fi
+
+  case "\${path}" in
+${renderBashCasePatterns()}
+  esac
+}
+`;
+    if (shell === "zsh") {
+        return `autoload -Uz compinit && compinit
+autoload -U +X bashcompinit && bashcompinit
+${bashFunction}complete -F _gh_symphony_completion gh-symphony
+`;
+    }
+    return `${bashFunction}complete -F _gh_symphony_completion gh-symphony
+`;
+}

package/dist/config.d.ts

@@ -1,19 +1,21 @@
-import type { OrchestratorTenantConfig } 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;
     };
 };
 export type StateRole = "active" | "wait" | "terminal";
@@ -23,13 +25,13 @@ export type StateMapping = {
 };
 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 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 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,46 +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 daemonPidPath(configDir) {
-    return join(configDir, DAEMON_PID_FILE);
+export function daemonPidPath(configDir, projectId) {
+    return join(projectConfigDir(configDir, projectId), DAEMON_PID_FILE);
 }
-export function logsDir(configDir) {
-    return join(configDir, LOGS_DIR);
+export function orchestratorLogPath(configDir, projectId) {
+    return join(projectConfigDir(configDir, projectId), ORCHESTRATOR_LOG_FILE);
 }
-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 loadProjectConfig(configDir, projectId) {
+    return readJsonFile(projectConfigPath(configDir, projectId));
 }
-export async function saveTenantConfig(configDir, tenantId, config) {
-    await writeJsonFile(tenantConfigPath(configDir, tenantId), config);
+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.d.ts

@@ -5,10 +5,5 @@ export type GlobalOptions = {
     json: boolean;
     noColor: boolean;
 };
-export declare function parseGlobalOptions(argv: string[]): {
-    options: GlobalOptions;
-    command: string;
-    args: string[];
-};
 export type CommandHandler = (args: string[], options: GlobalOptions) => Promise<void>;
 export declare function runCli(argv: string[]): Promise<void>;