@gh-symphony/cli 0.0.4 → 0.0.6

package/README.md

@@ -61,8 +61,8 @@ The interactive wizard will:
 1. Authenticate via `gh` CLI
 2. Let you select a **GitHub Project**
 3. Select repositories to orchestrate
-4. Auto-detect workflow column mappings
-5. Choose an AI runtime (Codex / Claude Code / custom)
+4. Optionally limit processing to issues assigned to the authenticated user
+5. Configure the workspace root directory
 6. Write tenant configuration to `~/.gh-symphony/`
 
 ### Tenant Management

package/dist/commands/help.js

@@ -41,7 +41,7 @@ Global Options:
 
 Examples:
   gh-symphony tenant add              # Add a tenant (interactive)
-  gh-symphony tenant add --non-interactive --project <id>
+  gh-symphony tenant add --non-interactive --project <id> --workspace-dir <path>
   gh-symphony tenant list             # List all tenants
   gh-symphony tenant remove <id>      # Remove a tenant
   gh-symphony start                   # Start orchestrator

package/dist/commands/init.d.ts

@@ -1,6 +1,5 @@
 import type { GlobalOptions } from "../index.js";
 import { type ProjectDetail, type ProjectStatusField, type LinkedRepository } from "../github/client.js";
-import { type StateMapping } from "../config.js";
 export declare function abortIfCancelled<T>(input: T | Promise<T>): Promise<Exclude<T, symbol>>;
 declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
 export default handler;
@@ -27,22 +26,9 @@ type WriteConfigInput = {
     tenantId: string;
     project: ProjectDetail;
     repos: LinkedRepository[];
-    statusField: {
-        id: string;
-        name: string;
-        options: Array<{
-            id: string;
-            name: string;
-            color?: string | null;
-        }>;
-    };
-    mappings: Record<string, StateMapping>;
-    runtime: string;
-    agentCommand?: string;
-    workerCommand?: string;
-    pollIntervalMs?: number;
-    concurrency?: number;
+    workspaceDir: string;
     maxAttempts?: number;
+    assignedOnly?: boolean;
 };
 export declare function writeConfig(configDir: string, input: WriteConfigInput): Promise<void>;
 export declare function generateTenantId(projectTitle: string, uniqueKey: string): string;

package/dist/commands/init.js

@@ -2,11 +2,10 @@ import * as p from "@clack/prompts";
 import { createHash } from "node:crypto";
 import { mkdir, 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, saveGlobalConfig, saveTenantConfig, saveWorkflowMapping, } from "../config.js";
+import { loadGlobalConfig, saveGlobalConfig, saveTenantConfig, } 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";
@@ -436,29 +435,11 @@ async function runInteractiveStandalone(_options) {
         nextSteps: "Run 'gh-symphony tenant add' to register a tenant.",
     });
 }
-function resolveWorkerCommand() {
-    try {
-        const url = import.meta.resolve("@gh-symphony/worker/dist/index.js");
-        return `node ${fileURLToPath(url)}`;
-    }
-    catch {
-        return undefined;
-    }
-}
 export async function writeConfig(configDir, input) {
-    const lifecycleConfig = toWorkflowLifecycleConfig(input.statusField.name, input.mappings);
-    // Save workflow mapping
-    const mappingConfig = {
-        stateFieldName: input.statusField.name,
-        mappings: input.mappings,
-        lifecycle: lifecycleConfig,
-    };
-    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,
+        workspaceDir: input.workspaceDir,
         repositories: input.repos.map((r) => ({
             owner: r.owner,
             name: r.name,
@@ -469,15 +450,9 @@ export async function writeConfig(configDir, input) {
             bindingId: input.project.id,
             settings: {
                 projectId: input.project.id,
+                ...(input.assignedOnly ? { assignedOnly: true } : {}),
             },
         },
-        runtime: {
-            driver: "local",
-            workspaceRuntimeDir: runtimeDir,
-            projectRoot: process.cwd(),
-            workerCommand: input.workerCommand ?? resolveWorkerCommand(),
-        },
-        workflowMapping: mappingConfig,
     });
     // Save/update global config
     const existing = await loadGlobalConfig(configDir);
@@ -489,18 +464,6 @@ export async function writeConfig(configDir, input) {
         ],
     };
     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");
 }
 export function generateTenantId(projectTitle, uniqueKey) {
     const slug = projectTitle

package/dist/commands/start.js

@@ -151,6 +151,9 @@ const handler = async (args, options) => {
                 return snapshot ?? null;
             },
         },
+        onRefresh: async () => {
+            await service.runOnce({ tenantId });
+        },
     });
     logLine(green("\u25B2"), `Starting orchestrator for tenant: ${bold(tenantId)}`);
     logLine(dim("\u00B7"), dim("Press Ctrl+C to stop"));

package/dist/commands/status-refresh.d.ts

@@ -0,0 +1,8 @@
+type RefreshRequestOptions = {
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function resolveOrchestratorStatusBaseUrl(env?: NodeJS.ProcessEnv): string;
+export declare function requestOrchestratorRefresh(options?: RefreshRequestOptions): Promise<boolean>;
+export {};

package/dist/commands/status-refresh.js

@@ -0,0 +1,21 @@
+export function resolveOrchestratorStatusBaseUrl(env = process.env) {
+    const host = env.ORCHESTRATOR_STATUS_HOST ?? "127.0.0.1";
+    const port = env.ORCHESTRATOR_STATUS_PORT ?? "4680";
+    const urlHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+    return `http://${urlHost}:${port}`;
+}
+export async function requestOrchestratorRefresh(options = {}) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    const signal = AbortSignal.timeout(timeoutMs);
+    try {
+        const response = await fetchImpl(`${resolveOrchestratorStatusBaseUrl(options.env)}/api/v1/refresh`, {
+            method: "POST",
+            signal,
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/status.js

@@ -4,6 +4,8 @@ import { resolveRuntimeRoot, resolveTenantConfig, syncTenantToRuntime, } from ".
 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 { requestOrchestratorRefresh } from "./status-refresh.js";
+const WATCH_REFRESH_TIMEOUT_MS = 1_500;
 function healthIcon(health) {
     switch (health) {
         case "idle":
@@ -166,7 +168,11 @@ const handler = async (args, options) => {
     if (parsed.watch) {
         const isTTY = process.stdout.isTTY === true;
         let terminalWidth = process.stdout.columns ?? 115;
+        let runPromise = null;
         const run = async () => {
+            await requestOrchestratorRefresh({
+                timeoutMs: WATCH_REFRESH_TIMEOUT_MS,
+            });
             const snapshots = await readAllStatusSnapshots(runtimeRoot);
             if (options.json || !isTTY) {
                 process.stdout.write(JSON.stringify(snapshots, null, 2) + "\n");
@@ -180,11 +186,20 @@ const handler = async (args, options) => {
                     "\n");
             }
         };
+        const tick = () => {
+            if (runPromise) {
+                return;
+            }
+            runPromise = run().finally(() => {
+                runPromise = null;
+            });
+        };
         if (isTTY) {
             process.stdout.write(hideCursor());
         }
-        await run();
-        const interval = setInterval(() => void run(), 2000);
+        tick();
+        await runPromise;
+        const interval = setInterval(tick, 2000);
         process.on("SIGWINCH", () => {
             terminalWidth = process.stdout.columns ?? terminalWidth;
         });

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 ───────────────────────────────────────────────────────
@@ -17,7 +16,7 @@ function displayScopeError(error, retryCommand) {
     p.note(`gh auth refresh --scopes ${scopeArg}\n\nThen re-run: ${retryCommand}`, "Fix missing scope");
 }
 function parseTenantAddFlags(args) {
-    const flags = { nonInteractive: false };
+    const flags = { nonInteractive: false, assignedOnly: false };
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
         const next = args[i + 1];
@@ -29,10 +28,13 @@ 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":
+                flags.assignedOnly = true;
+                break;
         }
     }
     return flags;
@@ -112,37 +114,14 @@ 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) {
         process.stdout.write(JSON.stringify({ tenantId, status: "created" }) + "\n");
@@ -228,7 +207,7 @@ async function tenantAddInteractive(options) {
         return;
     }
     const selectedProjectId = await abortIfCancelled(p.select({
-        message: "Step 1/3 — Select a GitHub Project:",
+        message: "Step 1/4 — Select a GitHub Project:",
         options: projects.map((proj) => ({
             value: proj.id,
             label: `${proj.owner.login}/${proj.title}`,
@@ -249,68 +228,42 @@ 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;
         return;
     }
     const selectedRepos = await abortIfCancelled(p.multiselect({
-        message: "Step 2/3 — Select repositories to orchestrate:",
+        message: "Step 2/4 — 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" },
-        ],
+    // ── Step 3: Assignment filter ────────────────────────────────────────────────
+    const assignedOnly = await abortIfCancelled(p.confirm({
+        message: "Step 3/4 — Only process issues assigned to the authenticated GitHub user?",
+        initialValue: false,
+    }));
+    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(", ")}`,
-        `Runtime:    ${runtime}`,
-        `Active:     ${lifecycleConfig.activeStates.join(", ")}`,
-        `Terminal:   ${lifecycleConfig.terminalStates.join(", ")}`,
+        `Assigned:   ${assignedOnly ? `Only issues assigned to ${login}` : "All project issues"}`,
+        `Workspace:  ${workspaceDir}`,
     ].join("\n"), "Configuration Summary");
     const confirmed = await abortIfCancelled(p.confirm({ message: "Apply this configuration?" }));
     if (!confirmed) {
@@ -327,14 +280,8 @@ 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.");
     }
@@ -344,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,4 +1,4 @@
-import type { OrchestratorTenantConfig, WorkflowLifecycleConfig } from "@gh-symphony/core";
+import type { OrchestratorTenantConfig } 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";
@@ -7,24 +7,24 @@ export type CliGlobalConfig = {
     activeTenant: string | null;
     tenants: string[];
 };
-export type CliTenantConfig = OrchestratorTenantConfig & {
-    workflowMapping?: WorkflowStateConfig;
+export type CliTenantTrackerSettings = Record<string, string | boolean> & {
+    projectId?: string;
+    assignedOnly?: boolean;
+};
+export type CliTenantConfig = Omit<OrchestratorTenantConfig, "tracker"> & {
+    tracker: Omit<OrchestratorTenantConfig["tracker"], "settings"> & {
+        settings?: CliTenantTrackerSettings;
+    };
 };
 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;
@@ -32,6 +32,4 @@ export declare function loadGlobalConfig(configDir: string): Promise<CliGlobalCo
 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>;

package/dist/config.js

@@ -17,9 +17,6 @@ export function tenantConfigDir(configDir, tenantId) {
 export function tenantConfigPath(configDir, tenantId) {
     return join(tenantConfigDir(configDir, tenantId), "tenant.json");
 }
-export function workflowMappingPath(configDir, tenantId) {
-    return join(tenantConfigDir(configDir, tenantId), "workflow-mapping.json");
-}
 export function daemonPidPath(configDir) {
     return join(configDir, DAEMON_PID_FILE);
 }
@@ -41,12 +38,6 @@ export async function loadTenantConfig(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 saveWorkflowMapping(configDir, tenantId, mapping) {
-    await writeJsonFile(workflowMappingPath(configDir, tenantId), mapping);
-}
 export async function loadActiveTenantConfig(configDir) {
     const global = await loadGlobalConfig(configDir);
     if (!global?.activeTenant) {

package/dist/dashboard/renderer.js

@@ -1,7 +1,7 @@
 // ── Dashboard Renderer (Elixir-parity) ──────────────────────────────────────
 import { bold, dim, green, red, yellow, cyan, magenta, blue, stripAnsi, } from "../ansi.js";
 // ── Column widths (from Elixir spec) ─────────────────────────────────────────
-const COL_ID = 8;
+const COL_ID = 24;
 const COL_STAGE = 14;
 const COL_PID = 8;
 const COL_AGE_TURN = 12;
@@ -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, COL_STAGE);
+    const stage = pad(run.issueState || "\u2014", COL_STAGE);
     const pid = pad(run.processId != null ? String(run.processId) : "\u2014", COL_PID);
     const age = fmtAge(run.startedAt, now);
     const turn = run.turnCount ?? 0;

package/dist/github/gh-auth.js

@@ -31,7 +31,7 @@ export function checkGhAuthenticated(opts) {
     if ((result.status ?? 1) !== 0) {
         return { authenticated: false };
     }
-    const login = parseLogin((result.stderr ?? "").toString());
+    const login = parseLogin((result.stdout ?? "").toString());
     return { authenticated: true, login };
 }
 export function checkGhScopes(opts) {
@@ -40,7 +40,7 @@ export function checkGhScopes(opts) {
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"],
     });
-    const output = (result.stderr ?? "").toString();
+    const output = (result.stdout ?? "").toString();
     const scopes = parseScopes(output);
     if (scopes.length === 0) {
         return { valid: true, missing: [], scopes: [] };

package/dist/orchestrator-runtime.js

@@ -1,4 +1,4 @@
-import { copyFile, mkdir, writeFile } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { loadGlobalConfig, loadTenantConfig, } from "./config.js";
 export function resolveRuntimeRoot(configDir) {
@@ -22,20 +22,5 @@ export async function syncTenantToRuntime(configDir, tenantConfig) {
     const configPath = orchestratorTenantConfigPath(runtimeRoot, tenantConfig.tenantId);
     await mkdir(dirname(configPath), { recursive: true });
     await writeFile(configPath, JSON.stringify(tenantConfig, null, 2) + "\n");
-    // Copy tenant WORKFLOW.md to runtime if it exists
-    const workflowSrc = join(configDir, "tenants", tenantConfig.tenantId, "WORKFLOW.md");
-    const workflowDst = join(dirname(configPath), "WORKFLOW.md");
-    try {
-        await copyFile(workflowSrc, workflowDst);
-    }
-    catch (error) {
-        // ENOENT is expected for tenants created before WORKFLOW.md scaffolding
-        if (!(error &&
-            typeof error === "object" &&
-            "code" in error &&
-            error.code === "ENOENT")) {
-            throw error;
-        }
-    }
     return runtimeRoot;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gh-symphony/cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "license": "MIT",
   "author": "hojinzs",
   "description": "Interactive CLI for GitHub Symphony orchestration",
@@ -36,10 +36,10 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.9.1",
-    "@gh-symphony/core": "0.0.3",
-    "@gh-symphony/orchestrator": "0.0.3",
-    "@gh-symphony/tracker-github": "0.0.3",
-    "@gh-symphony/worker": "0.0.3"
+    "@gh-symphony/core": "0.0.6",
+    "@gh-symphony/orchestrator": "0.0.6",
+    "@gh-symphony/tracker-github": "0.0.6",
+    "@gh-symphony/worker": "0.0.6"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",