@higherdev/cli 0.37.0 → 0.39.0

package/README.md

@@ -32,9 +32,10 @@ workspace-map config shapes are migrated automatically when they are read.
 | `hd ticket cancel KEY` | Cancel a ticket |
 | `hd epic new PATH [--title TITLE] [--draft]` | Create an approved epic, or keep it as a draft |
 | `hd epic list` | List epics and ticket progress |
-| `hd epic approve ID` | Open a draft epic for orchestrator decomposition |
+| `hd epic approve ID` | Open a draft epic for Delivery Manager decomposition |
 | `hd epic rm ID` | Remove a draft epic |
-| `hd plan` | Point to the TUI `/architect` conversation |
+| `hd product` (`hd plan`) | Point to the TUI Product Manager conversation |
+| `hd architect` | Point to the TUI Architect design conversation |
 | `hd workspace ls` | List every workspace available to the configured key |
 | `hd workspace use SLUG` | Switch the current workspace |
 | `hd workspace new --name NAME --repo OWNER/NAME [options]` | Preflight GitHub, wire the runner, and create a paused workspace |
@@ -102,10 +103,10 @@ Use `hd host env set SUPABASE_ACCESS_TOKEN=... SUPABASE_ORG_ID=...` once to let
 Supabase for workspaces assigned to that host. Host values are never passed to builder processes.
 Use `hd host env set VERCEL_TOKEN=... VERCEL_TEAM_ID=...` to let the runner adopt or provision a linked
 Vercel project. It syncs `NEXT_PUBLIC_*`, names listed in `settings.vercel.env`, and existing Vercel-held names
-to production and preview. Later `hd env set` changes wake the orchestrator to update matching Vercel variables.
+to production and preview. Later `hd env set` changes wake the Delivery Manager to update matching Vercel variables.
 
 Inside the TUI, use `/board`, `/inbox`, `/inbox more`, `/ticket`, `/ticket new [PATH.md]`, `/queue`, `/cancel`, `/msg`, `/logs`, `/epic new`,
-`/epic approve`, `/epic rm`, `/epics`, `/architect` (or `/plan`), `/decide`, `/agents add`, `/agents rm`, `/env`, `/settings`, `/workspace`,
+`/epic approve`, `/epic rm`, `/epics`, `/product` (or `/plan`), `/architect`, `/decide`, `/agents add`, `/agents rm`, `/env`, `/settings`, `/workspace`,
 `/workspace new`, `/workspace set`, `/workspace rotate-key`, `/workspace grant-runner-access`, `/feed`,
 `/on`, `/off`, `/orchestrator`, `/refresh`, `/help`, or `/exit`. The display refreshes from
 the HDX API every five seconds.

package/dist/agent-commands.js

@@ -2,7 +2,7 @@ import { createAgent, getStatus, listAgents } from "./api.js";
 import { promptOnStdin } from "./prompt.js";
 export const AGENT_ADD_USAGE = "usage: hd agents add [ROLE] --name NAME --provider P --model M --effort E";
 const EFFORTS = ["low", "medium", "high"];
-const ROLES = ["architect", "orchestrator", "reviewer", "builder"];
+const ROLES = ["product", "architect", "orchestrator", "reviewer", "builder"];
 function parse(argv) {
     const opts = {};
     const rest = [];

package/dist/api.js

@@ -4,7 +4,7 @@ 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_(architect|orchestrator|reviewer)_idx/i)?.[1]?.toLowerCase();
+    const duplicate = raw.match(/agents_one_enabled_(product|architect|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.`;
     }

package/dist/attachments.js

@@ -1,5 +1,5 @@
-import { readFile, stat } from "node:fs/promises";
-import { isAbsolute, basename, extname } from "node:path";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { isAbsolute, basename, extname, join } from "node:path";
 import { loadConfig } from "./config.js";
 const MIME = {
     ".avif": "image/avif", ".bmp": "image/bmp", ".gif": "image/gif", ".heic": "image/heic",
@@ -8,6 +8,9 @@ const MIME = {
     ".text": "text/plain", ".md": "text/markdown", ".markdown": "text/markdown",
     ".json": "application/json", ".csv": "text/csv",
 };
+export const MAX_ATTACHMENTS_PER_DROP = 20;
+export const PATH_DOES_NOT_EXIST = "That path does not exist";
+const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
 export function formatAttachmentBytes(size) {
     if (size < 1024)
         return `${size} B`;
@@ -74,28 +77,46 @@ export function parseAttachArgs(argv) {
         }
         if (arg === "--to") {
             const role = argv[++at];
-            if (role === "architect" || role === "orchestrator")
+            if (role === "product" || role === "architect" || role === "orchestrator")
                 to = role;
             else
-                throw new Error("--to must be architect or orchestrator.");
+                throw new Error("--to must be product, architect, or orchestrator.");
             continue;
         }
         rest.push(arg);
     }
-    if (rest.length !== 1 || Boolean(ticketKey) === Boolean(to)) {
-        throw new Error("usage: hd attach PATH --ticket KEY | --to architect|orchestrator");
+    if (!rest.length || Boolean(ticketKey) === Boolean(to)) {
+        throw new Error("usage: hd attach PATH [PATH...] --ticket KEY | --to product|architect|orchestrator");
     }
     if (ticketKey && !/^HD-[1-9][0-9]*$/i.test(ticketKey))
         throw new Error("--ticket must be an HD-N key.");
-    return { path: rest[0], ...(ticketKey ? { ticketKey } : {}), ...(to ? { to } : {}) };
+    return { paths: rest, ...(ticketKey ? { ticketKey } : {}), ...(to ? { to } : {}) };
 }
 export function parseTuiAttach(text) {
     const words = shellWords(text.trim());
     if (!words?.length)
         return null;
-    const key = words.at(-1)?.match(/^HD-[1-9][0-9]*$/i)?.[0].toUpperCase();
-    const paths = key ? words.slice(0, -1) : words;
-    return paths.length === 1 ? { path: paths[0], ...(key ? { ticketKey: key } : {}) } : null;
+    const rest = [];
+    let to;
+    for (let at = 0; at < words.length; at += 1) {
+        if (words[at] !== "--to") {
+            rest.push(words[at]);
+            continue;
+        }
+        const role = words[++at];
+        if (role !== "product" && role !== "architect" && role !== "orchestrator")
+            return null;
+        to = role;
+    }
+    const key = rest.at(-1)?.match(/^HD-[1-9][0-9]*$/i)?.[0].toUpperCase();
+    const paths = key ? rest.slice(0, -1) : rest;
+    if (!paths.length || (key && to))
+        return null;
+    return { paths, ...(key ? { ticketKey: key } : {}), ...(to ? { to } : {}) };
+}
+export function absolutePathInput(text) {
+    const words = shellWords(text.trim());
+    return words?.length && words.every(isAbsolute) ? words : [];
 }
 /**
  * Text that a Finder drop produces: one or more absolute paths, plain, quoted, or with
@@ -111,23 +132,80 @@ export function looksLikeDroppedPaths(text) {
     const firstWord = trimmed.split(/\s+/)[0].replace(/^['"]/, "");
     return firstWord.slice(1).includes("/") || /^['"]/.test(trimmed);
 }
-export async function detectDroppedPaths(pasted, isFile = async (path) => (await stat(path)).isFile()) {
-    const text = pasted.trim();
-    if (!text)
-        return [];
-    if (isAbsolute(text) && await isFile(text).catch(() => false))
-        return [text];
-    const words = shellWords(text);
-    if (!words?.length || words.some((path) => !isAbsolute(path)))
-        return [];
-    const checks = await Promise.all(words.map((path) => isFile(path).catch(() => false)));
-    return checks.every(Boolean) ? words : [];
+async function collectFiles(input, files) {
+    const info = await stat(input);
+    if (info.isFile()) {
+        files.push(input);
+        return;
+    }
+    if (!info.isDirectory())
+        return;
+    const entries = await readdir(input, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        const child = join(input, entry.name);
+        if (entry.isDirectory())
+            await collectFiles(child, files);
+        else if (entry.isFile())
+            files.push(child);
+    }
+}
+export async function expandAttachmentPaths(inputs, limit = MAX_ATTACHMENTS_PER_DROP) {
+    const files = [];
+    const missing = [];
+    let existingInputs = 0;
+    for (const input of inputs) {
+        try {
+            await collectFiles(input, files);
+            existingInputs += 1;
+        }
+        catch (error) {
+            if (["ENOENT", "ENOTDIR"].includes(error.code ?? ""))
+                missing.push(input);
+            else
+                throw error;
+        }
+    }
+    const unique = [...new Set(files)].sort((left, right) => left.localeCompare(right));
+    const skipped = { unsupported: 0, tooLarge: 0, limit: 0 };
+    const allowed = [];
+    for (const file of unique) {
+        if (!MIME[extname(file).toLowerCase()]) {
+            skipped.unsupported += 1;
+            continue;
+        }
+        if ((await stat(file)).size > MAX_ATTACHMENT_BYTES) {
+            skipped.tooLarge += 1;
+            continue;
+        }
+        if (allowed.length >= limit) {
+            skipped.limit += 1;
+            continue;
+        }
+        allowed.push(file);
+    }
+    return { paths: allowed, missing, existingInputs, skipped };
+}
+export function attachmentSkipNote(expansion) {
+    const reasons = [];
+    if (expansion.skipped.unsupported)
+        reasons.push(`${expansion.skipped.unsupported} unsupported type${expansion.skipped.unsupported === 1 ? "" : "s"}`);
+    if (expansion.skipped.tooLarge)
+        reasons.push(`${expansion.skipped.tooLarge} over 20 MB`);
+    if (expansion.skipped.limit)
+        reasons.push(`${expansion.skipped.limit} beyond the 20-file limit`);
+    const count = expansion.skipped.unsupported + expansion.skipped.tooLarge + expansion.skipped.limit;
+    return count ? `Skipped ${count} file${count === 1 ? "" : "s"}: ${reasons.join(", ")}.` : null;
+}
+export async function detectDroppedPaths(pasted) {
+    const paths = absolutePathInput(pasted);
+    return paths.length ? (await expandAttachmentPaths(paths)).paths : [];
 }
 export async function uploadAttachment(path, target = {}, config = loadConfig(), fetchImpl = fetch) {
     const info = await stat(path);
     if (!info.isFile())
         throw new Error(`${path} is not a file.`);
-    if (info.size > 20 * 1024 * 1024)
+    if (info.size > MAX_ATTACHMENT_BYTES)
         throw new Error("Attachments must be 20 MB or smaller.");
     const mime = MIME[extname(path).toLowerCase()];
     if (!mime)

package/dist/index.js

@@ -13,7 +13,7 @@ import { banner, c, statusChip, table, truncate, usage } from "./out.js";
 import { ticketNew } from "./ticket-commands.js";
 import { ticketViewLines } from "./tui/ticket-view.js";
 import { agentAdd, AGENT_ADD_USAGE } from "./agent-commands.js";
-import { attachmentChip, parseAttachArgs, uploadAttachment } from "./attachments.js";
+import { attachmentChip, attachmentSkipNote, expandAttachmentPaths, parseAttachArgs, PATH_DOES_NOT_EXIST, uploadAttachment } from "./attachments.js";
 import { WORKSPACE_USAGE, workspaceGrantRunnerAccess, workspaceNew, workspaceRotateKey, workspaceSet, workspaceUse } from "./workspace-commands.js";
 import { defaultGh, hasWriteRepoPermission, HDX_RUNNER_GH_USER, requireAdminRepo, runnerRepoPermission } from "./workspace-preflight.js";
 function fail(message) {
@@ -261,10 +261,10 @@ async function cmdRoadmap(argv) {
     for (const line of roadmapText(data.epics))
         console.log(line);
 }
-async function cmdPlan(argv) {
+async function cmdChat(argv, role) {
     if (argv.length)
-        fail("usage: hd plan");
-    console.log("Open the HDX TUI and use /architect (or /plan).");
+        fail(`usage: hd ${role}`);
+    console.log(`Open the HDX TUI and use /${role}${role === "product" ? " (or /plan)" : ""}.`);
 }
 async function cmdLogs(argv) {
     const { rest, bools } = flags(argv);
@@ -309,14 +309,26 @@ async function cmdMsg(argv) {
     });
     console.log(`sent ${message.id}`);
 }
-export async function cmdAttach(argv) {
+export async function cmdAttach(argv, deps = {}) {
     const parsed = parseAttachArgs(argv);
-    const attachment = await uploadAttachment(parsed.path, parsed.ticketKey ? { ticketKey: parsed.ticketKey } : {});
-    if (parsed.to) {
-        await postMessage({ body_md: `Attached ${attachment.name}.`, to_role: parsed.to, delivery: "queue",
-            attachment_ids: [attachment.id] });
-    }
-    console.log(`${attachmentChip(attachment)}${parsed.ticketKey ? ` attached to ${parsed.ticketKey}` : ` sent to ${parsed.to}`}`);
+    const expansion = await expandAttachmentPaths(parsed.paths);
+    if (expansion.missing.length)
+        throw new Error(PATH_DOES_NOT_EXIST);
+    const note = attachmentSkipNote(expansion);
+    if (!expansion.paths.length)
+        throw new Error(["No supported files found.", note].filter(Boolean).join(" "));
+    const config = deps.config ?? loadConfig();
+    const attachments = [];
+    for (const path of expansion.paths)
+        attachments.push(await uploadAttachment(path, {}, config, deps.fetch));
+    await (deps.postMessage ?? postMessage)({ body_md: `Attached ${attachments.length} files`,
+        to_role: parsed.to ?? "builder", delivery: "queue", ...(parsed.ticketKey ? { ticket_key: parsed.ticketKey } : {}),
+        attachment_ids: attachments.map((item) => item.id) }, config);
+    for (const attachment of attachments)
+        console.log(attachmentChip(attachment));
+    console.log(`Attached ${attachments.length} files${parsed.ticketKey ? ` to ${parsed.ticketKey}` : ` to ${parsed.to}`}.`);
+    if (note)
+        console.log(note);
 }
 async function cmdInbox(argv) {
     const { rest, opts, bools } = flags(argv);
@@ -713,8 +725,12 @@ export async function main(argv = process.argv.slice(2), deps = {}) {
             await cmdRoadmap(rest);
             return;
         }
-        if (cmd === "plan") {
-            await cmdPlan(rest);
+        if (cmd === "plan" || cmd === "product") {
+            await cmdChat(rest, "product");
+            return;
+        }
+        if (cmd === "architect") {
+            await cmdChat(rest, "architect");
             return;
         }
         if (cmd === "logs") {

package/dist/out.js

@@ -68,7 +68,7 @@ export function usage() {
         `  ${c.blue("hd runs | hd run cancel ID")}          inspect or cancel live runs`,
         `  ${c.blue("hd epic new PATH [--draft] | list | approve | rm")} epic operations`,
         `  ${c.blue("hd roadmap [--json]")}               ordered workspace roadmap`,
-        `  ${c.blue("hd plan")}                           use /architect in the TUI`,
+        `  ${c.blue("hd product | hd architect")}          open a role chat in the TUI`,
         `  ${c.blue("hd workspace ls | use | new | set | rotate-key | grant-runner-access")} workspace operations`,
         `  ${c.blue("hd agents [add | rm | set]")}         manage agents`,
         `  ${c.blue("hd caps [set PROVIDER N]")}           provider concurrency`,
@@ -76,7 +76,7 @@ export function usage() {
         `  ${c.blue("hd host runner-install | roll | env")} install CI, roll, or edit host env`,
         `  ${c.blue("hd logs KEY [-f]")}                  run events`,
         `  ${c.blue("hd msg KEY TEXT")}                   message a builder`,
-        `  ${c.blue("hd attach PATH --ticket KEY | --to ROLE")} attach a file`,
+        `  ${c.blue("hd attach PATH... --ticket KEY | --to ROLE")} attach files or a folder`,
         `  ${c.blue("hd inbox [--all] [--limit N] [--json]")} inbox messages`,
         `  ${c.blue("hd decide [ID --answer TEXT]")}      decisions`,
         `  ${c.blue("hd on | hd off")}                    workspace switch`,

package/dist/tui/App.js

@@ -33,7 +33,7 @@ import { editFor, editableKeys, nextValue, seedFor, settingsRows } from "./setti
 import { appendLines, runLabels, toStreamLines } from "./stream.js";
 import { UI } from "./theme.js";
 import { WorkspaceLoads } from "./workspace-load.js";
-import { attachmentChip, detectDroppedPaths, looksLikeDroppedPaths, uploadAttachment } from "../attachments.js";
+import { absolutePathInput, attachmentChip, attachmentSkipNote, expandAttachmentPaths, looksLikeDroppedPaths, MAX_ATTACHMENTS_PER_DROP, PATH_DOES_NOT_EXIST, uploadAttachment } from "../attachments.js";
 let messageSeq = 0;
 const nextId = () => `m${messageSeq++}`;
 const tuiPrompt = (question) => promptOnStdin(question, true);
@@ -456,31 +456,43 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
             }
         })();
     }, [agentName, config, pendingAttachments, setThread, workspace.id]);
+    const uploadExpanded = useCallback(async (inputs, target = {}, prepared, limit = MAX_ATTACHMENTS_PER_DROP) => {
+        const expansion = prepared ?? await expandAttachmentPaths(inputs, limit);
+        if (expansion.missing.length)
+            throw new Error(PATH_DOES_NOT_EXIST);
+        const note = attachmentSkipNote(expansion);
+        if (!expansion.paths.length)
+            throw new Error(["No supported files found.", note].filter(Boolean).join(" "));
+        const uploaded = [];
+        for (const path of expansion.paths) {
+            try {
+                uploaded.push(await uploadAttachment(path, { ...target, onProgress: (progress) => setAttachmentUploads((current) => ({ ...current, [path]: progress })) }, config));
+            }
+            finally {
+                setAttachmentUploads((current) => {
+                    const next = { ...current };
+                    delete next[path];
+                    return next;
+                });
+            }
+        }
+        return { uploaded, note };
+    }, [config, pendingAttachments.length]);
     const receiveDrop = useCallback((pasted) => {
         if (!looksLikeDroppedPaths(pasted))
             return false;
         void (async () => {
-            const paths = await detectDroppedPaths(pasted);
-            if (!paths.length) {
+            const inputs = absolutePathInput(pasted);
+            if (!inputs.length) {
                 setDraft((current) => current + pasted.replace(/[\r\n]+/g, " "));
                 return;
             }
             setBusy(true);
             try {
-                const uploaded = [];
-                for (const path of paths) {
-                    try {
-                        uploaded.push(await uploadAttachment(path, { onProgress: (progress) => setAttachmentUploads((current) => ({ ...current, [path]: progress })) }, config));
-                    }
-                    finally {
-                        setAttachmentUploads((current) => {
-                            const next = { ...current };
-                            delete next[path];
-                            return next;
-                        });
-                    }
-                }
+                const { uploaded, note } = await uploadExpanded(inputs, {}, undefined, Math.max(0, MAX_ATTACHMENTS_PER_DROP - pendingAttachments.length));
                 setPendingAttachments((current) => [...current, ...uploaded]);
+                if (note)
+                    setNotice(note);
             }
             catch (error) {
                 setNotice(error instanceof Error ? error.message : String(error));
@@ -490,7 +502,7 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
             }
         })();
         return true;
-    }, [config]);
+    }, [uploadExpanded]);
     const openTicket = useCallback(async (key) => {
         setTicketKey(key);
         setView("ticket");
@@ -520,11 +532,27 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
     }, [view, ticketKey, visibleStory?.latest_headline, visibleStory?.timeline, config]);
     const run = useCallback(async (raw) => {
         const text = raw.trim();
-        // A dropped path that reached the line as typed text is an attachment, not a command.
-        if (looksLikeDroppedPaths(text) && (await detectDroppedPaths(text)).length) {
-            setDraft("");
-            receiveDrop(text);
-            return;
+        // An existing absolute path always wins over slash-command parsing in every view.
+        const absolutePaths = absolutePathInput(text);
+        if (absolutePaths.length) {
+            const expansion = await expandAttachmentPaths(absolutePaths, Math.max(0, 20 - pendingAttachments.length));
+            if (expansion.existingInputs) {
+                setDraft("");
+                setBusy(true);
+                try {
+                    const { uploaded, note } = await uploadExpanded(absolutePaths, {}, expansion);
+                    setPendingAttachments((current) => [...current, ...uploaded]);
+                    if (note)
+                        setNotice(note);
+                }
+                catch (error) {
+                    setNotice(error instanceof Error ? error.message : String(error));
+                }
+                finally {
+                    setBusy(false);
+                }
+                return;
+            }
         }
         if (view === "settings") {
             const open = editingRef.current;
@@ -588,11 +616,15 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
         setDraft("");
         setNotice(null);
         const action = parseLine(text);
+        if (absolutePaths.length && action.kind === "unknown") {
+            setNotice(PATH_DOES_NOT_EXIST);
+            return;
+        }
         if (action.kind === "say") {
             if (mode !== "browse")
                 askAgent(mode, text);
             else
-                setNotice("Use /architect or /orchestrator before sending a message.");
+                setNotice("Use /product, /architect, or /orchestrator before sending a message.");
             return;
         }
         switch (action.kind) {
@@ -886,12 +918,26 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
             case "attach":
                 setBusy(true);
                 try {
-                    const key = action.key ?? ticketKey;
-                    if (!key)
-                        throw new Error("Open a ticket or include its HD-N key.");
-                    const attachment = await uploadAttachment(action.path, { ticketKey: key }, config);
-                    say("system", `${attachmentChip(attachment)} attached to ${key}.`);
-                    await refresh();
+                    const key = action.key ?? (view === "ticket" ? ticketKey : null);
+                    if (!key && !action.to && view !== "chat") {
+                        throw new Error("Choose a target: open a ticket, add HD-N, or use --to product|architect|orchestrator.");
+                    }
+                    const queuesForChat = !key && !action.to;
+                    const { uploaded, note } = await uploadExpanded(action.paths, key ? { ticketKey: key } : {}, undefined, queuesForChat ? Math.max(0, MAX_ATTACHMENTS_PER_DROP - pendingAttachments.length) : MAX_ATTACHMENTS_PER_DROP);
+                    if (action.to) {
+                        await postAgentMessage(action.to, `Attached ${uploaded.length} files`, config, uploaded.map((attachment) => attachment.id));
+                        say("system", `Attached ${uploaded.length} files to ${action.to}.`);
+                    }
+                    else if (key) {
+                        say("system", `Attached ${uploaded.length} files to ${key}.`);
+                        await refresh();
+                    }
+                    else {
+                        setPendingAttachments((current) => [...current, ...uploaded]);
+                        say("system", `Attached ${uploaded.length} files to your next ${mode} message.`);
+                    }
+                    if (note)
+                        setNotice(note);
                 }
                 catch (error) {
                     setNotice(error instanceof Error ? error.message : String(error));
@@ -956,7 +1002,8 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
         }
     }, [view, settings, applyEdit, board, browsing, mode, say, askAgent, openAgentChat, order, settingsOrder,
         changeWorkspace, config, refresh, suspendTerminal, exit, inbox, inboxFocus, openTicket, answering,
-        selectedDecisionId, submitDecision, ticketKey, ticketCollapsed, ticketOffset, width, pendingAttachments]);
+        selectedDecisionId, submitDecision, ticketKey, ticketCollapsed, ticketOffset, width, pendingAttachments,
+        uploadExpanded]);
     useInput((input, key) => {
         if (key.ctrl && input === "c") {
             exit();

package/dist/tui/Help.js

@@ -13,12 +13,13 @@ export const COMMANDS = [
     { name: "/cancel", args: "HD-12 | RUN-ID", help: "cancel a ticket or run" },
     { name: "/merge", args: "HD-12", help: "approve a reviewed PR over the reviewer's objections" },
     { name: "/msg", args: "HD-12 TEXT", help: "message a ticket's builder" },
-    { name: "/attach", args: "PATH [HD-12]", help: "attach a file to the open or named ticket" },
+    { name: "/attach", args: "PATH... [HD-12 | --to ROLE]", help: "attach files, or queue them for this chat" },
     { name: "/logs", args: "[raw] [HD-12]", help: "filter activity; raw reveals event JSON" },
     { name: "/epic", args: "new PATH [--draft] | approve ID | rm ID", help: "create, approve, or remove an epic" },
     { name: "/epics", help: "list epics and ticket progress" },
-    { name: "/architect", help: "open a chat with the architect" },
-    { name: "/plan", help: "alias for /architect" },
+    { name: "/product", help: "open a chat with the Product Manager" },
+    { name: "/plan", help: "one-release alias for /product" },
+    { name: "/architect", help: "open a technical design chat with the Architect" },
     { name: "/decide", args: "[N|ID] [answer]", help: "answer the selected or numbered decision" },
     { name: "/agents", args: "[add [ROLE] [flags] | rm ROLE|ID]", help: "view or manage named agents" },
     { name: "/env", help: "list workspace environment variable names" },
@@ -27,7 +28,7 @@ export const COMMANDS = [
     { name: "/on", help: "turn on the current workspace" },
     { name: "/off", help: "turn off the current workspace" },
     { name: "/feed", help: "what just happened" },
-    { name: "/orchestrator", help: "open a chat with the orchestrator" },
+    { name: "/orchestrator", help: "open a chat with the Delivery Manager" },
     { name: "/refresh", help: "reload the board now" },
     { name: "/help", help: "this list" },
     { name: "/exit", help: "leave" },

package/dist/tui/Roadmap.js

@@ -8,7 +8,7 @@ import { wrapLines } from "./ticket-view.js";
 import { UI } from "./theme.js";
 export function roadmapLines(board, width) {
     if (!board.roadmap)
-        return ["No roadmap yet. Talk to /architect to create one."];
+        return ["No roadmap yet. Talk to /product to create one."];
     const lines = ["Vision"];
     lines.push(...wrapLines(board.roadmap.vision_md, Math.max(12, width - 2)));
     lines.push("");

package/dist/tui/agent-rows.js

@@ -21,6 +21,7 @@ export function signedOutProviders(board) {
     return providers;
 }
 const roleForKind = {
+    product: "product",
     architect: "architect",
     build: "builder",
     followup: "builder",

package/dist/tui/chat-view.js

@@ -29,7 +29,7 @@ export function chatAgentLabel(role, displayName) {
     const named = displayName?.trim();
     if (named)
         return named;
-    return role === "architect" ? "Architect" : "Orchestrator";
+    return role === "product" ? "Product Manager" : role === "architect" ? "Architect" : "Delivery Manager";
 }
 export function formatWorkingElapsed(ms) {
     const seconds = Math.max(0, Math.floor(ms / 1000));

package/dist/tui/data.js

@@ -144,7 +144,7 @@ export async function loadChatMessages(config, role) {
     return messages.slice().reverse();
 }
 export async function followChat(config, role, messageId, since) {
-    const kind = role === "architect" ? "architect" : "orchestrate";
+    const kind = role === "orchestrator" ? "orchestrate" : role;
     const status = await getStatus(config);
     const runs = [...(status.live_runs ?? []), ...(status.recent_runs ?? [])];
     const tagged = runs.find((run) => run.message_id === messageId);

package/dist/tui/parse.js

@@ -15,9 +15,12 @@ export function parseLine(raw) {
         case "orchestrator":
             return { kind: "mode", mode: "orchestrator" };
         case "architect":
+            return rest.length ? { kind: "unknown", command: "architect takes no arguments" }
+                : { kind: "mode", mode: "architect" };
+        case "product":
         case "plan":
             return rest.length ? { kind: "unknown", command: `${word.toLowerCase()} takes no arguments` }
-                : { kind: "mode", mode: "architect" };
+                : { kind: "mode", mode: "product" };
         case "board":
         case "roadmap":
         case "feed":
@@ -105,8 +108,8 @@ export function parseLine(raw) {
                 : { kind: "unknown", command: "msg needs KEY TEXT" };
         case "attach": {
             const parsed = parseTuiAttach(argument);
-            return parsed ? { kind: "attach", path: parsed.path, key: parsed.ticketKey ?? null }
-                : { kind: "unknown", command: "attach needs PATH and an optional HD-N key" };
+            return parsed ? { kind: "attach", paths: parsed.paths, key: parsed.ticketKey ?? null, to: parsed.to ?? null }
+                : { kind: "unknown", command: "attach needs PATH [PATH...] and HD-N or --to product|architect|orchestrator" };
         }
         case "logs":
             if (rest[0]?.toLowerCase() === "raw" && rest.length <= 2) {

package/dist/tui/theme.js

@@ -40,6 +40,7 @@ export function speakerStyle(speaker) {
         case "you":
             return { borderStyle: DOTTED, borderColor: UI.cream, label: "you" };
         case "orchestrator":
+        case "product":
         case "architect":
             return {
                 borderStyle: THIN,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@higherdev/cli",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "type": "module",
   "repository": {
     "type": "git",