@higherdev/cli 0.8.0 → 0.10.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]` | Create a paused workspace |
+| `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 |
@@ -48,7 +54,11 @@ workspace-map config shapes are migrated automatically when they are read.
 | `hd init [options]` | Configure this host and runner service |
 | `hd upgrade [options]` | Refresh this host configuration |
 
-Inside the TUI, use `/board`, `/inbox`, `/ticket`, `/queue`, `/epic new`,
-`/epics`, `/plan`, `/decide`, `/agents`, `/settings`, `/workspace`, `/feed`,
+`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.
+
+Inside the TUI, use `/board`, `/inbox`, `/ticket`, `/queue`, `/cancel`, `/epic new`,
+`/epics`, `/plan`, `/decide`, `/agents add`, `/agents rm`, `/settings`, `/workspace`, `/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,12 +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, createWorkspace, deleteAgent, getStatus, listAgents, listEpics, listTicketEvents, listTickets, listWorkspaces, postMessage, queueTicket, rotateWorkspaceApiKey, setPaused, showTicket, updateAgent, updateCaps, updateWorkspace, } from "./api.js";
 import { initHost, parseHostFlags } from "./host.js";
 import { loadConfig, writeHdConfig } 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";
 function fail(message) {
     console.error(message);
     process.exit(1);
@@ -118,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;
@@ -218,7 +227,7 @@ async function cmdDecide(argv) {
     await answerDecision(id, opts.answer);
     console.log("answered");
 }
-async function cmdWorkspace(argv) {
+async function cmdWorkspace(argv, deps = {}) {
     const [action, ...rest] = argv;
     if (action === "ls") {
         const current = loadConfig().slug;
@@ -232,24 +241,80 @@ async function cmdWorkspace(argv) {
         ])));
         return;
     }
+    const workspaceUsage = "usage: hd workspace ls | new ... | set [flags] | rotate-key";
+    if (action === "rotate-key") {
+        const config = loadConfig();
+        const { api_key } = await rotateWorkspaceApiKey(config);
+        writeHdConfig({ ...config, api_key });
+        console.log(`api key: ${api_key}`);
+        console.log("saved locally; update Mel's hd init configuration on the box.");
+        return;
+    }
+    if (action === "set") {
+        const { rest: args, opts, bools } = flags(rest);
+        if (args.length || bools.size)
+            fail(workspaceUsage);
+        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"]))
+                fail("--auto-merge must be on or off");
+            fields.auto_merge = opts["auto-merge"] === "on";
+        }
+        if (opts["max-turns"]) {
+            const maxTurns = {};
+            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) {
+                    fail("--max-turns must be KIND=N[,KIND=N...] for build, followup, review, or orchestrate");
+                }
+                maxTurns[kind] = value;
+            }
+            fields.max_turns = maxTurns;
+        }
+        if (opts["max-attempts"]) {
+            const value = Number(opts["max-attempts"]);
+            if (!Number.isInteger(value) || value < 1)
+                fail("--max-attempts must be an integer >= 1");
+            fields.max_attempts = value;
+        }
+        if (!Object.keys(fields).length)
+            fail(workspaceUsage);
+        const { workspace } = await updateWorkspace(fields);
+        console.log(`${workspace.slug}  ${workspace.name}  ${workspace.repo}`);
+        return;
+    }
     if (action !== "new")
-        fail("usage: hd workspace ls | new --name NAME --repo OWNER/NAME [--slug S] [--branch main] [--host box]");
-    const { opts } = flags(rest);
+        fail(workspaceUsage);
+    const { opts, bools } = flags(rest);
     if (!opts.name || !opts.repo) {
-        fail("usage: hd workspace new --name NAME --repo OWNER/NAME [--slug S] [--branch main] [--host box]");
+        fail(workspaceUsage);
     }
+    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: opts.branch ?? "main", default_host: opts.host ?? "box" });
+        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 });
     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}`);
 }
-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) {
@@ -260,26 +325,59 @@ 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)) {
+export async function main(argv = process.argv.slice(2), deps = {}) {
     const [cmd, ...rest] = argv;
     try {
         if (!cmd) {
@@ -329,13 +427,17 @@ export async function main(argv = process.argv.slice(2)) {
             return;
         }
         if (cmd === "workspace") {
-            await cmdWorkspace(rest);
+            await cmdWorkspace(rest, deps);
             return;
         }
         if (cmd === "agents") {
             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

@@ -16,7 +16,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 +149,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();
         }
@@ -348,6 +351,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,11 +9,12 @@ 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: "/feed", help: "what just happened" },

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,11 +14,25 @@ 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":
@@ -39,6 +53,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-preflight.js

@@ -0,0 +1,77 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+export const HDX_RUNNER_GH_USER = "mel-ilotus";
+export function preflightDecision(input) {
+    if (!input.found)
+        return { ok: false, error: "Repository was not found or is inaccessible." };
+    if (input.viewerPermission.toUpperCase() !== "ADMIN") {
+        return { ok: false, error: `Repository admin permission is required; viewer has ${input.viewerPermission || "none"}.` };
+    }
+    if (input.empty && input.noBootstrap) {
+        return { ok: false, error: "Repository is empty and --no-bootstrap was set." };
+    }
+    return { ok: true, bootstrap: input.empty };
+}
+function errorMessage(error) {
+    if (!error || typeof error !== "object")
+        return String(error);
+    const value = error;
+    return value.stderr?.trim() || value.message || String(error);
+}
+async function defaultGh(args) {
+    try {
+        return (await exec("gh", args, { encoding: "utf8", maxBuffer: 1024 * 1024 })).stdout;
+    }
+    catch (error) {
+        throw new Error(errorMessage(error));
+    }
+}
+async function repoView(repo, gh) {
+    return JSON.parse(await gh(["repo", "view", repo, "--json", "defaultBranchRef,isEmpty,viewerPermission"]));
+}
+function canPush(permission) {
+    return ["admin", "maintain", "write", "push"].includes(permission.toLowerCase());
+}
+export async function preflightWorkspace(input, gh = defaultGh) {
+    try {
+        await gh(["--version"]);
+    }
+    catch {
+        throw new Error("GitHub CLI is unavailable. Install it if needed, then run `gh auth login`.");
+    }
+    let view;
+    try {
+        view = await repoView(input.repo, gh);
+    }
+    catch (error) {
+        throw new Error(`GitHub repository ${input.repo} was not found or is inaccessible: ${errorMessage(error)}`);
+    }
+    const decision = preflightDecision({ found: true, empty: view.isEmpty,
+        viewerPermission: view.viewerPermission, noBootstrap: input.noBootstrap });
+    if (!decision.ok)
+        throw new Error(decision.error);
+    if (decision.bootstrap) {
+        await gh(["api", "-X", "PUT", `repos/${input.repo}/contents/README.md`,
+            "-f", "message=Initial commit", "-f", `content=${Buffer.from(`# ${input.name}`).toString("base64")}`]);
+        view = await repoView(input.repo, gh);
+    }
+    const branch = input.branch || view.defaultBranchRef?.name;
+    if (!branch)
+        throw new Error(`GitHub repository ${input.repo} has no default branch.`);
+    const runnerUser = input.runnerUser || HDX_RUNNER_GH_USER;
+    let permission = "none";
+    try {
+        const result = JSON.parse(await gh(["api", `repos/${input.repo}/collaborators/${runnerUser}/permission`]));
+        permission = result.permission ?? "none";
+    }
+    catch (error) {
+        if (!/404|not found/i.test(errorMessage(error)))
+            throw error;
+    }
+    const invitationPending = !canPush(permission);
+    if (invitationPending) {
+        await gh(["api", "-X", "PUT", `repos/${input.repo}/collaborators/${runnerUser}`, "-f", "permission=push"]);
+    }
+    return { branch, invitationPending };
+}

package/package.json

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