@skillcdn/console 0.4.4 → 0.4.5

package/skills/working-the-board/SKILL.md

@@ -66,7 +66,7 @@ The work happens where it happens: in the repository, the document, the tool. At
 
 ### Phase 4: Ask when a person must decide
 
-A choice the body does not settle, a trade-off, a cost, a change of scope: `console ask "<question>" --option "<one>" --option "<another>" --body "<what they need to know>"`, with `--attach <file>` for a picture of what is to be chosen between, a screenshot of what was made; a picture the body names as `![words](its name)` is shown there ([ADR-0055](/docs/adr/0055-a-decision-carries-the-files-put-on-it-when-it-is-raised.md)). The decision is for the person you work for, who finds it among their decisions; `--to <login>` addresses it to another person of the project when the task or the rules name who decides such things ([ADR-0042](/docs/adr/0042-a-decision-is-addressed-to-a-person-its-raiser-unless-another-is-named.md)), and `--to` given again to several of them, any of whom may answer, the first answer ending it ([ADR-0057](/docs/adr/0057-a-decision-may-be-addressed-to-several-people-and-the-first-answer-ends-it.md)). The run waits for the answer; the command waits a minute and exits with `3` while it is still to come. Keep waiting with `console decision <id> --wait 100` (seconds), as often as needed, and meanwhile do only what does not depend on the answer. Act on the answer as given, which may be the person's own words rather than one of the options, marked as theirs; what was answered is not asked again. An answer that reaches you anywhere but the board is written on the decision in the person's name first (`console answer`, above) and acted on from there; a question the work overtook is answered the same way, with the person's word on it, however short. Once acted on, `console decision <id> --outcome "<what followed>"` makes the decision read as a record.
+A choice the body does not settle, a trade-off, a cost, a change of scope: `console ask "<question>" --option "<one>" --option "<another>" --body "<what they need to know>"`, with `--attach <file>` for a picture of what is to be chosen between, a screenshot of what was made; a picture the body names as `![words](its name)` is shown there ([ADR-0055](/docs/adr/0055-a-decision-carries-the-files-put-on-it-when-it-is-raised.md)). The decision is for the person you work for, who finds it among their decisions; `--to <login>` addresses it to another person of the project when the task or the rules name who decides such things ([ADR-0042](/docs/adr/0042-a-decision-is-addressed-to-a-person-its-raiser-unless-another-is-named.md)), and `--to` given again to several of them, any of whom may answer, the first answer ending it ([ADR-0057](/docs/adr/0057-a-decision-may-be-addressed-to-several-people-and-the-first-answer-ends-it.md)). The run waits for the answer; the command waits a minute and exits with `3` while it is still to come. Keep waiting with `console decision <id> --wait 100` (seconds), as often as needed, and meanwhile do only what does not depend on the answer; the command finds a decision wherever it is, in the project it works in or, for a plugin's decision that waits in the plugin's own project, there ([ADR-0068](/docs/adr/0068-a-decision-reaches-whom-it-is-addressed-to-wherever-it-is-and-a-plugins-reaches-the-managers-above-them.md)). Act on the answer as given, which may be the person's own words rather than one of the options, marked as theirs; what was answered is not asked again. An answer that reaches you anywhere but the board is written on the decision in the person's name first (`console answer`, above) and acted on from there; a question the work overtook is answered the same way, with the person's word on it, however short. Once acted on, `console decision <id> --outcome "<what followed>"` makes the decision read as a record.
 
 ### Phase 5: Hand in
 

package/src/api.ts

@@ -108,6 +108,9 @@ export {
   MAX_STREAMS_PER_PERSON,
   MAX_SUMMARY_LENGTH,
   MAX_TASKS_PER_PROJECT,
+  MAX_TEAM_KEY_LENGTH,
+  MAX_TEAM_NAME_LENGTH,
+  MAX_TEAMS,
   MAX_TITLE_LENGTH,
   MAX_TOKEN_DAYS,
   MAX_TOKEN_NAME_LENGTH,
@@ -124,6 +127,8 @@ export {
   CLAIM_PATH,
   categoryPath,
   connectPath,
+  decisionFilePath,
+  decisionPath,
   isSignInFailure,
   loginPath,
   PROJECT_COLLECTIONS,
@@ -224,6 +229,7 @@ export {
   type RestProjectRules,
   type RestProjects,
   type RestProvider,
+  type RestReachedDecision,
   type RestReport,
   type RestReportInput,
   type RestRules,
@@ -245,6 +251,11 @@ export {
   type RestTaskLink,
   type RestTaskPatch,
   type RestTasks,
+  type RestTeam,
+  type RestTeamInput,
+  type RestTeamMemberInput,
+  type RestTeamPatch,
+  type RestTeams,
   type RestToken,
   type RestTokenCreated,
   type RestTokenInput,
@@ -324,6 +335,7 @@ export {
   restProjectSchema,
   restProjectsSchema,
   restProviderSchema,
+  restReachedDecisionSchema,
   restReportInputSchema,
   restReportSchema,
   restRulesInputSchema,
@@ -345,6 +357,11 @@ export {
   restTaskPatchSchema,
   restTaskSchema,
   restTasksSchema,
+  restTeamInputSchema,
+  restTeamMemberInputSchema,
+  restTeamPatchSchema,
+  restTeamSchema,
+  restTeamsSchema,
   restTokenCreatedSchema,
   restTokenInputSchema,
   restTokenSchema,

package/src/cli/cli.ts

@@ -33,6 +33,7 @@ import { PLUGIN_LIST_LIMIT } from "../plugin/limits.js";
 import { fillRules, RULES_PATH, RULES_TITLE } from "../rules.js";
 import {
   hostOfLogin,
+  type RestAnswerInput,
   type RestClaim,
   type RestDecision,
   type RestMember,
@@ -101,6 +102,7 @@ import {
   formatPersonLine,
   formatPersonWork,
   formatPlugin,
+  formatPluginAsks,
   formatPluginGrantLine,
   formatPluginHelp,
   formatPluginRecord,
@@ -115,6 +117,7 @@ import {
   formatRunLine,
   formatTask,
   formatTaskLine,
+  formatTeamLine,
   formatVersion,
   formatVersionLine,
   formatWork,
@@ -632,9 +635,14 @@ function theTwo(positionals: readonly string[], ask: string): readonly [string,
  * The decision once answered, or as it stands when the wait is over. Each request asks the
  * console to hold it for a while, so the answer arrives as soon as a person gives it.
  */
+/** Whatever waits for a decision's answer: the project's client, or the decision wherever it is (ADR-0068). */
+interface Waiter {
+  awaitDecision(id: string, waitSeconds: number): Promise<RestDecision>;
+}
+
 async function waitForAnswer(
   io: CliIo,
-  project: ProjectClient,
+  project: Waiter,
   decision: RestDecision,
   seconds: number,
 ): Promise<RestDecision> {
@@ -665,7 +673,7 @@ const stillWaiting = (id: string): string =>
 async function settle(
   io: CliIo,
   session: Session,
-  project: ProjectClient,
+  project: Waiter,
   decision: RestDecision,
   seconds: number,
   shown = false,
@@ -1919,12 +1927,18 @@ async function pluginEnable(
   answer(io, session, enabled, () =>
     [
       `Enabled ${enabled.key}${enabled.board === null ? "" : `, with the board project ${enabled.board.key}`}; on ${enabled.projects === "all" || enabled.projects === null ? "every project" : enabled.projects.join(", ") || "no project"}.`,
+      ...(enabled.needsTimeZone === true
+        ? [
+            "The workspace has no time zone: the plugin's times of day run on UTC until an administrator sets one, with console workspace edit --time-zone <zone>.",
+          ]
+        : []),
       ...(enabled.settings.length === 0
         ? []
         : [
             "Settings:",
             ...enabled.settings.map((setting) => formatPluginSettingLine(setting, me.language)),
           ]),
+      ...formatPluginAsks(enabled, me.language),
     ].join("\n"),
   );
   return EXIT.ok;
@@ -1999,7 +2013,10 @@ async function pluginSecret(
   return EXIT.ok;
 }
 
-/** Grants a role of the plugin to a person, to the members of a project, or to everyone; an administrator's. */
+/**
+ * Grants a role of the plugin to a person, to the members of a project, to another plugin, to the
+ * members of a team, or to everyone; an administrator's.
+ */
 async function pluginGrant(
   io: CliIo,
   session: Session,
@@ -2009,14 +2026,26 @@ async function pluginGrant(
 ): Promise<number> {
   const { values, positionals } = parse(rest, {
     person: { type: "string" },
+    plugin: { type: "string" },
+    team: { type: "string" },
     everyone: { type: "boolean" },
   });
-  const usage = `console plugin ${client.key} grant <role> --person <login> | --project <key> | --everyone`;
+  const usage = `console plugin ${client.key} grant <role> --person <login> | --project <key> | --plugin <key> | --team <key> | --everyone`;
   const role = theOne(positionals, `Say which role: ${usage}`);
   const login = text(values, "person");
+  const other = text(values, "plugin");
+  const teamKey = text(values, "team");
   const everyone = on(values, "everyone");
-  if ([login !== undefined, projectKey !== undefined, everyone].filter(Boolean).length !== 1) {
-    throw misuse(`Say whom, one of the three: ${usage}`);
+  if (
+    [
+      login !== undefined,
+      projectKey !== undefined,
+      other !== undefined,
+      teamKey !== undefined,
+      everyone,
+    ].filter(Boolean).length !== 1
+  ) {
+    throw misuse(`Say whom, one of the five: ${usage}`);
   }
   let input: RestPluginGrantInput;
   if (login !== undefined) {
@@ -2027,6 +2056,10 @@ async function pluginGrant(
     input = { role, person: person.id };
   } else if (projectKey !== undefined) {
     input = { role, project: projectKey };
+  } else if (other !== undefined) {
+    input = { role, plugin: other };
+  } else if (teamKey !== undefined) {
+    input = { role, team: teamKey };
   } else {
     input = { role, everyone: true };
   }
@@ -2679,8 +2712,7 @@ const answering: Command = async (args, io) => {
   }
   const note = await bodyOf(io, values, text(values, "note"));
   const session = await open(io, values);
-  const project = await session.project();
-  const answered = await project.answerDecision(id, {
+  const answered = await answerReached(session, id, {
     ...(own === undefined ? { option } : { own }),
     ...(note === undefined ? {} : { note }),
   });
@@ -2688,6 +2720,75 @@ const answering: Command = async (args, io) => {
   return EXIT.ok;
 };
 
+/** Whether a refusal says the decision is not in the project the command works in, or the project is not the person's. */
+const notInProject = (error: unknown): boolean =>
+  error instanceof ApiError &&
+  (error.code === "decision.not_found" || error.code === "project.not_found");
+
+/**
+ * One decision as the command reaches it (ADR-0068): in the project the command works in, as
+ * before; else wherever it is, addressed to the person, raised by them, or a plugin's addressed
+ * to someone they manage, through the console's own route for one decision. A plugin's decision
+ * waits in the plugin's board project, which a checkout bound to another project does not name,
+ * and which the person may not be in at all. A console from before that route answers as before.
+ */
+async function reachDecision(
+  session: Session,
+  id: string,
+): Promise<{ readonly decision: RestDecision; readonly waiter: Waiter }> {
+  if ((await session.projectKey()) !== undefined) {
+    const project = await session.project();
+    try {
+      return { decision: await project.decision(id), waiter: project };
+    } catch (error) {
+      if (!notInProject(error)) {
+        throw error;
+      }
+    }
+  }
+  const anywhere = session.client;
+  try {
+    const reached = await anywhere.decision(id);
+    return {
+      decision: reached.decision,
+      waiter: {
+        awaitDecision: async (decisionId, seconds) =>
+          (await anywhere.awaitDecision(decisionId, seconds)).decision,
+      },
+    };
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 404) {
+      throw new ApiError(404, "decision.not_found", "The decision was not found.");
+    }
+    throw error;
+  }
+}
+
+/** Writes an answer on a decision as the command reaches it (ADR-0068): in the project, else wherever it is. */
+async function answerReached(
+  session: Session,
+  id: string,
+  input: RestAnswerInput,
+): Promise<RestDecision> {
+  if ((await session.projectKey()) !== undefined) {
+    try {
+      return await (await session.project()).answerDecision(id, input);
+    } catch (error) {
+      if (!notInProject(error)) {
+        throw error;
+      }
+    }
+  }
+  try {
+    return await session.client.answerDecision(id, input);
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 404) {
+      throw new ApiError(404, "decision.not_found", "The decision was not found.");
+    }
+    throw error;
+  }
+}
+
 const decision: Command = async (args, io) => {
   const { values, positionals } = parse(args, {
     wait: { type: "string" },
@@ -2701,19 +2802,19 @@ const decision: Command = async (args, io) => {
   const seconds = secondsOf(text(values, "wait"), 0);
   const outcome = await bodyOf(io, values, text(values, "outcome"));
   const session = await open(io, values);
-  const project = await session.project();
   if (outcome !== undefined) {
     // What followed the decision: the record grows, and is printed as it stands.
+    const project = await session.project();
     const grown = await project.updateDecision(id, { outcome });
     answer(io, session, grown, () => formatDecision(grown));
     return EXIT.ok;
   }
-  const found = await project.decision(id);
+  const { decision: found, waiter } = await reachDecision(session, id);
   if (seconds === 0) {
     answer(io, session, found, () => formatDecision(found));
     return EXIT.ok;
   }
-  return settle(io, session, project, found, seconds);
+  return settle(io, session, waiter, found, seconds);
 };
 
 const docs: Command = async (args, io) => {
@@ -3215,6 +3316,77 @@ const people: Command = async (args, io) => {
   return EXIT.ok;
 };
 
+/** The teams of the workspace (ADR-0073): each with who is in it, by login. */
+const teams: Command = async (args, io) => {
+  const { values } = parse(args, {}, false);
+  const session = await open(io, values);
+  const [found, everyone] = await Promise.all([session.client.teams(), session.client.people()]);
+  const loginOf = new Map(everyone.items.map((person) => [person.id, person.login]));
+  answer(io, session, found, () =>
+    found.items.length === 0
+      ? "No teams yet. console team new <key> <name> makes one."
+      : found.items.map((team) => formatTeamLine(team, loginOf)).join("\n"),
+  );
+  return EXIT.ok;
+};
+
+const TEAM_USAGE =
+  'Say what to do: console team new <key> "<name>"  |  team rename <key> "<new name>"  |  team remove <key>  |  team add <key> <login>  |  team drop <key> <login>';
+
+// A team is called by its key (ADR-0074), which never changes; its name is what people read.
+const team: Command = async (args, io) => {
+  const what = args[0];
+  if (what === "new") {
+    const { values, positionals } = parse(args.slice(1), {});
+    const [key, name] = theTwo(
+      positionals,
+      'Say the key and the name: console team new <key> "<name>"',
+    );
+    const session = await open(io, values);
+    const made = await session.client.createTeam({ key, name });
+    answer(io, session, made, () => formatTeamLine(made, new Map()));
+    return EXIT.ok;
+  }
+  if (what === "rename") {
+    const { values, positionals } = parse(args.slice(1), {});
+    const [key, next] = theTwo(
+      positionals,
+      'Say which team and its new name: console team rename <key> "<new name>"',
+    );
+    const session = await open(io, values);
+    const changed = await session.client.renameTeam(key, { name: next });
+    answer(io, session, changed, () => formatTeamLine(changed, new Map()));
+    return EXIT.ok;
+  }
+  if (what === "remove") {
+    const { values, positionals } = parse(args.slice(1), {});
+    const key = theOne(positionals, "Say which team: console team remove <key>");
+    const session = await open(io, values);
+    await session.client.removeTeam(key);
+    answer(io, session, { removed: key }, () => `The team ${key} is no more.`);
+    return EXIT.ok;
+  }
+  if (what === "add" || what === "drop") {
+    const { values, positionals } = parse(args.slice(1), {});
+    const [key, login] = theTwo(
+      positionals,
+      `Say which team and whom: console team ${what} <key> <login>`,
+    );
+    const session = await open(io, values);
+    const person = await personOf(session, login);
+    const changed =
+      what === "add"
+        ? await session.client.addTeamMember(key, person.id)
+        : await session.client.removeTeamMember(key, person.id);
+    const everyone = await session.client.people();
+    answer(io, session, changed, () =>
+      formatTeamLine(changed, new Map(everyone.items.map((one) => [one.id, one.login]))),
+    );
+    return EXIT.ok;
+  }
+  throw misuse(TEAM_USAGE);
+};
+
 // The workspace's settings (ADR-0035): read by everyone, changed by an administrator, themselves
 // on the Settings page or through their agent here (ADR-0021).
 const WORKSPACE_FLAGS =
@@ -3291,7 +3463,7 @@ const workspace: Command = async (args, io) => {
 };
 
 const PERSON_USAGE =
-  "Say what to do: console person role <login> <admin|member>  |  person manager <login> <manager login|none>  |  person add <login> [--host gh|google]  |  person remove <login>  |  person deactivate <login>  |  person reactivate <login>";
+  "Say what to do: console person role <login> <admin|member>  |  person manager <login> <manager login|none>  |  person email <login> <address|none>  |  person add <login> [--host gh|google]  |  person remove <login>  |  person deactivate <login>  |  person reactivate <login>";
 
 const person: Command = async (args, io) => {
   const what = args[0];
@@ -3308,6 +3480,20 @@ const person: Command = async (args, io) => {
     answer(io, session, changed, () => formatPersonLine(changed));
     return EXIT.ok;
   }
+  if (what === "email") {
+    const { values, positionals } = parse(args.slice(1), {});
+    const [login, address] = theTwo(
+      positionals,
+      "Say whom and their address: console person email <login> <address|none>",
+    );
+    const session = await open(io, values);
+    const found = await personOf(session, login);
+    const changed = await session.client.updatePerson(found.id, {
+      email: address === "none" ? null : address,
+    });
+    answer(io, session, changed, () => formatPersonLine(changed));
+    return EXIT.ok;
+  }
   if (what === "manager") {
     const { values, positionals } = parse(args.slice(1), {});
     const [login, manager] = theTwo(
@@ -3769,6 +3955,8 @@ const COMMANDS: Readonly<Record<string, Command>> = {
   plugin,
   people,
   person,
+  teams,
+  team,
   workspace,
   project,
   members,

package/src/cli/format.ts

@@ -30,6 +30,7 @@ import type {
   RestRulesPlugin,
   RestRun,
   RestTask,
+  RestTeam,
   RestVersion,
   RestVersionSummary,
   RestWork,
@@ -123,9 +124,11 @@ export function formatProject(project: RestProject): string {
 export function formatPersonLine(person: RestPerson, reportsTo?: string | undefined): string {
   const standing = person.status === "active" ? person.role : `${person.role}, deactivated`;
   const line = reportsTo === undefined ? "" : `, reports to ${reportsTo}`;
+  // The work email where the console answers one: to an administrator, and for oneself.
+  const email = typeof person.email === "string" ? `  <${person.email}>` : "";
   return person.name === null
-    ? `${person.login}  (${standing}${line})`
-    : `${person.login}  ${person.name}  (${standing}${line})`;
+    ? `${person.login}${email}  (${standing}${line})`
+    : `${person.login}  ${person.name}${email}  (${standing}${line})`;
 }
 
 /** The provider a listing names, as people call it. */
@@ -637,12 +640,22 @@ export function formatPlugins(plugins: RestPlugins, language: string | null | un
   ].join("\n");
 }
 
-/** How a command or a query of a plugin is given, as help prints it: the positionals, then the flags. */
-export function formatOperationUsage(key: string, operation: RestPluginOperation): string {
+/**
+ * How a command or a query of a plugin is given, as help prints it: the positionals, then the
+ * flags. In brief, for a listing that an agent reads whole at every first use, the positionals
+ * and the required flags alone, the rest as `[options]`, since `help <command>` has them all.
+ */
+export function formatOperationUsage(
+  key: string,
+  operation: RestPluginOperation,
+  { brief = false }: { readonly brief?: boolean } = {},
+): string {
   const entries = Object.entries(operation.args);
+  const shown = brief ? entries.filter(([, arg]) => arg.positional || !arg.optional) : entries;
   const usage = [
-    ...entries.filter(([, arg]) => arg.positional).map(([name, arg]) => argUsage(name, arg)),
-    ...entries.filter(([, arg]) => !arg.positional).map(([name, arg]) => argUsage(name, arg)),
+    ...shown.filter(([, arg]) => arg.positional).map(([name, arg]) => argUsage(name, arg)),
+    ...shown.filter(([, arg]) => !arg.positional).map(([name, arg]) => argUsage(name, arg)),
+    ...(brief && shown.length < entries.length ? ["[options]"] : []),
   ];
   return `console plugin ${key} ${operation.name}${usage.map((part) => ` ${part}`).join("")}`;
 }
@@ -703,11 +716,11 @@ export function formatPluginHelp(detail: RestPluginDetail, name: string | undefi
     }
     return [
       ...detail.operations.flatMap((operation) => [
-        formatOperationUsage(detail.key, operation),
+        formatOperationUsage(detail.key, operation, { brief: true }),
         `    ${operation.kind === "query" ? "[query] " : ""}${operation.about}`,
       ]),
       "",
-      `One in full: console plugin ${detail.key} help <command>.`,
+      `One in full, with every option: console plugin ${detail.key} help <command>.`,
     ].join("\n");
   }
   const operation = detail.operations.find((candidate) => candidate.name === name);
@@ -750,7 +763,13 @@ export function formatPluginSettingLine(
   const holds =
     setting.type === "secret"
       ? setting.set
-        ? `set${setting.setAt === null ? "" : ` ${moment(setting.setAt)}`}`
+        ? `set${setting.setAt === null ? "" : ` ${moment(setting.setAt)}`}${
+            setting.source === null ||
+            setting.source === undefined ||
+            setting.source === "administrator"
+              ? ""
+              : ` from ${setting.source}`
+          }${setting.expiresAt === null || setting.expiresAt === undefined ? "" : `, expires ${moment(setting.expiresAt)}`}`
         : "not set"
       : setting.set
         ? setting.value === null
@@ -765,14 +784,25 @@ export function formatPluginSettingLine(
 /** A grant in a line: its id, the role, whom it is to, since when. */
 export function formatPluginGrantLine(grant: RestPluginGrant): string {
   const whom =
-    grant.person !== null
-      ? `person ${grant.person.login}`
-      : grant.project !== null
-        ? `the members of ${grant.project.key}`
-        : "everyone";
+    grant.plugin !== null && grant.plugin !== undefined
+      ? `the plugin ${grant.plugin}`
+      : grant.team !== null && grant.team !== undefined
+        ? `the team ${grant.team.key}`
+        : grant.person !== null
+          ? `person ${grant.person.login}`
+          : grant.project !== null
+            ? `the members of ${grant.project.key}`
+            : "everyone";
   return `${grant.id}  ${grant.role} to ${whom}  since ${moment(grant.createdAt)}`;
 }
 
+/** A team in a line (ADR-0073): its key (ADR-0074), its name, how many are in it, and their logins. */
+export function formatTeamLine(team: RestTeam, loginOf: ReadonlyMap<string, string>): string {
+  const logins = team.memberIds.map((id) => loginOf.get(id) ?? id);
+  const count = team.memberIds.length === 1 ? "1 member" : `${team.memberIds.length} members`;
+  return `${team.key}  ${team.name}  ${count}${logins.length === 0 ? "" : `: ${logins.join(", ")}`}`;
+}
+
 /** One plugin in full: what it is, how it stands, what one may run, its skills and its settings. */
 export function formatPlugin(
   detail: RestPluginDetail,
@@ -811,11 +841,11 @@ export function formatPlugin(
     lines.push("Commands and queries:");
     for (const operation of detail.operations) {
       lines.push(
-        `  ${formatOperationUsage(detail.key, operation)}`,
+        `  ${formatOperationUsage(detail.key, operation, { brief: true })}`,
         `      ${operation.kind === "query" ? "[query] " : ""}${operation.about}`,
       );
     }
-    lines.push(`One in full: console plugin ${detail.key} help <command>.`);
+    lines.push(`One in full, with every option: console plugin ${detail.key} help <command>.`);
   }
   if (detail.skills !== null) {
     lines.push(
@@ -839,18 +869,51 @@ export function formatPlugin(
       ...detail.grants.map((grant) => `  ${formatPluginGrantLine(grant)}`),
     );
   }
+  lines.push(...formatPluginAsks(detail, language));
   return lines.join("\n");
 }
 
+/**
+ * The roles the plugin asks of other plugins (ADR-0072), each with how it stands and, where not
+ * granted, the command that grants it; nothing where it asks none.
+ */
+export function formatPluginAsks(
+  detail: RestPluginDetail,
+  language: string | null | undefined,
+): string[] {
+  const asks = detail.asks ?? [];
+  if (asks.length === 0) {
+    return [];
+  }
+  return [
+    "",
+    "Asks of other plugins:",
+    ...asks.map((ask) => {
+      const standing =
+        ask.state === "granted"
+          ? "granted"
+          : ask.state === "unavailable"
+            ? `${ask.plugin} is not enabled`
+            : `not granted; console plugin ${ask.plugin} grant ${ask.role} --plugin ${detail.key}`;
+      return `  ${ask.role} of ${ask.plugin}: ${standing}  ${localized(ask.why, language)}`;
+    }),
+  ];
+}
+
 /** What a command or a query answered, as the command prints it. */
 export function formatInvocation(result: RestPluginInvocation): string {
   if (result.kind === "query") {
     return result.data === undefined ? "null" : JSON.stringify(result.data, null, 2);
   }
   const text = result.text.length === 0 ? "Done." : result.text;
-  return result.waiting === null
-    ? text
-    : `${text}\ndecision id: ${result.waiting}\nThe decision waits for a person: console decision ${result.waiting} --wait 100`;
+  if (result.waiting === null) {
+    return text;
+  }
+  const where =
+    result.project === null || result.project === undefined
+      ? ""
+      : ` in the project ${result.project}`;
+  return `${text}\ndecision id: ${result.waiting}\nThe decision waits for a person${where}: console decision ${result.waiting} --wait 100`;
 }
 
 /** A record's data on one line, cut where it runs long. */