@fulldivevr/workcord-cli 1.3.0 → 1.6.0

package/README.md

@@ -205,6 +205,7 @@ workcord <namespace> <command> [--<path-param> <value>] [--body '<json>'] [--que
 ```bash
 workcord auth login --email you@company.com
 workcord --as USER messages send-text --room R --text "hello"
+workcord messages ask-agent --room R --agent INSTALLATION_ID --text "Summarize the decision"
 ```
 
 Semantic aliases cover common agent/admin actions with consistent flags:
@@ -225,6 +226,10 @@ Server auto-extracts mention tokens from visible `@Name` text. Prefer
 member's display name and avoids exposing raw user ids. `auth login` never
 takes `--as` — it is how you obtain a `WORKCORD_TOKEN` in the first place.
 
+`messages ask-agent` posts an ordinary visible `@Agent` request, then waits for
+that installed agent's visible reply in the room or request thread. Pass the
+`installationId` returned by Home to `--agent`.
+
 ### Error handling
 
 Every error is **a single JSON line on stderr**, with a non-zero exit code:

package/dist/cli.js

@@ -14,6 +14,8 @@ import { registerChallenges } from "./commands/challenges.js";
 import { registerHealth } from "./commands/health.js";
 import { registerHermes } from "./commands/hermes.js";
 import { registerAgent } from "./commands/agent.js";
+import { registerAgentSkills } from "./commands/agent-skills.js";
+import { registerReflections } from "./commands/reflections.js";
 import { registerAll as registerGenerated } from "./generated/index.js";
 const program = new Command();
 const require = createRequire(import.meta.url);
@@ -36,6 +38,8 @@ registerDm(program);
 registerUsers(program);
 registerRoomAgents(program);
 registerCustomAgents(program);
+registerAgentSkills(program);
+registerReflections(program);
 registerChallenges(program); // adds regenerate-cards (not in the OpenAPI spec)
 registerHealth(program);
 registerHermes(program);

package/dist/client.js

@@ -1,13 +1,18 @@
 import { resolveAuth } from "./auth.js";
 import { DEFAULT_BASE_URL, readConfig } from "./config.js";
 import { applyQuery, fetchWithRetry, httpError, normalizeBaseUrl, safeJson } from "./http.js";
+import { validateRoomCreateBody } from "./room-types.js";
 let baseUrlOverride;
 export function setBaseUrlOverride(url) {
     baseUrlOverride = url;
 }
 export async function getBaseUrl() {
     const config = await readConfig();
-    return normalizeBaseUrl(baseUrlOverride || process.env.WORKCORD_API_URL || config.baseUrl || DEFAULT_BASE_URL);
+    return normalizeBaseUrl(baseUrlOverride
+        || process.env.WORKCORD_API_URL
+        || process.env.WORKCORD_API_URL_TOKEN
+        || config.baseUrl
+        || DEFAULT_BASE_URL);
 }
 export async function call({ method = "GET", path, query, body, headers, asUserId }) {
     const config = await readConfig();
@@ -18,6 +23,8 @@ export async function callPublic({ method = "GET", path, query, body, headers })
     return request({ method, path, query, body, headers });
 }
 async function request({ method = "GET", path, query, body, headers, bearer }) {
+    if (method === "POST" && path === "/api/v1/rooms")
+        validateRoomCreateBody(body);
     const base = await getBaseUrl();
     const url = applyQuery(new URL(base + path), query);
     const res = await fetchWithRetry(() => ({

package/dist/commands/agent-skills.js

@@ -0,0 +1,127 @@
+import { actingUserId } from "../auth.js";
+import { call } from "../client.js";
+import { getOrCreateGroup } from "./_group.js";
+const SKILL_ID = /^[a-z][a-z0-9_-]{0,63}$/;
+const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+export function parseSkillRef(ref) {
+    const at = ref.lastIndexOf("@");
+    if (at <= 0 || at === ref.length - 1)
+        throw new Error("skill must be ID@VERSION, e.g. web-research@1.0.0");
+    return { id: skillId(ref.slice(0, at)), version: semver(ref.slice(at + 1)) };
+}
+function skillId(id) {
+    if (!SKILL_ID.test(id))
+        throw new Error("skill id must be a lowercase slug");
+    return id;
+}
+function semver(version) {
+    if (!SEMVER.test(version))
+        throw new Error("version must be a semantic version, e.g. 1.0.0");
+    return version;
+}
+function bool(value) {
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    throw new Error("enabled must be true or false");
+}
+function skillPath(path) {
+    const segments = path.split("/");
+    if (segments.some((s) => !s || s === "." || s === ".."))
+        throw new Error("invalid skill file path");
+    return segments.map(encodeURIComponent).join("/");
+}
+// Agent ids are uuids, optionally behind the prefix a room agent is listed under.
+const AGENT_ID = /^(?:workcord-room-agent:|marketplace-install:)?[0-9a-z]{8}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{12}$/i;
+/** Pick the one agent named `name` (exact, case-insensitive) from a list-mine response. */
+export function agentIdByName(name, mine) {
+    const agents = (mine?.data ?? []);
+    const wanted = name.toLowerCase();
+    const found = (Array.isArray(agents) ? agents : [])
+        .filter((a) => typeof a?.name === "string" && a.name.toLowerCase() === wanted);
+    if (found.length === 0)
+        throw new Error(`no agent named ${name}`);
+    if (found.length > 1) {
+        throw new Error(`more than one agent named ${name}: ${found.map((a) => `${a.name} (${a.id})`).join(", ")}`);
+    }
+    return String(found[0].id);
+}
+function agentPath(agentId, suffix) {
+    return `/api/v1/agents/${encodeURIComponent(agentId)}/${suffix}`;
+}
+export function registerAgentSkills(program, send = call, output = (value) => process.stdout.write(JSON.stringify(value) + "\n")) {
+    const agents = getOrCreateGroup(program, "custom-agents", "CustomAgents operations");
+    const skills = agents.command("skills").description("Inspect and manage skills on an agent you own");
+    const withActor = (req) => {
+        const asUserId = actingUserId(program);
+        return asUserId ? { ...req, asUserId } : req;
+    };
+    // The server takes ids only, so a name is resolved here against list-mine.
+    const resolve = async (agent) => {
+        if (AGENT_ID.test(agent))
+            return agent;
+        const mine = await send(withActor({ method: "GET", path: "/api/v1/agents/mine", query: { includeShadow: "true" } }));
+        return agentIdByName(agent, mine);
+    };
+    const run = async (agent, req) => {
+        const result = await send(withActor(req(await resolve(agent))));
+        if (result != null)
+            output(result);
+    };
+    agents.command("stop")
+        .description("Stop an agent you own. Its runtime returns to cold-idle.")
+        .argument("<agent>", "agent id or exact name")
+        .action((agent) => run(agent, (id) => ({ method: "POST", path: agentPath(id, "stop") })));
+    skills.command("list")
+        .description("List the agent's skills (core, flavor, private, and market).")
+        .argument("<agent>", "agent id or exact name")
+        .action((agent) => run(agent, (id) => ({ method: "GET", path: agentPath(id, "skills") })));
+    skills.command("files")
+        .description("List the files attached to one skill.")
+        .argument("<agent>", "agent id or exact name")
+        .argument("<category>", "skill category")
+        .argument("<skill>", "skill name")
+        .action((agent, category, skill) => run(agent, (id) => ({
+        method: "GET",
+        path: agentPath(id, `skills/${encodeURIComponent(category)}/${encodeURIComponent(skill)}/files`),
+    })));
+    skills.command("read")
+        .description("Read one skill file.")
+        .argument("<agent>", "agent id or exact name")
+        .argument("<path>", "path relative to the skill root, e.g. research/web-research/SKILL.md")
+        .action((agent, path) => {
+        const file = skillPath(path);
+        return run(agent, (id) => ({ method: "GET", path: agentPath(id, `skill-files/${file}`) }));
+    });
+    skills.command("enabled")
+        .description("Enable or disable one skill.")
+        .argument("<agent>", "agent id or exact name")
+        .argument("<name>", "skill name")
+        .argument("<true|false>", "new state")
+        .action((agent, name, enabled) => {
+        const body = { enabled: bool(enabled) };
+        return run(agent, (id) => ({ method: "PUT", path: agentPath(id, `skills/${encodeURIComponent(name)}/state`), body }));
+    });
+    skills.command("installed")
+        .description("List the market skills installed on the agent.")
+        .argument("<agent>", "agent id or exact name")
+        .action((agent) => run(agent, (id) => ({ method: "GET", path: agentPath(id, "market-skills") })));
+    skills.command("install")
+        .description("Install or update a market skill at an exact version.")
+        .argument("<agent>", "agent id or exact name")
+        .argument("<ID@VERSION>", "market skill and version, e.g. web-research@1.0.0")
+        .action((agent, ref) => {
+        const body = parseSkillRef(ref);
+        return run(agent, (id) => ({ method: "POST", path: agentPath(id, "market-skills"), body }));
+    });
+    skills.command("uninstall")
+        .description("Remove a market skill.")
+        .argument("<agent>", "agent id or exact name")
+        .argument("<id>", "market skill id")
+        .action((agent, id) => {
+        const skill = encodeURIComponent(skillId(id));
+        return run(agent, (agentId) => ({ method: "DELETE", path: agentPath(agentId, `market-skills/${skill}`) }));
+    });
+}
+//# sourceMappingURL=agent-skills.js.map

package/dist/commands/messages.js

@@ -1,5 +1,7 @@
+import { randomUUID } from "node:crypto";
 import { actingUserId } from "../auth.js";
 import { call } from "../client.js";
+import { parseDuration } from "./agent.js";
 import { getOrCreateGroup } from "./_group.js";
 const MAX_LIMIT = 500;
 const MAX_PAGE_LIMIT = 100;
@@ -102,21 +104,165 @@ async function resolveMentions(roomId, asUserId, userIds) {
         return { userId, name, type: "user" };
     });
 }
+async function resolveAgentMentions(roomId, asUserId, agentIds) {
+    if (agentIds.length === 0)
+        return [];
+    const res = (await call({
+        method: "GET",
+        path: `/api/v1/rooms/${encodeURIComponent(roomId)}/members`,
+        query: { limit: MEMBER_PAGE_LIMIT },
+        asUserId,
+    }));
+    const names = new Map();
+    for (const member of res.data ?? []) {
+        if (member.memberType !== "agent" || !member.agentId)
+            continue;
+        names.set(member.agentId, member.displayName || member.agentId);
+    }
+    return agentIds.map((agentId) => {
+        const name = names.get(agentId);
+        if (name === undefined)
+            throw new Error(`Agent ${agentId} is not installed in room ${roomId}`);
+        return { agentId, name };
+    });
+}
+export function mentionedText(names, text) {
+    return names.length > 0 ? `${names.map((name) => `@${name}`).join(" ")} ${text.trimStart()}` : text;
+}
+export function resolveAgentTarget(members, agentId) {
+    const agents = members.filter((member) => member.memberType === "agent" && member.agentId);
+    const matches = agents.filter((member) => member.agentId === agentId.trim());
+    if (matches.length === 0) {
+        throw new Error(`Agent ${agentId} is not installed or enabled in this room.`);
+    }
+    return {
+        agentId: matches[0].agentId,
+        name: matches[0].displayName || matches[0].agentId,
+    };
+}
+export function agentRequestText(agentName, text, requestId) {
+    const marker = `[request:${requestId}]`;
+    return mentionedText([agentName], `${marker} ${text.trim()}\n\nReply once in this room, address the requesting Assistant by name, and repeat ${marker}.`);
+}
+export function matchingAgentReply(message, requestMessageId, agentId) {
+    const candidate = record(message);
+    const metadata = record(candidate.metadata);
+    const state = typeof metadata.a2aState === "string" ? metadata.a2aState.toLowerCase() : "";
+    if (candidate.senderType !== "agent"
+        || candidate.agentId !== agentId
+        || metadata.replyTo !== requestMessageId
+        || state === "working"
+        || state === "submitted") {
+        return undefined;
+    }
+    return candidate;
+}
+export async function waitForAgentReply(input) {
+    const now = input.now ?? Date.now;
+    const sleep = input.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const deadline = now() + input.timeoutMs;
+    while (true) {
+        const reply = (await input.read())
+            .map((message) => matchingAgentReply(message, input.requestMessageId, input.agentId))
+            .find((message) => message !== undefined);
+        if (reply)
+            return { reply, timedOut: false };
+        const remaining = deadline - now();
+        if (remaining <= 0)
+            return { reply: null, timedOut: true };
+        await sleep(Math.min(input.pollIntervalMs ?? 1000, remaining));
+    }
+}
+function messageId(value) {
+    const id = record(value).id;
+    if (typeof id !== "string" || !id)
+        throw new Error("Sent message response did not contain an id.");
+    return id;
+}
+function messageSentAt(value) {
+    const sentAt = record(value).sentAt;
+    return typeof sentAt === "string" && !Number.isNaN(new Date(sentAt).getTime()) ? sentAt : undefined;
+}
 export function registerMessages(program) {
     const group = getOrCreateGroup(program, "messages", "Messages operations");
+    group
+        .command("ask-agent")
+        .description("Post one visible request to an installed room agent and wait for its visible correlated reply.")
+        .requiredOption("--room <roomId>", "target room id")
+        .requiredOption("--text <text>", "request for the agent")
+        .requiredOption("--agent <agentInstallationId>", "installed room-agent id returned by Home")
+        .option("--timeout <duration>", "maximum local wait, such as 30s or 5m", "2m")
+        .action(async (opts) => {
+        const as = actingUserId(program);
+        const text = opts.text.trim();
+        if (!text)
+            throw new Error("--text must not be blank.");
+        const timeoutMs = parseDuration(opts.timeout);
+        const members = (await call({
+            method: "GET",
+            path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/members`,
+            query: { limit: MEMBER_PAGE_LIMIT },
+            asUserId: as,
+        }));
+        const target = resolveAgentTarget(members.data ?? [], opts.agent);
+        const requestId = randomUUID().replace(/-/g, "").slice(0, 8);
+        const content = agentRequestText(target.name, text, requestId);
+        const request = await call({
+            method: "POST",
+            path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages`,
+            body: { content, type: "text" },
+            asUserId: as,
+        });
+        const requestMessageId = messageId(request);
+        const after = messageSentAt(request);
+        const result = await waitForAgentReply({
+            requestMessageId,
+            agentId: target.agentId,
+            timeoutMs,
+            read: async () => {
+                const [room, thread] = await Promise.all([
+                    call({
+                        method: "GET",
+                        path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages`,
+                        query: { limit: MAX_PAGE_LIMIT, after },
+                        asUserId: as,
+                    }),
+                    call({
+                        method: "GET",
+                        path: `/api/v1/rooms/${encodeURIComponent(opts.room)}/messages/${encodeURIComponent(requestMessageId)}/thread`,
+                        query: { limit: MAX_PAGE_LIMIT },
+                        asUserId: as,
+                    }),
+                ]);
+                return [
+                    ...(Array.isArray(record(room).data) ? record(room).data : []),
+                    ...(Array.isArray(record(thread).data) ? record(thread).data : []),
+                ];
+            },
+        });
+        process.stdout.write(JSON.stringify({
+            roomId: opts.room,
+            requestId,
+            target,
+            request: { messageId: requestMessageId, content },
+            ...result,
+        }) + "\n");
+    });
     group
         .command("send-text")
-        .description("Send a text message to a room. Use --mention-user to mention members without exposing raw ids.")
+        .description("Send one text message to a room. Mention flags prepend visible @Name text; exclude those names from --text.")
         .requiredOption("--room <roomId>", "target room id")
-        .requiredOption("--text <text>", "message body")
+        .requiredOption("--text <text>", "message body after any mentions added by mention flags")
         .option("--reply-to <messageId>", "parent message id (for threaded replies)")
-        .option("--mention-user <userId>", "room member to mention by display name; repeatable", collect, [])
+        .option("--mention-user <userId>", "prepend the room member's visible @Name; repeatable", collect, [])
+        .option("--mention-agent <agentId>", "prepend the installed room agent's visible @Name; repeatable", collect, [])
         .option("--attachments <urls>", "comma-separated GCS URLs (use `workcord rooms upload-image-file` to get URLs first)")
         .option("--no-shadow-guidance", "do not opt in to Shadow guidance cards")
         .action(async (opts) => {
         const as = actingUserId(program);
         const mentions = await resolveMentions(opts.room, as, opts.mentionUser);
-        const content = mentions.length > 0 ? `${mentions.map((m) => `@${m.name}`).join(" ")} ${opts.text}` : opts.text;
+        const agentMentions = await resolveAgentMentions(opts.room, as, opts.mentionAgent);
+        const content = mentionedText([...mentions, ...agentMentions].map((mention) => mention.name), opts.text);
         const body = {
             content,
             type: "text",

package/dist/commands/reflections.js

@@ -0,0 +1,96 @@
+import { actingUserId } from "../auth.js";
+import { call } from "../client.js";
+import { getOrCreateGroup } from "./_group.js";
+function list(value) {
+    return value?.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function output(value) {
+    process.stdout.write(JSON.stringify(value) + "\n");
+}
+export function registerReflections(program) {
+    const group = getOrCreateGroup(program, "reflections", "Create and manage Shadow reflections");
+    group.command("list").action(async () => output(await call({
+        path: "/api/v1/shadow/reflections",
+        asUserId: actingUserId(program),
+    })));
+    group.command("get")
+        .requiredOption("--reflection <id>", "reflection id")
+        .action(async (opts) => output(await call({
+        path: `/api/v1/shadow/reflections/${encodeURIComponent(opts.reflection)}`,
+        asUserId: actingUserId(program),
+    })));
+    group.command("create")
+        .requiredOption("--name <name>", "reflection name")
+        .option("--description <text>", "short description")
+        .option("--style <text>", "response style")
+        .option("--topics <items>", "comma-separated allowed topics")
+        .option("--refusal-message <text>", "reply used outside allowed topics")
+        .option("--knowledge <text>", "knowledge content")
+        .option("--policy <text>", "policy content")
+        .option("--examples <text>", "examples content")
+        .action(async (opts) => {
+        const { topics, ...body } = opts;
+        output(await call({
+            method: "POST",
+            path: "/api/v1/shadow/reflections",
+            body: { ...body, ...(topics === undefined ? {} : { allowedTopics: list(topics) }) },
+            asUserId: actingUserId(program),
+        }));
+    });
+    group.command("update")
+        .requiredOption("--reflection <id>", "reflection id")
+        .option("--name <name>", "reflection name")
+        .option("--description <text>", "short description")
+        .option("--style <text>", "response style")
+        .option("--topics <items>", "comma-separated allowed topics")
+        .option("--refusal-message <text>", "reply used outside allowed topics")
+        .option("--knowledge <text>", "knowledge content")
+        .option("--policy <text>", "policy content")
+        .option("--examples <text>", "examples content")
+        .action(async (opts) => {
+        const { reflection, topics, ...body } = opts;
+        output(await call({
+            method: "PATCH",
+            path: `/api/v1/shadow/reflections/${encodeURIComponent(reflection)}`,
+            body: { ...body, ...(topics === undefined ? {} : { allowedTopics: list(topics) }) },
+            asUserId: actingUserId(program),
+        }));
+    });
+    group.command("activate")
+        .requiredOption("--reflection <id>", "reflection id")
+        .action(async (opts) => output(await call({
+        method: "POST",
+        path: `/api/v1/shadow/reflections/${encodeURIComponent(opts.reflection)}/activate`,
+        asUserId: actingUserId(program),
+    })));
+    group.command("install")
+        .requiredOption("--reflection <id>", "reflection id")
+        .requiredOption("--room <roomId>", "target room id")
+        .action(async (opts) => output(await call({
+        method: "POST",
+        path: `/api/v1/shadow/reflections/${encodeURIComponent(opts.reflection)}/install`,
+        body: { roomId: opts.room },
+        asUserId: actingUserId(program),
+    })));
+    group.command("set-price")
+        .requiredOption("--reflection <id>", "reflection id")
+        .requiredOption("--multiplier <n>", "price multiplier")
+        .option("--subsidy-daily-cap <n>", "daily subsidy cap in credits")
+        .action(async (opts) => output(await call({
+        method: "PATCH",
+        path: `/api/v1/shadow/reflections/${encodeURIComponent(opts.reflection)}/price`,
+        body: {
+            multiplier: Number(opts.multiplier),
+            ...(opts.subsidyDailyCap === undefined ? {} : { subsidyDailyCapCredits: Number(opts.subsidyDailyCap) }),
+        },
+        asUserId: actingUserId(program),
+    })));
+    group.command("delete")
+        .requiredOption("--reflection <id>", "reflection id")
+        .action(async (opts) => output(await call({
+        method: "DELETE",
+        path: `/api/v1/shadow/reflections/${encodeURIComponent(opts.reflection)}`,
+        asUserId: actingUserId(program),
+    })));
+}
+//# sourceMappingURL=reflections.js.map

package/dist/commands/rooms.js

@@ -124,13 +124,17 @@ function inviteResolution(inviteToken, room) {
         room: normalized,
     };
 }
-function applyRoomVisibility(body, opts) {
+export function applyRoomVisibility(body, opts) {
     if (opts.public && opts.private)
         throw new Error("Use either --public or --private, not both");
-    if (opts.public)
+    if (opts.public) {
         body.isPublic = true;
-    if (opts.private)
+        body.accessLevel = "open";
+    }
+    if (opts.private) {
         body.isPublic = false;
+        body.accessLevel = "inviteOnly";
+    }
 }
 function addRoomShapeOptions(command, opts = {}) {
     let withOptions = command;

package/dist/generated/commands/agent-feedback-admin.js

@@ -0,0 +1,69 @@
+import { call } from "../../client.js";
+import { actingUserId } from "../../auth.js";
+import { getOrCreateGroup, hasSubcommand } from "../_helpers.js";
+export function register(program) {
+    const group = getOrCreateGroup(program, "agent-feedback-admin", "AgentFeedbackAdmin operations");
+    if (!hasSubcommand(group, "list")) {
+        group
+            .command("list")
+            .description("GET /api/v1/admin/agent-feedback")
+            .option("--status <value>", "string")
+            .option("--agent-id <value>", "string")
+            .option("--hermes-tenant-id <value>", "string")
+            .option("--brand <value>", "string")
+            .option("--cursor <value>", "string")
+            .option("--limit <value>", "string")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/admin/agent-feedback`;
+            const query = {};
+            {
+                const v = opts.status;
+                if (v !== undefined)
+                    query["status"] = v;
+            }
+            {
+                const v = opts.agentId;
+                if (v !== undefined)
+                    query["agentId"] = v;
+            }
+            {
+                const v = opts.hermesTenantId;
+                if (v !== undefined)
+                    query["hermesTenantId"] = v;
+            }
+            {
+                const v = opts.brand;
+                if (v !== undefined)
+                    query["brand"] = v;
+            }
+            {
+                const v = opts.cursor;
+                if (v !== undefined)
+                    query["cursor"] = v;
+            }
+            {
+                const v = opts.limit;
+                if (v !== undefined)
+                    query["limit"] = v;
+            }
+            const data = await call({ method: "GET", path, asUserId: as, query });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "update")) {
+        group
+            .command("update")
+            .description("PATCH /api/v1/admin/agent-feedback/{id}")
+            .requiredOption("--id <value>", "id (path param)")
+            .option("--body <json>", "request body as JSON (no schema available)")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/admin/agent-feedback/${encodeURIComponent(opts.id)}`;
+            const body = opts.body ? JSON.parse(opts.body) : undefined;
+            const data = await call({ method: "PATCH", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+}
+//# sourceMappingURL=agent-feedback-admin.js.map

package/dist/generated/commands/ai.js

@@ -9,6 +9,7 @@ export function register(program) {
             .description("POST /api/v1/rooms/{roomId}/ai/ask")
             .requiredOption("--room-id <value>", "roomId (path param)")
             .requiredOption("--query <value>", "string, ≤500 chars")
+            .option("--call-id <value>", "string, ≤64 chars")
             .action(async (opts) => {
             const as = actingUserId(program);
             const path = `/api/v1/rooms/${encodeURIComponent(opts.roomId)}/ai/ask`;
@@ -18,6 +19,36 @@ export function register(program) {
                 if (v !== undefined)
                     body["query"] = v;
             }
+            {
+                const v = opts.callId;
+                if (v !== undefined)
+                    body["callId"] = v;
+            }
+            const data = await call({ method: "POST", path, asUserId: as, body });
+            process.stdout.write(JSON.stringify(data) + "\n");
+        });
+    }
+    if (!hasSubcommand(group, "ask-shadow")) {
+        group
+            .command("ask-shadow")
+            .description("POST /api/v1/rooms/{roomId}/ai/ask-shadow")
+            .requiredOption("--room-id <value>", "roomId (path param)")
+            .requiredOption("--query <value>", "string, ≤500 chars")
+            .option("--call-id <value>", "string, ≤64 chars")
+            .action(async (opts) => {
+            const as = actingUserId(program);
+            const path = `/api/v1/rooms/${encodeURIComponent(opts.roomId)}/ai/ask-shadow`;
+            const body = {};
+            {
+                const v = opts.query;
+                if (v !== undefined)
+                    body["query"] = v;
+            }
+            {
+                const v = opts.callId;
+                if (v !== undefined)
+                    body["callId"] = v;
+            }
             const data = await call({ method: "POST", path, asUserId: as, body });
             process.stdout.write(JSON.stringify(data) + "\n");
         });