@higherdev/cli 0.5.0 → 0.7.0

package/README.md

@@ -12,17 +12,14 @@ Create `~/.config/hd/config.json` with an existing workspace API key:
 
 ```json
 {
-  "current": "workspace",
-  "workspaces": {
-    "workspace": {
-      "url": "https://hdx-higher-ops.vercel.app",
-      "api_key": "hdx_..."
-    }
-  }
+  "url": "https://hdx-higher-ops.vercel.app",
+  "api_key": "hdx_...",
+  "current": "workspace"
 }
 ```
 
-The previous single-workspace config shape is migrated automatically when it is read.
+One workspace key reaches every workspace. Previous single-workspace and
+workspace-map config shapes are migrated automatically when they are read.
 
 ## Commands
 
@@ -33,7 +30,11 @@ The previous single-workspace config shape is migrated automatically when it is
 | `hd status` | Show workspace, ticket, run, and decision status |
 | `hd ticket list` | List tickets |
 | `hd ticket show KEY` | Show one ticket |
-| `hd ticket new --title TITLE [options]` | Create a ticket |
+| `hd ticket new --title TITLE [--acceptance TEXT] [options]` | Create a ticket |
+| `hd ticket queue KEY` | Queue a complete ticket now |
+| `hd epic new PATH [--title TITLE]` | Create an epic from a Markdown spec |
+| `hd epic list` | List epics and ticket progress |
+| `hd workspace ls` | List every workspace available to the configured key |
 | `hd workspace new --name NAME --repo OWNER/NAME [options]` | Create a paused workspace |
 | `hd agents` | List agents |
 | `hd agents set ROLE --provider P --model M [--effort E]` | Update an agent |
@@ -46,6 +47,7 @@ The previous single-workspace config shape is migrated automatically when it is
 | `hd init [options]` | Configure this host and runner service |
 | `hd upgrade [options]` | Refresh this host configuration |
 
-Inside the TUI, use `/board`, `/inbox`, `/ticket`, `/decide`, `/agents`,
-`/settings`, `/workspace`, `/feed`, `/orchestrator`, `/refresh`, `/help`, or
-`/exit`. The display refreshes from the HDX API every five seconds.
+Inside the TUI, use `/board`, `/inbox`, `/ticket`, `/queue`, `/epic new`,
+`/epics`, `/decide`, `/agents`, `/settings`, `/workspace`, `/feed`,
+`/orchestrator`, `/refresh`, `/help`, or `/exit`. The display refreshes from
+the HDX API every five seconds.

package/dist/api.js

@@ -1,5 +1,20 @@
 import { loadConfig } from "./config.js";
-async function request(config, method, path, body) {
+export const MAX_API_ERROR_BODY = 500;
+export function apiErrorMessage(status, parsed, fallback) {
+    const raw = parsed && typeof parsed === "object" && "error" in parsed
+        && typeof parsed.error === "string"
+        ? parsed.error : fallback;
+    const duplicate = raw.match(/agents_one_enabled_(orchestrator|reviewer)_idx/i)?.[1]?.toLowerCase();
+    if (duplicate) {
+        return `hd: ${status} Only one enabled ${duplicate} is allowed per workspace. Disable the current ${duplicate} before enabling another.`;
+    }
+    const trimmed = raw.trim();
+    const body = trimmed.length > MAX_API_ERROR_BODY
+        ? `${trimmed.slice(0, MAX_API_ERROR_BODY)}... [truncated ${trimmed.length - MAX_API_ERROR_BODY} chars]`
+        : trimmed;
+    return `hd: ${status} ${body}`;
+}
+async function request(config, method, path, body, verbatimError = false) {
     const response = await fetch(`${config.url}${path}`, {
         method,
         headers: {
@@ -14,11 +29,14 @@ async function request(config, method, path, body) {
         parsed = text ? JSON.parse(text) : null;
     }
     catch {
-        throw new Error(`hd: ${response.status} ${text || response.statusText}`);
+        throw new Error(apiErrorMessage(response.status, null, text || response.statusText));
     }
     if (!response.ok) {
-        const err = parsed;
-        throw new Error(`hd: ${response.status} ${err.error ?? text}`);
+        if (verbatimError && parsed && typeof parsed === "object" && "error" in parsed
+            && typeof parsed.error === "string") {
+            throw new Error(parsed.error);
+        }
+        throw new Error(apiErrorMessage(response.status, parsed, text || response.statusText));
     }
     return parsed;
 }
@@ -34,6 +52,9 @@ export async function showTicket(key, config = loadConfig()) {
 export async function createTicket(fields, config = loadConfig()) {
     return request(config, "POST", `/api/w/${config.slug}/tickets`, fields);
 }
+export async function queueTicket(key, config = loadConfig()) {
+    return request(config, "POST", `/api/w/${config.slug}/tickets/${encodeURIComponent(key)}/queue`, undefined, true);
+}
 export async function listTicketEvents(key, afterAt, afterId, config = loadConfig()) {
     const query = new URLSearchParams();
     if (afterAt)
@@ -57,6 +78,9 @@ export async function createWorkspace(fields, config = loadConfig()) {
     const result = await request(config, "POST", "/api/workspaces", fields);
     return { ...result, url: config.url };
 }
+export async function listWorkspaces(config = loadConfig()) {
+    return request(config, "GET", "/api/workspaces");
+}
 export async function listAgents(config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/agents`);
 }
@@ -66,6 +90,9 @@ export async function updateAgent(id, fields, config = loadConfig()) {
 export async function listEpics(config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/epics`);
 }
+export async function createEpic(fields, config = loadConfig()) {
+    return request(config, "POST", `/api/w/${config.slug}/epics`, fields);
+}
 export async function listMessages(options = {}, config = loadConfig()) {
     const query = new URLSearchParams();
     if (options.ticketId)

package/dist/config.js

@@ -1,10 +1,10 @@
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 export function configPath() {
     return process.env.HD_CONFIG ?? join(homedir(), ".config/hd/config.json");
 }
-function normalizeWorkspace(value) {
+function normalizeConnection(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return null;
     const row = value;
@@ -14,7 +14,7 @@ function normalizeWorkspace(value) {
     return { url: row.url.replace(/\/$/, ""), api_key: row.api_key };
 }
 function missing(path) {
-    return new Error(`missing ${path}\nWrite { "current": "workspace", "workspaces": { "workspace": { "url": "https://hdx-higher-ops.vercel.app", "api_key": "hdx_..." } } }`);
+    return new Error(`missing ${path}\nWrite { "url": "https://hdx-higher-ops.vercel.app", "api_key": "hdx_...", "current": "workspace" }`);
 }
 export function loadStoredConfig(path = configPath()) {
     let raw;
@@ -25,56 +25,51 @@ export function loadStoredConfig(path = configPath()) {
         throw missing(path);
     }
     const parsed = JSON.parse(raw);
-    // 0.4 and earlier stored one workspace at the top level. Rewrite it once so
-    // every later read sees the multi-workspace format.
-    const legacy = normalizeWorkspace(parsed);
-    if (legacy && typeof parsed.slug === "string" && parsed.slug) {
-        const migrated = { current: parsed.slug, workspaces: { [parsed.slug]: legacy } };
+    const connection = normalizeConnection(parsed);
+    const current = typeof parsed.current === "string" ? parsed.current : "";
+    if (connection && current)
+        return { ...connection, current };
+    // 0.4 stored one workspace at the top level with `slug` rather than
+    // `current`. One key can now reach every workspace, so only the selected
+    // slug needs to survive.
+    if (connection && typeof parsed.slug === "string" && parsed.slug) {
+        const migrated = { ...connection, current: parsed.slug };
         writeStoredConfig(migrated, path);
         return migrated;
     }
-    const current = typeof parsed.current === "string" ? parsed.current : "";
+    // 0.5 stored one connection per workspace. Keep the current workspace's
+    // credentials as the shared operator connection and discard the duplicates.
     const source = parsed.workspaces;
     if (!current || !source || typeof source !== "object" || Array.isArray(source)) {
-        throw new Error(`${path} needs current and workspaces`);
-    }
-    const workspaces = {};
-    for (const [slug, value] of Object.entries(source)) {
-        const workspace = normalizeWorkspace(value);
-        if (workspace)
-            workspaces[slug] = workspace;
+        throw new Error(`${path} needs url, api_key, and current`);
     }
-    if (!workspaces[current])
+    const selected = normalizeConnection(source[current]);
+    if (!selected)
         throw new Error(`${path} current workspace ${current} is not configured`);
-    return { current, workspaces };
+    const migrated = { ...selected, current };
+    writeStoredConfig(migrated, path);
+    return migrated;
 }
 export function loadConfig(slug) {
     const stored = loadStoredConfig();
     const selected = slug ?? stored.current;
-    const workspace = stored.workspaces[selected];
-    if (!workspace)
-        throw new Error(`No configured workspace ${selected}.`);
-    return { ...workspace, slug: selected };
+    return { url: stored.url, api_key: stored.api_key, slug: selected };
 }
 export function writeStoredConfig(config, path = configPath()) {
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
     chmodSync(path, 0o600);
 }
-/** Store credentials for a workspace and make it current. */
+/** Store one operator connection and make its selected workspace current. */
 export function writeHdConfig(config, path = configPath()) {
-    const stored = existsSync(path)
-        ? loadStoredConfig(path)
-        : { current: config.slug, workspaces: {} };
-    stored.workspaces[config.slug] = { url: config.url.replace(/\/$/, ""), api_key: config.api_key };
-    stored.current = config.slug;
-    writeStoredConfig(stored, path);
+    writeStoredConfig({
+        url: config.url.replace(/\/$/, ""),
+        api_key: config.api_key,
+        current: config.slug,
+    }, path);
 }
 export function switchWorkspace(slug, path = configPath()) {
     const stored = loadStoredConfig(path);
-    const workspace = stored.workspaces[slug];
-    if (!workspace)
-        throw new Error(`No configured workspace ${slug}.`);
     writeStoredConfig({ ...stored, current: slug }, path);
-    return { ...workspace, slug };
+    return { url: stored.url, api_key: stored.api_key, slug };
 }

package/dist/epics.js

@@ -0,0 +1,25 @@
+import { readFile } from "node:fs/promises";
+export function headingTitle(spec) {
+    const match = spec.match(/^#[ \t]+(.+?)\s*$/m);
+    const title = match?.[1]?.replace(/[ \t]+#+[ \t]*$/, "").trim();
+    return title || null;
+}
+export async function readEpicSpec(path, title) {
+    const spec_md = await readFile(path, "utf8");
+    const resolved = title?.trim() || headingTitle(spec_md);
+    if (!resolved)
+        throw new Error(`No # heading in ${path}. Pass --title TITLE.`);
+    return { title: resolved, spec_md };
+}
+export function epicProgressRows(epics, tickets) {
+    return epics.map((epic) => {
+        const linked = tickets.filter((ticket) => ticket.epic_id === epic.id);
+        return {
+            id: epic.id,
+            title: epic.title,
+            status: epic.status,
+            merged: linked.filter((ticket) => ticket.status === "merged").length,
+            total: linked.length,
+        };
+    });
+}

package/dist/index.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
-import { answerDecision, createTicket, createWorkspace, getStatus, listAgents, listTicketEvents, listTickets, postMessage, setPaused, showTicket, updateAgent, } from "./api.js";
+import { answerDecision, createEpic, createTicket, createWorkspace, getStatus, listAgents, listEpics, listTicketEvents, listTickets, listWorkspaces, postMessage, queueTicket, setPaused, showTicket, updateAgent, } from "./api.js";
 import { initHost, parseHostFlags } from "./host.js";
-import { writeHdConfig } from "./config.js";
+import { loadConfig, writeHdConfig } from "./config.js";
+import { epicProgressRows, readEpicSpec } from "./epics.js";
 import { banner, c, statusChip, table, truncate, usage } from "./out.js";
 function fail(message) {
     console.error(message);
@@ -96,7 +97,7 @@ async function cmdTicket(argv) {
     if (action === "new") {
         const { opts } = flags(rest);
         if (!opts.title)
-            fail("usage: hd ticket new --title TITLE [--body TEXT] [--area TAG] [--provider NAME] [--epic ID]");
+            fail("usage: hd ticket new --title TITLE [--body TEXT] [--acceptance TEXT] [--area TAG] [--provider NAME] [--epic ID]");
         const { ticket } = await createTicket({
             title: opts.title,
             body_md: opts.body,
@@ -108,7 +109,41 @@ async function cmdTicket(argv) {
         console.log(`${c.bold(ticket.key)}  ${statusChip(ticket.status)}  ${ticket.title}`);
         return;
     }
-    fail("usage: hd ticket list | show KEY | new --title TITLE");
+    if (action === "queue") {
+        const key = rest[0];
+        if (!key)
+            fail("usage: hd ticket queue KEY");
+        const { ticket } = await queueTicket(key.toUpperCase());
+        console.log(`${c.bold(ticket.key)}  ${statusChip(ticket.status)}`);
+        return;
+    }
+    fail("usage: hd ticket list | show KEY | new --title TITLE | queue KEY");
+}
+async function cmdEpic(argv) {
+    const [action, ...rest] = argv;
+    if (action === "list") {
+        const [{ epics }, { tickets }] = await Promise.all([listEpics(), listTickets()]);
+        const rows = epicProgressRows(epics, tickets);
+        if (!rows.length) {
+            console.log(c.dim("No epics."));
+            return;
+        }
+        console.log(table(["KEY", "STATUS", "PROGRESS", "TITLE"], rows.map((epic) => [
+            epic.id, statusChip(epic.status), `${epic.merged}/${epic.total}`, epic.title,
+        ])));
+        return;
+    }
+    if (action === "new") {
+        const { rest: paths, opts } = flags(rest);
+        const path = paths.join(" ");
+        if (!path)
+            fail("usage: hd epic new PATH [--title TITLE]");
+        const input = await readEpicSpec(path, opts.title);
+        const { epic } = await createEpic(input);
+        console.log(`${c.bold(epic.id)}  ${statusChip(epic.status)}  ${epic.title}`);
+        return;
+    }
+    fail("usage: hd epic new PATH [--title TITLE] | list");
 }
 async function cmdLogs(argv) {
     const { rest, bools } = flags(argv);
@@ -176,8 +211,20 @@ async function cmdDecide(argv) {
 }
 async function cmdWorkspace(argv) {
     const [action, ...rest] = argv;
+    if (action === "ls") {
+        const current = loadConfig().slug;
+        const workspaces = await listWorkspaces();
+        console.log(table(["", "SLUG", "NAME", "REPO", "STATE"], workspaces.map((workspace) => [
+            workspace.slug === current ? "*" : "",
+            workspace.slug,
+            workspace.name,
+            workspace.repo,
+            workspace.on ? c.green("on") : c.dim("off"),
+        ])));
+        return;
+    }
     if (action !== "new")
-        fail("usage: hd workspace new --name NAME --repo OWNER/NAME [--slug S] [--branch main] [--host box]");
+        fail("usage: hd workspace ls | new --name NAME --repo OWNER/NAME [--slug S] [--branch main] [--host box]");
     const { opts } = flags(rest);
     if (!opts.name || !opts.repo) {
         fail("usage: hd workspace new --name NAME --repo OWNER/NAME [--slug S] [--branch main] [--host box]");
@@ -252,6 +299,10 @@ export async function main(argv = process.argv.slice(2)) {
             await cmdTicket(rest);
             return;
         }
+        if (cmd === "epic") {
+            await cmdEpic(rest);
+            return;
+        }
         if (cmd === "logs") {
             await cmdLogs(rest);
             return;

package/dist/out.js

@@ -64,8 +64,9 @@ export function usage() {
     return [
         c.bold("Usage"),
         `  ${c.blue("hd status")}                         workspace overview`,
-        `  ${c.blue("hd ticket list | show | new")}       ticket operations`,
-        `  ${c.blue("hd workspace new")}                  create a paused workspace`,
+        `  ${c.blue("hd ticket list | show | new | queue")} ticket operations`,
+        `  ${c.blue("hd epic new PATH | list")}            epic operations`,
+        `  ${c.blue("hd workspace ls | new")}             list or create workspaces`,
         `  ${c.blue("hd agents [set]")}                   inspect or update agents`,
         `  ${c.blue("hd logs KEY [-f]")}                  run events`,
         `  ${c.blue("hd msg KEY TEXT")}                   message a builder`,

package/dist/tui/App.js

@@ -1,6 +1,7 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, Static, Text, useApp, useInput, useStdout } from "ink";
+import { epicProgressRows } from "../epics.js";
 import { Banner } from "./Banner.js";
 import { Bubble } from "./Bubble.js";
 import { Cockpit, StreamPanel, boardTicketIds, nextCursor } from "./Dashboard.js";
@@ -14,7 +15,7 @@ import { alertOnce } from "./alert.js";
 import { bubbleRows } from "./height.js";
 import { planLayout, splitPanels } from "./layout.js";
 import { parseLine } from "./parse.js";
-import { configuredSlugs, decisionOptions, loadLiveEvents, loadTicketDetail, pollSnapshot, postOrchestrator, resolveDecision, switchWorkspace, updateAgent, updateProviderCap, } from "./data.js";
+import { configuredSlugs, createEpicFromFile, decisionOptions, loadLiveEvents, loadTicketDetail, pollSnapshot, postOrchestrator, queueTicket, resolveDecision, switchWorkspace, updateAgent, updateProviderCap, } from "./data.js";
 import { editFor, editableKeys, nextValue, seedFor, settingsRows } from "./settings-model.js";
 import { appendLines, runLabels, toStreamLines } from "./stream.js";
 import { UI } from "./theme.js";
@@ -57,6 +58,23 @@ export function App({ initial }) {
         if (messages.length > 0 || view !== "home")
             setStarted(true);
     }, [messages.length, view]);
+    useEffect(() => {
+        if (!ready)
+            return;
+        const live = planLayout({
+            rows,
+            columns,
+            width,
+            splash: false,
+            ready: true,
+            decision: decisionRows(board.decisions),
+            inFlight: 0,
+            notice: false,
+            home: true,
+        });
+        if (live.cockpit > 0)
+            setStarted(true);
+    }, [ready, rows, columns, width, board.decisions]);
     const applySnapshot = useCallback((snapshot) => {
         const token = loads.current.start(snapshot.workspace.id);
         if (!loads.current.isCurrent(token))
@@ -144,13 +162,9 @@ export function App({ initial }) {
         }
     }, [settings, config, refresh]);
     const changeWorkspace = useCallback(async (slug) => {
-        if (!configuredSlugs().includes(slug)) {
-            setNotice(`No configured workspace ${slug}. You can reach: ${configuredSlugs().join(", ")}.`);
-            return;
-        }
         setBusy(true);
         try {
-            const snapshot = await switchWorkspace(slug);
+            const snapshot = await switchWorkspace(slug, config);
             loads.current.switchTo(snapshot.workspace.id);
             setConfig(snapshot.config);
             setWorkspace(snapshot.workspace);
@@ -265,10 +279,20 @@ export function App({ initial }) {
                 }
                 return;
             case "workspace":
-                if (!action.slug)
-                    say("system", `Workspaces: ${configuredSlugs().join(", ")}.`);
-                else
+                if (action.slug)
                     await changeWorkspace(action.slug);
+                else {
+                    setBusy(true);
+                    try {
+                        say("system", `Workspaces: ${(await configuredSlugs(config)).join(", ")}.`);
+                    }
+                    catch (error) {
+                        setNotice(error instanceof Error ? error.message : String(error));
+                    }
+                    finally {
+                        setBusy(false);
+                    }
+                }
                 return;
             case "ticket":
                 setTicketKey(action.key);
@@ -288,6 +312,41 @@ export function App({ initial }) {
                     setBusy(false);
                 }
                 return;
+            case "epic-new":
+                setBusy(true);
+                try {
+                    const { epic } = await createEpicFromFile(config, action.path);
+                    say("system", `Created epic ${epic.id}: ${epic.title}`);
+                    await refresh();
+                }
+                catch (error) {
+                    setNotice(error instanceof Error ? error.message : String(error));
+                }
+                finally {
+                    setBusy(false);
+                }
+                return;
+            case "epics": {
+                const rows = epicProgressRows(board.epics, board.tickets);
+                say("system", rows.length
+                    ? rows.map((epic) => `${epic.id}  ${epic.status}  ${epic.merged}/${epic.total}  ${epic.title}`).join("\n")
+                    : "No epics.");
+                return;
+            }
+            case "queue":
+                setBusy(true);
+                try {
+                    const { ticket: queued } = await queueTicket(config, action.key);
+                    say("system", `${queued.key} queued.`);
+                    await refresh();
+                }
+                catch (error) {
+                    setNotice(error instanceof Error ? error.message : String(error));
+                }
+                finally {
+                    setBusy(false);
+                }
+                return;
             case "decide": {
                 const decision = board.decisions[0];
                 if (!decision) {

package/dist/tui/Dashboard.js

@@ -130,7 +130,7 @@ export function AgentsColumn({ board, width, rows, }) {
                 const name = Math.max(8, Math.min(22, width - 14));
                 return (_jsxs(Box, { flexWrap: "nowrap", children: [_jsxs(Text, { color: inkColor(tone), children: [DOT, " "] }), _jsx(Box, { width: name, flexShrink: 0, children: _jsx(Text, { color: UI.text, wrap: "truncate", children: truncate(agent.display_name, name - 1) }) }), _jsx(Text, { color: UI.dim, wrap: "truncate", children: run
                                 ? `${ticket ? `${ticket.key} ` : ""}${elapsed(run.started_at ?? run.created_at)}`
-                                : blocked || (agent.enabled ? "idle" : "off") })] }, agent.id));
+                                : blocked || (agent.enabled ? "idle" : "offline") })] }, agent.id));
             }),
             _jsx(More, { count: ordered.length - shown.length }, "more"),
         ] }));

package/dist/tui/Help.js

@@ -8,6 +8,9 @@ export const COMMANDS = [
     { name: "/board", help: "the kanban board" },
     { name: "/inbox", help: "decisions and messages waiting on you" },
     { name: "/ticket", args: "HD-12", help: "open one ticket" },
+    { name: "/queue", args: "HD-12", help: "queue a complete ticket now" },
+    { name: "/epic", args: "new PATH", help: "create an epic from a Markdown spec" },
+    { name: "/epics", help: "list epics and ticket progress" },
     { name: "/decide", args: "2 | text", help: "answer the decision on screen" },
     { name: "/agents", help: "every agent in full, and the live run stream" },
     { name: "/settings", help: "change provider caps and agent settings" },

package/dist/tui/data.js

@@ -1,5 +1,6 @@
-import { answerDecision, getStatus, listAgents, listEpics, listFeed, listMessages, listTicketEvents, listTickets, postMessage as sendMessage, showTicket, updateAgent as patchAgent, updateCaps, } from "../api.js";
-import { loadConfig, loadStoredConfig, switchWorkspace as selectWorkspace, } from "../config.js";
+import { answerDecision, createEpic as postEpic, getStatus, listAgents, listEpics, listFeed, listMessages, listTicketEvents, listTickets, listWorkspaces, postMessage as sendMessage, queueTicket as queueTicketNow, showTicket, updateAgent as patchAgent, updateCaps, } from "../api.js";
+import { loadConfig, switchWorkspace as selectWorkspace, } from "../config.js";
+import { readEpicSpec } from "../epics.js";
 export const POLL_MS = 5_000;
 export const providers = ["claude", "codex", "gemini", "grok"];
 export const efforts = ["low", "medium", "high"];
@@ -17,8 +18,8 @@ export const BOARD_COLUMNS = [
     "merged",
     "cancelled",
 ];
-export function configuredSlugs() {
-    return Object.keys(loadStoredConfig().workspaces).sort();
+export async function configuredSlugs(config = loadConfig()) {
+    return (await listWorkspaces(config)).map((workspace) => workspace.slug).sort();
 }
 export async function loadSnapshot(config = loadConfig()) {
     const [status, ticketData, agentData, epicData, feedData] = await Promise.all([
@@ -83,8 +84,14 @@ export function pollSnapshot(config, onSnapshot, onState, onError) {
     void refresh();
     return { refresh, close: () => { closed = true; clearInterval(timer); } };
 }
-export async function switchWorkspace(slug) {
-    return loadSnapshot(selectWorkspace(slug));
+export async function switchWorkspace(slug, config = loadConfig()) {
+    const slugs = await configuredSlugs(config);
+    if (!slugs.includes(slug)) {
+        throw new Error(`No workspace ${slug}. You can reach: ${slugs.join(", ")}.`);
+    }
+    const snapshot = await loadSnapshot({ ...config, slug });
+    selectWorkspace(slug);
+    return snapshot;
 }
 export async function postOrchestrator(body, config) {
     await sendMessage({ body_md: body, to_role: "orchestrator", delivery: "queue" }, config);
@@ -92,6 +99,12 @@ export async function postOrchestrator(body, config) {
 export async function loadTicketDetail(config, key) {
     return showTicket(key, config);
 }
+export async function createEpicFromFile(config, path) {
+    return postEpic(await readEpicSpec(path), config);
+}
+export async function queueTicket(config, key) {
+    return queueTicketNow(key, config);
+}
 export async function waitForReply(config, since, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() <= deadline) {

package/dist/tui/parse.js

@@ -29,6 +29,16 @@ export function parseLine(raw) {
             return argument
                 ? { kind: "ticket", key: argument.toUpperCase() }
                 : { kind: "unknown", command: "ticket needs a key" };
+        case "epic":
+            return rest[0]?.toLowerCase() === "new" && rest.length > 1
+                ? { kind: "epic-new", path: rest.slice(1).join(" ") }
+                : { kind: "unknown", command: "epic needs new PATH" };
+        case "epics":
+            return { kind: "epics" };
+        case "queue":
+            return argument
+                ? { kind: "queue", key: argument.toUpperCase() }
+                : { kind: "unknown", command: "queue needs a key" };
         case "decide": {
             const dismiss = /(^|\s)--(skip|dismiss)(\s|$)/.test(argument);
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@higherdev/cli",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "type": "module",
   "bin": {
     "hd": "dist/index.js"