@higherdev/cli 0.9.0 → 0.11.0

package/README.md

@@ -32,13 +32,19 @@ workspace-map config shapes are migrated automatically when they are read.
 | `hd ticket show KEY` | Show one ticket |
 | `hd ticket new --title TITLE [--acceptance TEXT] [options]` | Create a ticket |
 | `hd ticket queue KEY` | Queue a complete ticket now |
+| `hd ticket cancel KEY` | Cancel a ticket |
 | `hd epic new PATH [--title TITLE]` | Create an epic from a Markdown spec |
 | `hd epic list` | List epics and ticket progress |
 | `hd plan [--repo DIR]` | Hand the terminal to Codex to author an epic spec |
 | `hd workspace ls` | List every workspace available to the configured key |
 | `hd workspace new --name NAME --repo OWNER/NAME [options]` | Preflight GitHub, wire the runner, and create a paused workspace |
+| `hd workspace set [options]` | Update settings; max turns uses `--max-turns KIND=N[,KIND=N...]` |
+| `hd workspace rotate-key` | Rotate the shared API key and save it locally |
 | `hd agents` | List agents |
-| `hd agents set ROLE --provider P --model M [--effort E]` | Update an agent |
+| `hd agents add ROLE --provider P --model M [options]` | Add an agent |
+| `hd agents rm ROLE\|ID` | Remove an unambiguous agent |
+| `hd agents set ROLE\|ID [options]` | Rename, configure, enable, or disable an agent |
+| `hd caps [set PROVIDER N]` | Show or update provider concurrency caps |
 | `hd logs KEY [-f]` | Show or follow run events |
 | `hd msg KEY "message" [--interrupt]` | Message a builder |
 | `hd decide` | List open decisions |
@@ -50,9 +56,12 @@ workspace-map config shapes are migrated automatically when they are read.
 
 `hd workspace new` uses the operator's authenticated `gh`, defaults to the repository's real default
 branch, bootstraps an empty repository unless `--no-bootstrap` is set, and invites `mel-ilotus` unless
-`--runner-user USER` overrides it.
+`--runner-user USER` overrides it. On a terminal, missing name or repo flags start a guided wizard. If
+the repository is missing, approve private creation interactively, use `--create` to force it, or
+`--no-create` to fail. Fully flagged calls remain non-interactive for scripts and Mel.
 
-Inside the TUI, use `/board`, `/inbox`, `/ticket`, `/queue`, `/epic new`,
-`/epics`, `/plan`, `/decide`, `/agents`, `/settings`, `/workspace`, `/feed`,
+Inside the TUI, use `/board`, `/inbox`, `/ticket`, `/queue`, `/cancel`, `/epic new`,
+`/epics`, `/plan`, `/decide`, `/agents add`, `/agents rm`, `/settings`, `/workspace`,
+`/workspace new`, `/workspace set`, `/workspace rotate-key`, `/feed`,
 `/orchestrator`, `/refresh`, `/help`, or `/exit`. The display refreshes from
 the HDX API every five seconds.

package/dist/api.js

@@ -55,6 +55,9 @@ export async function createTicket(fields, config = loadConfig()) {
 export async function queueTicket(key, config = loadConfig()) {
     return request(config, "POST", `/api/w/${config.slug}/tickets/${encodeURIComponent(key)}/queue`, undefined, true);
 }
+export async function cancelTicket(key, config = loadConfig()) {
+    return request(config, "POST", `/api/w/${config.slug}/tickets/${encodeURIComponent(key)}/cancel`);
+}
 export async function listTicketEvents(key, afterAt, afterId, config = loadConfig()) {
     const query = new URLSearchParams();
     if (afterAt)
@@ -81,12 +84,27 @@ export async function createWorkspace(fields, config = loadConfig()) {
 export async function listWorkspaces(config = loadConfig()) {
     return request(config, "GET", "/api/workspaces");
 }
+export async function getWorkspace(config = loadConfig()) {
+    return request(config, "GET", `/api/w/${config.slug}`);
+}
+export async function updateWorkspace(fields, config = loadConfig()) {
+    return request(config, "PATCH", `/api/w/${config.slug}`, fields);
+}
+export async function rotateWorkspaceApiKey(config = loadConfig()) {
+    return request(config, "POST", `/api/w/${config.slug}/api-key`);
+}
 export async function listAgents(config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/agents`);
 }
+export async function createAgent(fields, config = loadConfig()) {
+    return request(config, "POST", `/api/w/${config.slug}/agents`, fields);
+}
 export async function updateAgent(id, fields, config = loadConfig()) {
     return request(config, "PATCH", `/api/w/${config.slug}/agents`, { id, ...fields });
 }
+export async function deleteAgent(id, config = loadConfig()) {
+    return request(config, "DELETE", `/api/w/${config.slug}/agents`, { id });
+}
 export async function listEpics(config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/epics`);
 }

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
-import { answerDecision, createEpic, createTicket, createWorkspace, getStatus, listAgents, listEpics, listTicketEvents, listTickets, listWorkspaces, postMessage, queueTicket, setPaused, showTicket, updateAgent, } from "./api.js";
+import { answerDecision, cancelTicket, createAgent, createEpic, createTicket, deleteAgent, getStatus, listAgents, listEpics, listTicketEvents, listTickets, listWorkspaces, postMessage, queueTicket, setPaused, showTicket, updateAgent, updateCaps, } from "./api.js";
 import { initHost, parseHostFlags } from "./host.js";
-import { loadConfig, writeHdConfig } from "./config.js";
+import { loadConfig } from "./config.js";
 import { epicProgressRows, readEpicSpec } from "./epics.js";
 import { banner, c, statusChip, table, truncate, usage } from "./out.js";
 import { launchArchitect } from "./plan.js";
-import { HDX_RUNNER_GH_USER, preflightWorkspace } from "./workspace-preflight.js";
+import { WORKSPACE_USAGE, workspaceNew, workspaceRotateKey, workspaceSet } from "./workspace-commands.js";
 function fail(message) {
     console.error(message);
     process.exit(1);
@@ -119,7 +119,15 @@ async function cmdTicket(argv) {
         console.log(`${c.bold(ticket.key)}  ${statusChip(ticket.status)}`);
         return;
     }
-    fail("usage: hd ticket list | show KEY | new --title TITLE | queue KEY");
+    if (action === "cancel") {
+        const key = rest[0];
+        if (!key)
+            fail("usage: hd ticket cancel KEY");
+        const { ticket } = await cancelTicket(key.toUpperCase());
+        console.log(`${c.bold(ticket.key)}  ${statusChip(ticket.status)}`);
+        return;
+    }
+    fail("usage: hd ticket list | show KEY | new --title TITLE | queue KEY | cancel KEY");
 }
 async function cmdEpic(argv) {
     const [action, ...rest] = argv;
@@ -233,30 +241,36 @@ async function cmdWorkspace(argv, deps = {}) {
         ])));
         return;
     }
-    const workspaceUsage = "usage: hd workspace ls | new --name NAME --repo OWNER/NAME [--slug S] [--branch B] [--host box] [--runner-user USER] [--no-bootstrap]";
-    if (action !== "new")
-        fail(workspaceUsage);
-    const { opts, bools } = flags(rest);
-    if (!opts.name || !opts.repo) {
-        fail(workspaceUsage);
+    if (action === "rotate-key") {
+        if (rest.length)
+            fail(WORKSPACE_USAGE);
+        const result = await workspaceRotateKey();
+        console.log(`api key: ${result.apiKey}`);
+        console.log("saved locally; update Mel's hd init configuration on the box.");
+        return;
+    }
+    if (action === "set") {
+        const workspace = await workspaceSet(rest);
+        console.log(`${workspace.slug}  ${workspace.name}  ${workspace.repo}`);
+        return;
     }
-    const preflight = await (deps.preflightWorkspace ?? preflightWorkspace)({ name: opts.name, repo: opts.repo,
-        branch: opts.branch, noBootstrap: bools.has("no-bootstrap"),
-        runnerUser: opts["runner-user"] ?? HDX_RUNNER_GH_USER });
-    if (preflight.invitationPending)
-        console.log(`invitation pending for ${opts["runner-user"] ?? HDX_RUNNER_GH_USER}`);
-    const result = await createWorkspace({ name: opts.name, repo: opts.repo, slug: opts.slug,
-        default_branch: preflight.branch, default_host: opts.host ?? "box" });
-    console.log(`workspace: ${result.workspace.slug}`);
-    writeHdConfig({ url: result.url, api_key: result.api_key, slug: result.workspace.slug });
+    if (action !== "new")
+        fail(WORKSPACE_USAGE);
+    const result = await workspaceNew(rest, deps);
+    if (result.invitationPending)
+        console.log(`invitation pending for ${result.runnerUser}`);
+    console.log(`workspace: ${result.slug}`);
     console.log("saved and switched; configure another machine with:");
-    console.log(`hd init --url ${result.url} --api-key ${result.api_key} --slug ${result.workspace.slug}`);
+    console.log(result.initCommand);
 }
-function selectAgent(agents, role, provider) {
-    const matches = agents.filter((agent) => agent.role === role);
+function selectAgent(agents, target, provider) {
+    const exact = agents.find((agent) => agent.id === target);
+    if (exact)
+        return exact;
+    const matches = agents.filter((agent) => agent.role === target);
     const selected = matches.length === 1 ? matches[0] : matches.find((agent) => agent.provider === provider);
     if (!selected)
-        fail(`No unambiguous ${role} agent found for provider ${provider}.`);
+        fail(`No unambiguous agent ${target}${provider ? ` for provider ${provider}` : ""}.`);
     return selected;
 }
 async function cmdAgents(argv) {
@@ -267,24 +281,57 @@ async function cmdAgents(argv) {
             console.log("No agents.");
             return;
         }
-        console.log(table(["ROLE", "PROVIDER", "MODEL", "EFFORT", "STATE"], agents.map((agent) => [
-            agent.role, agent.provider, agent.model, agent.effort, agent.enabled ? c.green("on") : c.dim("off"),
+        console.log(table(["ID", "NAME", "ROLE", "PROVIDER", "MODEL", "EFFORT", "STATE"], agents.map((agent) => [
+            agent.id, agent.display_name, agent.role, agent.provider, agent.model, agent.effort,
+            agent.enabled ? c.green("on") : c.dim("off"),
         ])));
         return;
     }
-    if (action !== "set")
-        fail("usage: hd agents [set ROLE --provider P --model M [--effort E]]");
-    const { rest: args, opts } = flags(rest);
-    const role = args[0];
-    if (!role || !opts.provider || !opts.model) {
-        fail("usage: hd agents set ROLE --provider P --model M [--effort E]");
+    const agentUsage = "usage: hd agents add ROLE --provider P --model M [--effort E] [--name N] | rm ROLE|ID | set ROLE|ID [flags]";
+    const { rest: args, opts, bools } = flags(rest);
+    const target = args[0];
+    if (action === "add") {
+        if (!target || !opts.provider || !opts.model)
+            fail(agentUsage);
+        const { agent } = await createAgent({ role: target, provider: opts.provider, model: opts.model,
+            effort: opts.effort, display_name: opts.name ?? opts.provider });
+        console.log(`${agent.id}  ${agent.display_name}  ${agent.role}  ${agent.provider}`);
+        return;
     }
+    if (!target)
+        fail(agentUsage);
     const { agents } = await listAgents();
-    const current = selectAgent(agents, role, opts.provider);
-    const { agent } = await updateAgent(current.id, {
-        provider: opts.provider, model: opts.model, ...(opts.effort ? { effort: opts.effort } : {}),
-    });
-    console.log(`${agent.role}  ${agent.provider}  ${agent.model}  ${agent.effort}`);
+    const current = selectAgent(agents, target, opts.provider);
+    if (action === "rm") {
+        await deleteAgent(current.id);
+        console.log(`removed ${current.display_name} (${current.id})`);
+        return;
+    }
+    if (action !== "set" || (bools.has("on") && bools.has("off")))
+        fail(agentUsage);
+    const fields = {
+        ...(opts.provider ? { provider: opts.provider } : {}), ...(opts.model ? { model: opts.model } : {}),
+        ...(opts.effort ? { effort: opts.effort } : {}), ...(opts.name ? { display_name: opts.name } : {}),
+        ...(bools.has("on") || bools.has("off") ? { enabled: bools.has("on") } : {}),
+    };
+    if (!Object.keys(fields).length)
+        fail(agentUsage);
+    const { agent } = await updateAgent(current.id, fields);
+    console.log(`${agent.display_name}  ${agent.role}  ${agent.provider}  ${agent.model}  ${agent.enabled ? "on" : "off"}`);
+}
+async function cmdCaps(argv) {
+    const [action, provider, raw, ...extra] = argv;
+    if (!action) {
+        const caps = (await getStatus()).workspace.provider_caps;
+        console.log(table(["PROVIDER", "CAP"], Object.entries(caps).sort().map(([name, cap]) => [name, String(cap)])));
+        return;
+    }
+    const cap = Number(raw);
+    if (action !== "set" || !provider || extra.length || !Number.isInteger(cap) || cap < 0) {
+        fail("usage: hd caps | hd caps set PROVIDER N");
+    }
+    const result = await updateCaps({ [provider]: cap });
+    console.log(`${provider}  ${result.provider_caps[provider]}`);
 }
 export async function main(argv = process.argv.slice(2), deps = {}) {
     const [cmd, ...rest] = argv;
@@ -343,6 +390,10 @@ export async function main(argv = process.argv.slice(2), deps = {}) {
             await cmdAgents(rest);
             return;
         }
+        if (cmd === "caps") {
+            await cmdCaps(rest);
+            return;
+        }
         if (cmd === "pause" || cmd === "off") {
             await setPaused(true);
             console.log(cmd === "off" ? "off" : "paused");

package/dist/out.js

@@ -64,11 +64,12 @@ export function usage() {
     return [
         c.bold("Usage"),
         `  ${c.blue("hd status")}                         workspace overview`,
-        `  ${c.blue("hd ticket list | show | new | queue")} ticket operations`,
+        `  ${c.blue("hd ticket list | show | new | queue | cancel")} ticket operations`,
         `  ${c.blue("hd epic new PATH | list")}            epic operations`,
         `  ${c.blue("hd plan [--repo DIR]")}               author an epic with Codex`,
-        `  ${c.blue("hd workspace ls | new")}             list or create workspaces`,
-        `  ${c.blue("hd agents [set]")}                   inspect or update agents`,
+        `  ${c.blue("hd workspace ls | new | set | rotate-key")} workspace operations`,
+        `  ${c.blue("hd agents [add | rm | set]")}         manage agents`,
+        `  ${c.blue("hd caps [set PROVIDER N]")}           provider concurrency`,
         `  ${c.blue("hd logs KEY [-f]")}                  run events`,
         `  ${c.blue("hd msg KEY TEXT")}                   message a builder`,
         `  ${c.blue("hd decide [ID --answer TEXT]")}      decisions`,

package/dist/tui/App.js

@@ -1,8 +1,10 @@
 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 { loadConfig } from "../config.js";
 import { epicProgressRows } from "../epics.js";
 import { launchArchitect } from "../plan.js";
+import { workspaceNew, workspaceRotateKey, workspaceSet } from "../workspace-commands.js";
 import { Banner } from "./Banner.js";
 import { Bubble } from "./Bubble.js";
 import { Cockpit, StreamPanel, boardTicketIds, nextCursor } from "./Dashboard.js";
@@ -16,7 +18,7 @@ import { alertOnce } from "./alert.js";
 import { bubbleRows } from "./height.js";
 import { planLayout, splitPanels } from "./layout.js";
 import { parseLine } from "./parse.js";
-import { configuredSlugs, createEpicFromFile, decisionOptions, loadLiveEvents, loadTicketDetail, pollSnapshot, postOrchestrator, queueTicket, resolveDecision, switchWorkspace, updateAgent, updateProviderCap, } from "./data.js";
+import { configuredSlugs, cancelTicket, createAgent, createEpicFromFile, decisionOptions, deleteAgent, loadLiveEvents, loadTicketDetail, pollSnapshot, postOrchestrator, queueTicket, resolveDecision, switchWorkspace, updateAgent, updateProviderCap, updateWorkspace, } 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";
@@ -149,9 +151,12 @@ export function App({ initial }) {
             if (edit.value.target === "cap") {
                 await updateProviderCap(config, edit.value.provider, edit.value.cap);
             }
-            else {
+            else if (edit.value.target === "agent") {
                 await updateAgent(config, edit.value.id, edit.value.fields);
             }
+            else {
+                await updateWorkspace(config, edit.value.fields);
+            }
             setNotice(null);
             await refresh();
         }
@@ -162,10 +167,10 @@ export function App({ initial }) {
             setBusy(false);
         }
     }, [settings, config, refresh]);
-    const changeWorkspace = useCallback(async (slug) => {
+    const changeWorkspace = useCallback(async (slug, source = config) => {
         setBusy(true);
         try {
-            const snapshot = await switchWorkspace(slug, config);
+            const snapshot = await switchWorkspace(slug, source);
             loads.current.switchTo(snapshot.workspace.id);
             setConfig(snapshot.config);
             setWorkspace(snapshot.workspace);
@@ -185,7 +190,7 @@ export function App({ initial }) {
         finally {
             setBusy(false);
         }
-    }, [say]);
+    }, [config, say]);
     const askOrchestrator = useCallback(async (text) => {
         setBusy(true);
         const id = nextId();
@@ -295,6 +300,35 @@ export function App({ initial }) {
                     }
                 }
                 return;
+            case "workspace-command":
+                setBusy(true);
+                try {
+                    if (action.command === "new") {
+                        let created;
+                        await suspendTerminal(async () => { created = await workspaceNew(action.args); });
+                        if (!created)
+                            throw new Error("Workspace wizard did not finish.");
+                        await changeWorkspace(created.slug, loadConfig());
+                        say("system", `Created ${created.slug}. Configure the box with: ${created.initCommand}`);
+                    }
+                    else if (action.command === "set") {
+                        const updated = await workspaceSet(action.args);
+                        say("system", `Updated ${updated.slug}: ${updated.name} (${updated.repo}).`);
+                        await refresh();
+                    }
+                    else {
+                        const rotated = await workspaceRotateKey();
+                        setConfig(loadConfig());
+                        say("system", `API key: ${rotated.apiKey}\nSaved locally. Update Mel's hd init configuration on the box.`);
+                    }
+                }
+                catch (error) {
+                    setNotice(error instanceof Error ? error.message : String(error));
+                }
+                finally {
+                    setBusy(false);
+                }
+                return;
             case "ticket":
                 setTicketKey(action.key);
                 setView("ticket");
@@ -348,6 +382,55 @@ export function App({ initial }) {
                     setBusy(false);
                 }
                 return;
+            case "cancel":
+                setBusy(true);
+                try {
+                    const { ticket: cancelled } = await cancelTicket(config, action.key);
+                    say("system", `${cancelled.key} cancelled.`);
+                    await refresh();
+                }
+                catch (error) {
+                    setNotice(error instanceof Error ? error.message : String(error));
+                }
+                finally {
+                    setBusy(false);
+                }
+                return;
+            case "agent-add":
+                setBusy(true);
+                try {
+                    const { agent } = await createAgent(config, { role: action.role, provider: action.provider,
+                        model: action.model, effort: action.effort, display_name: action.name ?? action.provider });
+                    say("system", `Added ${agent.display_name} (${agent.id}).`);
+                    await refresh();
+                }
+                catch (error) {
+                    setNotice(error instanceof Error ? error.message : String(error));
+                }
+                finally {
+                    setBusy(false);
+                }
+                return;
+            case "agent-rm": {
+                const matches = board.agents.filter((agent) => agent.id === action.target || agent.role === action.target);
+                if (matches.length !== 1) {
+                    setNotice(`Agent ${action.target} is missing or ambiguous; use its ID.`);
+                    return;
+                }
+                setBusy(true);
+                try {
+                    await deleteAgent(config, matches[0].id);
+                    say("system", `Removed ${matches[0].display_name}.`);
+                    await refresh();
+                }
+                catch (error) {
+                    setNotice(error instanceof Error ? error.message : String(error));
+                }
+                finally {
+                    setBusy(false);
+                }
+                return;
+            }
             case "plan":
                 setBusy(true);
                 try {

package/dist/tui/Help.js

@@ -9,13 +9,14 @@ export const COMMANDS = [
     { 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: "/cancel", args: "HD-12", help: "cancel a ticket" },
     { name: "/epic", args: "new PATH", help: "create an epic from a Markdown spec" },
     { name: "/epics", help: "list epics and ticket progress" },
     { name: "/plan", help: "author an epic with your Codex CLI" },
     { name: "/decide", args: "2 | text", help: "answer the decision on screen" },
-    { name: "/agents", help: "every agent in full, and the live run stream" },
+    { name: "/agents", args: "[add ... | rm ROLE|ID]", help: "view or manage agents" },
     { name: "/settings", help: "change provider caps and agent settings" },
-    { name: "/workspace", args: "[slug]", help: "switch workspace, or list the ones you can reach" },
+    { name: "/workspace", args: "[slug | new | set | rotate-key]", help: "list, switch, create, or configure" },
     { name: "/feed", help: "what just happened" },
     { name: "/orchestrator", help: "talk to the agent that gets work in flight finished" },
     { name: "/refresh", help: "reload the board now" },

package/dist/tui/data.js

@@ -1,4 +1,4 @@
-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 { answerDecision, cancelTicket as cancelTicketNow, createAgent as postAgent, createEpic as postEpic, getStatus, getWorkspace, listAgents, listEpics, listFeed, listMessages, listTicketEvents, listTickets, listWorkspaces, postMessage as sendMessage, queueTicket as queueTicketNow, showTicket, updateAgent as patchAgent, updateCaps, updateWorkspace as patchWorkspace, deleteAgent as removeAgent, } from "../api.js";
 import { loadConfig, switchWorkspace as selectWorkspace, } from "../config.js";
 import { readEpicSpec } from "../epics.js";
 export const POLL_MS = 5_000;
@@ -22,8 +22,9 @@ 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([
+    const [status, workspaceData, ticketData, agentData, epicData, feedData] = await Promise.all([
         getStatus(config),
+        getWorkspace(config),
         listTickets(config),
         listAgents(config),
         listEpics(config),
@@ -44,7 +45,19 @@ export async function loadSnapshot(config = loadConfig()) {
     });
     return {
         config,
-        workspace: status.workspace,
+        workspace: {
+            ...status.workspace,
+            ...workspaceData.workspace,
+            paused: status.workspace.paused,
+            provider_caps: status.workspace.provider_caps,
+            max_turns: {
+                build: Number(workspaceData.workspace.settings.max_turns?.build ?? 40),
+                followup: Number(workspaceData.workspace.settings.max_turns?.followup ?? 15),
+                review: Number(workspaceData.workspace.settings.max_turns?.review ?? 50),
+                orchestrate: Number(workspaceData.workspace.settings.max_turns?.orchestrate ?? 30),
+            },
+            max_attempts: Number(workspaceData.workspace.settings.max_attempts ?? 3),
+        },
         board: {
             tickets,
             agents: agentData.agents,
@@ -105,6 +118,15 @@ export async function createEpicFromFile(config, path) {
 export async function queueTicket(config, key) {
     return queueTicketNow(key, config);
 }
+export async function cancelTicket(config, key) {
+    return cancelTicketNow(key, config);
+}
+export async function createAgent(config, fields) {
+    return postAgent(fields, config);
+}
+export async function deleteAgent(config, id) {
+    return removeAgent(id, config);
+}
 export async function waitForReply(config, since, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() <= deadline) {
@@ -126,6 +148,9 @@ export async function updateAgent(config, id, fields) {
 export async function updateProviderCap(config, provider, cap) {
     return updateCaps({ [provider]: cap }, config);
 }
+export async function updateWorkspace(config, fields) {
+    return patchWorkspace(fields, config);
+}
 export async function loadLiveEvents(config, board) {
     const liveIds = new Set(board.runs.filter((run) => run.status === "running").map((run) => run.id));
     const keys = new Set(board.runs

package/dist/tui/parse.js

@@ -14,15 +14,33 @@ export function parseLine(raw) {
         case "orchestrator":
             return { kind: "mode", mode: "orchestrator" };
         case "board":
-        case "agents":
         case "feed":
         case "inbox":
         case "settings":
             return { kind: "view", view: word.toLowerCase() };
+        case "agents": {
+            if (!argument)
+                return { kind: "view", view: "agents" };
+            const [verb, target, ...tail] = rest;
+            if (verb === "rm" && target && !tail.length)
+                return { kind: "agent-rm", target };
+            const opts = {};
+            for (let i = 0; i < tail.length; i += 2)
+                if (tail[i]?.startsWith("--") && tail[i + 1])
+                    opts[tail[i].slice(2)] = tail[i + 1];
+            return verb === "add" && target && opts.provider && opts.model
+                ? { kind: "agent-add", role: target, provider: opts.provider, model: opts.model,
+                    ...(opts.effort ? { effort: opts.effort } : {}), ...(opts.name ? { name: opts.name } : {}) }
+                : { kind: "unknown", command: "agents needs add ROLE --provider P --model M or rm ROLE|ID" };
+        }
         case "help":
             return { kind: "help" };
         case "workspace":
         case "ws": {
+            const command = rest[0]?.toLowerCase();
+            if (command && ["new", "set", "rotate-key"].includes(command)) {
+                return { kind: "workspace-command", command: command, args: rest.slice(1) };
+            }
             return { kind: "workspace", slug: argument || null };
         }
         case "ticket":
@@ -39,6 +57,9 @@ export function parseLine(raw) {
             return argument
                 ? { kind: "queue", key: argument.toUpperCase() }
                 : { kind: "unknown", command: "queue needs a key" };
+        case "cancel":
+            return argument ? { kind: "cancel", key: argument.toUpperCase() }
+                : { kind: "unknown", command: "cancel needs a key" };
         case "plan":
             return argument ? { kind: "unknown", command: "plan takes no arguments" } : { kind: "plan" };
         case "decide": {

package/dist/tui/settings-model.js

@@ -2,8 +2,16 @@ import { efforts, providers } from "./data.js";
 export function settingsRows(workspace, agents) {
     const rows = [
         { key: "h:workspace", kind: "heading", label: workspace.slug, value: workspace.repo },
-        { key: "w:branch", kind: "readonly", label: "branch", value: workspace.default_branch },
-        { key: "w:host", kind: "readonly", label: "host", value: workspace.default_host },
+        { key: "w:name", kind: "text", label: "name", value: workspace.name },
+        { key: "w:repo", kind: "text", label: "repo", value: workspace.repo, hint: "owner/name" },
+        { key: "w:default_branch", kind: "text", label: "branch", value: workspace.default_branch },
+        { key: "w:default_host", kind: "text", label: "host", value: workspace.default_host },
+        { key: "w:auto_merge", kind: "toggle", label: "auto merge", value: workspace.auto_merge ? "yes" : "no" },
+        ...["build", "followup", "review", "orchestrate"].map((kind) => ({
+            key: `w:max_turns:${kind}`, kind: "number", label: `turns ${kind}`,
+            value: String(workspace.max_turns[kind]), hint: "integer >= 1",
+        })),
+        { key: "w:max_attempts", kind: "number", label: "max attempts", value: String(workspace.max_attempts) },
     ];
     for (const provider of providers) {
         rows.push({
@@ -16,6 +24,7 @@ export function settingsRows(workspace, agents) {
     }
     for (const agent of agents) {
         rows.push({ key: `h:${agent.id}`, kind: "heading", label: agent.display_name, value: agent.role });
+        rows.push({ key: `a:${agent.id}:display_name`, kind: "text", label: "name", value: agent.display_name });
         rows.push({
             key: `a:${agent.id}:enabled`, kind: "toggle", label: "enabled",
             value: agent.enabled ? "yes" : "no", agent: agent.display_name,
@@ -59,6 +68,25 @@ export function editFor(row, raw) {
             return { ok: false, error: `${field} cap must be an integer >= 0.` };
         return { ok: true, value: { target: "cap", provider: field, cap } };
     }
+    if (scope === "w" && id) {
+        if (id === "max_turns" && field) {
+            const number = Number(value);
+            if (!Number.isInteger(number) || number < 1)
+                return { ok: false, error: `max_turns.${field} must be an integer >= 1.` };
+            return { ok: true, value: { target: "workspace", fields: { max_turns: { [field]: number } } } };
+        }
+        if (id === "max_attempts") {
+            const number = Number(value);
+            if (!Number.isInteger(number) || number < 1)
+                return { ok: false, error: "max_attempts must be an integer >= 1." };
+            return { ok: true, value: { target: "workspace", fields: { max_attempts: number } } };
+        }
+        if (id === "auto_merge")
+            return { ok: true, value: { target: "workspace", fields: { auto_merge: value === "yes" } } };
+        if (!value)
+            return { ok: false, error: `${row.label} is required.` };
+        return { ok: true, value: { target: "workspace", fields: { [id]: value } } };
+    }
     if (scope !== "a" || !id || !field)
         return { ok: false, error: `Nothing to change on ${row.label}.` };
     if (field === "enabled") {

package/dist/workspace-commands.js

@@ -0,0 +1,170 @@
+import { createInterface } from "node:readline/promises";
+import { createWorkspace, rotateWorkspaceApiKey, updateWorkspace } from "./api.js";
+import { loadConfig, writeHdConfig } from "./config.js";
+import { defaultGh, HDX_RUNNER_GH_USER, preflightWorkspace } from "./workspace-preflight.js";
+export const WORKSPACE_USAGE = "usage: hd workspace ls | new --name NAME --repo OWNER/NAME [--create|--no-create] [flags] | set [flags] | rotate-key";
+function flags(argv) {
+    const opts = {};
+    const bools = new Set();
+    const rest = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (!arg.startsWith("--")) {
+            rest.push(arg);
+            continue;
+        }
+        const next = argv[i + 1];
+        if (next && !next.startsWith("-")) {
+            opts[arg.slice(2)] = next;
+            i += 1;
+        }
+        else
+            bools.add(arg.slice(2));
+    }
+    return { opts, bools, rest };
+}
+export function workspaceSlug(name) {
+    return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "workspace";
+}
+function yes(answer) {
+    return !["n", "no"].includes(answer.trim().toLowerCase());
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function repoState(repo, gh) {
+    try {
+        const value = JSON.parse(await gh(["repo", "view", repo, "--json", "defaultBranchRef"]));
+        return { found: true, branch: value.defaultBranchRef?.name };
+    }
+    catch (error) {
+        if (/404|not found|could not resolve/i.test(message(error)))
+            return { found: false };
+        throw error;
+    }
+}
+function lazyPrompt(deps) {
+    let readline;
+    const ask = deps.prompt ?? (async (question) => {
+        readline ??= createInterface({ input: process.stdin, output: process.stdout });
+        return readline.question(question);
+    });
+    return { ask, close: () => readline?.close() };
+}
+async function askDefault(ask, label, fallback = "") {
+    const answer = (await ask(`${label}${fallback ? ` [${fallback}]` : ""}: `)).trim();
+    return answer || fallback;
+}
+export async function workspaceNew(argv, deps = {}) {
+    const { opts, bools, rest } = flags(argv);
+    if (rest.length || (bools.has("create") && bools.has("no-create")))
+        throw new Error(WORKSPACE_USAGE);
+    const interactive = deps.isTTY ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const guided = !opts.name || !opts.repo;
+    if (guided && !interactive)
+        throw new Error(WORKSPACE_USAGE);
+    const gh = deps.gh ?? defaultGh;
+    const prompt = lazyPrompt(deps);
+    try {
+        let name = opts.name ?? "";
+        let repo = opts.repo ?? "";
+        let branch = opts.branch;
+        let host = opts.host ?? "box";
+        if (guided || interactive || bools.has("create") || bools.has("no-create")) {
+            try {
+                await gh(["--version"]);
+            }
+            catch {
+                throw new Error("GitHub CLI is unavailable. Install it if needed, then run `gh auth login`.");
+            }
+        }
+        if (guided) {
+            name = await askDefault(prompt.ask, "Name", name);
+            if (!name)
+                throw new Error("Name is required.");
+            let defaultRepo = repo;
+            if (!defaultRepo) {
+                const owner = (await gh(["api", "user", "--jq", ".login"])).trim();
+                defaultRepo = `${owner}/${workspaceSlug(name)}`;
+            }
+            repo = await askDefault(prompt.ask, "Repo", defaultRepo);
+            if (!repo)
+                throw new Error("Repo is required.");
+        }
+        let state;
+        if (guided || interactive || bools.has("create") || bools.has("no-create"))
+            state = await repoState(repo, gh);
+        if (state && !state.found) {
+            if (bools.has("no-create"))
+                throw new Error(`GitHub repository ${repo} does not exist and --no-create was set.`);
+            const create = bools.has("create") || (interactive && yes(await prompt.ask(`Create ${repo} as a private GitHub repo? [Y/n] `)));
+            if (!create)
+                throw new Error(`GitHub repository ${repo} was not created.`);
+            await gh(["repo", "create", repo, "--private"]);
+            state = { found: true, branch: "main" };
+        }
+        if (guided) {
+            branch = await askDefault(prompt.ask, "Branch", branch ?? state?.branch ?? "main");
+            host = await askDefault(prompt.ask, "Host", host);
+            const summary = `${name} | ${repo} | ${branch} | host ${host}`;
+            if (!yes(await prompt.ask(`Create ${summary}. Proceed? [Y/n] `)))
+                throw new Error("Workspace creation cancelled.");
+        }
+        const preflight = await (deps.preflightWorkspace ?? preflightWorkspace)({
+            name, repo, branch, noBootstrap: bools.has("no-bootstrap"),
+            runnerUser: opts["runner-user"] ?? HDX_RUNNER_GH_USER,
+        }, gh);
+        const result = await createWorkspace({ name, repo, slug: opts.slug,
+            default_branch: preflight.branch, default_host: host });
+        writeHdConfig({ url: result.url, api_key: result.api_key, slug: result.workspace.slug });
+        return { slug: result.workspace.slug, repo: result.workspace.repo,
+            invitationPending: preflight.invitationPending,
+            runnerUser: opts["runner-user"] ?? HDX_RUNNER_GH_USER,
+            initCommand: `hd init --url ${result.url} --api-key ${result.api_key} --slug ${result.workspace.slug}` };
+    }
+    finally {
+        prompt.close();
+    }
+}
+export async function workspaceSet(argv) {
+    const { opts, bools, rest } = flags(argv);
+    if (rest.length || bools.size)
+        throw new Error(WORKSPACE_USAGE);
+    const fields = {};
+    for (const [flag, field] of [["name", "name"], ["repo", "repo"], ["branch", "default_branch"], ["host", "default_host"]]) {
+        if (opts[flag])
+            fields[field] = opts[flag];
+    }
+    if (opts["auto-merge"]) {
+        if (!["on", "off"].includes(opts["auto-merge"]))
+            throw new Error("--auto-merge must be on or off");
+        fields.auto_merge = opts["auto-merge"] === "on";
+    }
+    if (opts["max-turns"]) {
+        const turns = {};
+        for (const entry of opts["max-turns"].split(",")) {
+            const [kind, raw, ...extra] = entry.split("=");
+            const value = Number(raw);
+            if (extra.length || !["build", "followup", "review", "orchestrate"].includes(kind)
+                || !Number.isInteger(value) || value < 1)
+                throw new Error("--max-turns must be KIND=N[,KIND=N...]");
+            turns[kind] = value;
+        }
+        fields.max_turns = turns;
+    }
+    if (opts["max-attempts"]) {
+        const value = Number(opts["max-attempts"]);
+        if (!Number.isInteger(value) || value < 1)
+            throw new Error("--max-attempts must be an integer >= 1");
+        fields.max_attempts = value;
+    }
+    if (!Object.keys(fields).length)
+        throw new Error(WORKSPACE_USAGE);
+    return (await updateWorkspace(fields)).workspace;
+}
+export async function workspaceRotateKey() {
+    const config = loadConfig();
+    const { api_key } = await rotateWorkspaceApiKey(config);
+    writeHdConfig({ ...config, api_key });
+    return { apiKey: api_key, slug: config.slug };
+}

package/dist/workspace-preflight.js

@@ -19,7 +19,7 @@ function errorMessage(error) {
     const value = error;
     return value.stderr?.trim() || value.message || String(error);
 }
-async function defaultGh(args) {
+export async function defaultGh(args) {
     try {
         return (await exec("gh", args, { encoding: "utf8", maxBuffer: 1024 * 1024 })).stdout;
     }

package/package.json

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