@skillcdn/console 0.4.3 → 0.4.4

package/src/plugin/sandbox.ts

@@ -13,6 +13,15 @@ export const FORBIDDEN_BUILTINS: readonly string[] = [
   "dgram",
   "dns",
   "dns/promises",
+  // The same network, under the names Node keeps for compatibility.
+  "_http_agent",
+  "_http_client",
+  "_http_common",
+  "_http_incoming",
+  "_http_outgoing",
+  "_http_server",
+  "_tls_common",
+  "_tls_wrap",
   "child_process",
   "cluster",
   "worker_threads",
@@ -67,6 +76,15 @@ export interface HardenedThread {
   readonly removed: readonly string[];
 }
 
+/** What a plugin is told of a built-in it may not have, by whichever way it asked. */
+function refusedBuiltin(specifier: string): Error {
+  const error = new Error(
+    `the host refuses ${specifier}: a plugin reaches the console through ctx alone`,
+  );
+  (error as { code?: string }).code = "ERR_PLUGIN_FORBIDDEN_BUILTIN";
+  return error;
+}
+
 /** The module hook: refuses the forbidden built-ins and lets everything else resolve as it would. */
 export function forbiddingResolve<C, R>(
   specifier: string,
@@ -74,19 +92,16 @@ export function forbiddingResolve<C, R>(
   nextResolve: (specifier: string, context: C) => R,
 ): R {
   if (isForbiddenBuiltin(specifier)) {
-    const error = new Error(
-      `the host refuses ${specifier}: a plugin reaches the console through ctx alone`,
-    );
-    (error as { code?: string }).code = "ERR_PLUGIN_FORBIDDEN_BUILTIN";
-    throw error;
+    throw refusedBuiltin(specifier);
   }
   return nextResolve(specifier, context);
 }
 
 /**
- * Hardens the current thread: refuses the forbidden built-ins through the module hooks, removes
- * the globals, empties the environment, and blocks `process.binding`. Call it in a worker thread
- * before importing plugin code; it reaches nothing outside that thread.
+ * Hardens the current thread: refuses the forbidden built-ins through the module hooks and through
+ * `process.getBuiltinModule`, which goes round them, removes the globals, empties the environment,
+ * and blocks `process.binding`. Call it in a worker thread before importing plugin code; it reaches
+ * nothing outside that thread.
  */
 export function hardenThread(
   moduleApi: Pick<typeof import("node:module"), "registerHooks">,
@@ -112,6 +127,19 @@ export function hardenThread(
     for (const name of ["binding", "_linkedBinding", "dlopen"]) {
       Object.defineProperty(proc, name, { value: refuse, writable: false, configurable: false });
     }
+    const getBuiltinModule = proc.getBuiltinModule;
+    if (typeof getBuiltinModule === "function") {
+      Object.defineProperty(proc, "getBuiltinModule", {
+        value: (specifier: string): unknown => {
+          if (isForbiddenBuiltin(specifier)) {
+            throw refusedBuiltin(specifier);
+          }
+          return getBuiltinModule.call(proc, specifier);
+        },
+        writable: false,
+        configurable: false,
+      });
+    }
     const env = proc.env as Record<string, unknown> | undefined;
     if (env !== undefined) {
       for (const key of Object.keys(env)) {

package/src/plugin/semver.ts

@@ -0,0 +1,89 @@
+// Versions and ranges as a manifest spells them (docs/specs/plugins.md, "The manifest"): the
+// range of another plugin's version in `requires`, and the range of the console's version in
+// `console`. Read loosely, as npm spells the common ones, with no library: a plugin declares
+// `>=0.4.3 <0.6`, and the console, the authoring command and the tests compare the same way.
+
+export type Triple = readonly [number, number, number];
+
+/**
+ * A version read loosely: `0.4.3`, `v0.4.3`, `0.6` (as `0.6.0`), `1` (as `1.0.0`), a prerelease or
+ * a build after the numbers ignored; nothing for anything else.
+ */
+export function parseLooseVersion(text: string): Triple | undefined {
+  const match = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:[-+].*)?$/.exec(text.trim());
+  return match === null
+    ? undefined
+    : [Number(match[1]), Number(match[2] ?? "0"), Number(match[3] ?? "0")];
+}
+
+export function compareTriples(a: Triple, b: Triple): number {
+  return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+
+/**
+ * Whether a version is within a range as npm spells the common ones: `*`, exact, `^`, `~`, `>=`,
+ * `>`, `<=`, `<`, several with spaces between (all must hold) and alternatives with `||` between
+ * (one must hold). A partial version in the range is read as `.0` filled in: `<0.6` is `<0.6.0`.
+ */
+export function satisfiesRange(version: string, range: string): boolean {
+  const have = parseLooseVersion(version);
+  const trimmed = range.trim();
+  if (trimmed === "*" || trimmed === "" || trimmed === "x" || trimmed === "latest") {
+    return true;
+  }
+  if (have === undefined) {
+    return false;
+  }
+  return trimmed.split(/\s*\|\|\s*/).some((alternative) =>
+    alternative.split(/\s+/).every((part) => {
+      const operator = /^(\^|~|>=|<=|>|<|=)?(.*)$/.exec(part);
+      const wanted = parseLooseVersion(operator?.[2] ?? "");
+      if (wanted === undefined) {
+        return false;
+      }
+      switch (operator?.[1]) {
+        case "^":
+          return (
+            compareTriples(have, wanted) >= 0 &&
+            (wanted[0] === 0 ? have[0] === 0 && have[1] === wanted[1] : have[0] === wanted[0])
+          );
+        case "~":
+          return (
+            compareTriples(have, wanted) >= 0 && have[0] === wanted[0] && have[1] === wanted[1]
+          );
+        case ">=":
+          return compareTriples(have, wanted) >= 0;
+        case ">":
+          return compareTriples(have, wanted) > 0;
+        case "<=":
+          return compareTriples(have, wanted) <= 0;
+        case "<":
+          return compareTriples(have, wanted) < 0;
+        default:
+          return compareTriples(have, wanted) === 0;
+      }
+    }),
+  );
+}
+
+/**
+ * The version a dependency spells, read loosely: `^0.4.3`, `~0.4.3`, `>=0.4.3` and `0.4.3` are
+ * all `0.4.3`; `workspace:*`, `*`, `latest` and a tag name none.
+ */
+export function versionOfDependency(spec: string): Triple | undefined {
+  return parseLooseVersion(spec.trim().replace(/^(?:\^|~|>=|=)\s*/, ""));
+}
+
+export function formatTriple(version: Triple): string {
+  return `${version[0]}.${version[1]}.${version[2]}`;
+}
+
+/**
+ * The range of consoles a plugin written against `version` runs on, as `console-plugin init`
+ * writes it: from that version on, within its line, since the plugin API moves with the console's
+ * line before 1.0 (`>=0.4.3 <0.5.0`), and within its major from 1.0 (`>=1.2.0 <2.0.0`).
+ */
+export function lineRangeFrom(version: Triple): string {
+  const below: Triple = version[0] === 0 ? [0, version[1] + 1, 0] : [version[0] + 1, 0, 0];
+  return `>=${formatTriple(version)} <${formatTriple(below)}`;
+}

package/src/plugin/testing.ts

@@ -519,7 +519,7 @@ function refusingConsole(given: TestConsoleOptions | undefined): PluginConsole {
   return {
     workspace:
       given?.workspace ?? (async () => forbidden("console.workspace", "console.workspace")),
-    people: fill("people", ["list", "get"], given?.people),
+    people: fill("people", ["list", "get", "granted"], given?.people),
     projects: fill("projects", ["list", "get", "members"], given?.projects),
     tasks: fill("tasks", ["list", "get", "create", "update", "comment"], given?.tasks),
     decisions: fill("decisions", ["list", "get", "ask"], given?.decisions),
@@ -538,6 +538,7 @@ function build(store: Store, options: TestContextOptions, caller: PluginCaller):
     version: "0.0.0",
     dataVersion: 1,
     settings: {},
+    capabilities: [],
     board: null,
     projects: "all",
     ...options.plugin,

package/src/plugin/web.ts

@@ -11,11 +11,13 @@ import {
   type BridgeFile,
   type BridgeInit,
   type BridgeMethod,
+  type BridgePicture,
   type BridgeToPage,
   isBridgePath,
   isBridgeToFrame,
   MAX_BRIDGE_TITLE_LENGTH,
   PLUGIN_BRIDGE_VERSION,
+  type PluginWidgetSizeName,
 } from "./bridge.js";
 import type { PluginRecord, RecordPage, RecordVersion } from "./context.js";
 
@@ -111,6 +113,13 @@ export interface PluginFrame {
       type: string,
     ): Promise<{ readonly handle: string }>;
   };
+  readonly people: {
+    /**
+     * An address to put in an image, of the person of that id (ADR-0063), with `people:read`; or
+     * `null` for a person with no picture to show. Kept for the life of the frame.
+     */
+    picture(id: string): Promise<string | null>;
+  };
   /** The console's page follows a path of the console's in place; a URL is refused. */
   navigate(path: string): void;
   /** The console's page downloads a file of this plugin. */
@@ -125,12 +134,21 @@ export interface PluginFrame {
   onTheme(handler: (theme: Readonly<Record<string, string>>) => void): () => void;
   /** The console navigated within this page's address. */
   onPath(handler: (path: string) => void): () => void;
+  /** The person gave the widget another size (ADR-0059); `context.size` was the first. */
+  onSize(handler: (size: PluginWidgetSizeName) => void): () => void;
   /** Stops listening to the console's page. */
   close(): void;
 }
 
 const DEFAULT_CONNECT_MS = 10_000;
 
+/** What a page is told for a person with no picture to show, which is no failure of the page's. */
+const NO_PICTURE: ReadonlySet<string> = new Set([
+  "plugin.not_found",
+  "picture.refused",
+  "picture.unavailable",
+]);
+
 function globalWindow(): FrameWindow {
   const candidate = (globalThis as { window?: FrameWindow }).window;
   if (candidate === undefined) {
@@ -219,7 +237,9 @@ export function connect(options: ConnectOptions = {}): Promise<PluginFrame> {
   const eventHandlers = new Set<(kind: BridgeEventKind, data: unknown) => void>();
   const themeHandlers = new Set<(theme: Readonly<Record<string, string>>) => void>();
   const pathHandlers = new Set<(path: string) => void>();
+  const sizeHandlers = new Set<(size: PluginWidgetSizeName) => void>();
   const subscribed = new Set<BridgeEventKind>();
+  const pictures = new Map<string, Promise<string | null>>();
   let counter = 0;
   let stopHeight: (() => void) | undefined;
 
@@ -301,6 +321,26 @@ export function connect(options: ConnectOptions = {}): Promise<PluginFrame> {
                 }>;
               },
             },
+            people: {
+              picture: (id) => {
+                const kept = pictures.get(id);
+                if (kept !== undefined) {
+                  return kept;
+                }
+                const asked = (call("people.picture", { id }) as Promise<BridgePicture>).then(
+                  ({ type, bytes }) => URL.createObjectURL(new Blob([bytes], { type })),
+                  (error: unknown) => {
+                    if (error instanceof PluginBridgeError && NO_PICTURE.has(error.code)) {
+                      return null;
+                    }
+                    pictures.delete(id);
+                    throw error;
+                  },
+                );
+                pictures.set(id, asked);
+                return asked;
+              },
+            },
             navigate: (path) => {
               if (!isBridgePath(path)) {
                 throw new PluginBridgeError({
@@ -338,6 +378,10 @@ export function connect(options: ConnectOptions = {}): Promise<PluginFrame> {
               pathHandlers.add(handler);
               return () => pathHandlers.delete(handler);
             },
+            onSize: (handler) => {
+              sizeHandlers.add(handler);
+              return () => sizeHandlers.delete(handler);
+            },
             close: () => {
               win.removeEventListener("message", listener);
               stopHeight?.();
@@ -393,6 +437,11 @@ export function connect(options: ConnectOptions = {}): Promise<PluginFrame> {
             handler(message.path);
           }
           return;
+        case "size":
+          for (const handler of sizeHandlers) {
+            handler(message.size);
+          }
+          return;
         default:
           return;
       }

package/src/plugin.ts

@@ -29,6 +29,7 @@ export {
   type CapabilityWords,
   capabilityWords,
   isPluginCapability,
+  OUTBOUND_WEBRTC,
   outboundAllows,
   PLUGIN_CAPABILITIES,
   PLUGIN_CAPABILITY_PREFIXES,
@@ -72,8 +73,10 @@ export { PluginDefinitionError } from "./plugin/definition-error.js";
 export * from "./plugin/limits.js";
 export {
   CURRENT_PLUGIN_API,
+  capabilitiesAsked,
   isPluginKey,
   type Localized,
+  legacyWidgetSize,
   localizedText,
   type ManifestParse,
   PLUGIN_API_MAJORS,
@@ -83,6 +86,8 @@ export {
   PLUGIN_PAGE_LEVELS,
   PLUGIN_SETTING_TYPES,
   PLUGIN_WIDGET_PLACES,
+  PLUGIN_WIDGET_SIZE_CELLS,
+  PLUGIN_WIDGET_SIZE_NAMES,
   PLUGIN_WIDGET_SIZES,
   type PluginBoard,
   type PluginBoardNeeds,
@@ -93,16 +98,20 @@ export {
   type PluginPageLevel,
   type PluginRole,
   type PluginSetting,
+  type PluginSettingGroup,
   type PluginSettingType,
   type PluginWidget,
   type PluginWidgetPlace,
   type PluginWidgetSize,
+  type PluginWidgetSizeName,
   parsePluginManifest,
   pluginManifestSchema,
   RESERVED_COMMAND_NAMES,
   RESERVED_PAGE_KEYS,
   RESERVED_PLUGIN_KEYS,
   SETTING_KEY_PATTERN,
+  TIME_OF_DAY,
+  widgetSizesOf,
 } from "./plugin/manifest.js";
 export {
   isPluginError,
@@ -124,3 +133,12 @@ export {
   REMOVED_GLOBALS,
   removedGlobalsIn,
 } from "./plugin/sandbox.js";
+export {
+  compareTriples,
+  formatTriple,
+  lineRangeFrom,
+  parseLooseVersion,
+  satisfiesRange,
+  type Triple,
+  versionOfDependency,
+} from "./plugin/semver.js";

package/src/rules.ts

@@ -83,7 +83,7 @@ export function isReferenceRules(body: string): boolean {
 /** What stands in the rules for the language of the person the agent works for. */
 export const RULES_LANGUAGE_PLACEHOLDER = "{language}";
 
-/** What the rules say when the person chose no language: the task's, as the people of the board wrote it. */
+/** What the rules say for a person with no language yet: the task's, as the people of the board wrote it. */
 const TASKS_LANGUAGE = "the language the task is written in";
 
 /** The name of a language in English, from its tag (`ko` is Korean); the tag itself when it is not one. */
@@ -101,8 +101,8 @@ export function languageNameOf(tag: string): string {
 
 /**
  * The rules as they read for a person: `{language}` filled with the name of the language they
- * chose for the pages, or with the task's language when they chose none. The command fills
- * them for the person whose token it holds; the pages for whoever reads them.
+ * read in (ADR-0065), or with the task's language while they have none. The command fills them
+ * for the person whose token it holds; the pages for whoever reads them.
  */
 export function fillRules(body: string, language: string | null | undefined): string {
   const name = language == null ? TASKS_LANGUAGE : languageNameOf(language);

package/src/schemas.ts

@@ -16,9 +16,12 @@ import {
   MAX_BODY_LENGTH,
   MAX_CATEGORY_KEY_LENGTH,
   MAX_CATEGORY_NAME_LENGTH,
+  MAX_DECIDERS,
   MAX_DOCUMENT_LENGTH,
   MAX_DOCUMENT_PATH_LENGTH,
   MAX_FILE_NAME_LENGTH,
+  MAX_HOME_ROW,
+  MAX_HOME_TILES,
   MAX_LANGUAGE_TAG_LENGTH,
   MAX_LINK_LABEL_LENGTH,
   MAX_LINKS,
@@ -42,6 +45,7 @@ import {
   MAX_WORKERS,
   MIN_OPTIONS,
 } from "./limits.js";
+import { PLUGIN_WIDGET_SIZE_NAMES } from "./plugin/manifest.js";
 import { hasForbiddenCodePoint } from "./text.js";
 import {
   ARTIFACT_KINDS,
@@ -100,6 +104,14 @@ const day = z.iso.date();
 const count = z.int().check(z.nonnegative());
 
 /** A person of the workspace, as the pages show them. Nothing here is a secret. */
+/** A language tag as a browser sends one (`en`, `ko-KR`). */
+const languageTag = z
+  .string()
+  .check(
+    z.maxLength(MAX_LANGUAGE_TAG_LENGTH),
+    z.regex(/^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/, "must be a language tag"),
+  );
+
 export const restPersonSchema = z.object({
   id: uuid,
   /** What the account is called at its provider: a login at the git host, an address at Google. */
@@ -116,6 +128,19 @@ export const restPersonSchema = z.object({
   source: z.enum(MEMBERSHIP_SOURCES),
   /** When they were deactivated, or `null`. */
   deactivatedAt: z.nullable(instant),
+  /**
+   * The id of the person they report to, the reporting line of the directory an administrator
+   * keeps, or `null` for nobody; what a plugin reads as the default approver, the default
+   * assignee, in place of a line of its own. Answered from 0.4.4 and read as optional, so that
+   * a console built on this package still reads an older console's people.
+   */
+  managerId: z.optional(z.nullable(uuid)),
+  /**
+   * The language the person reads in (ADR-0065), a tag: the one they chose, else the one the pages
+   * first saw them in; `null` until they have opened the pages. What a plugin or an agent writes
+   * for them in. Answered from 0.4.4 and read as optional, as `managerId` is.
+   */
+  language: z.optional(z.nullable(languageTag)),
 });
 export type RestPerson = z.infer<typeof restPersonSchema>;
 
@@ -195,16 +220,59 @@ export const timeZoneName = z
     z.regex(/^[A-Za-z0-9_+-]+(?:\/[A-Za-z0-9_+-]+)*$/, "must be a time zone name"),
   );
 
-/** A language tag as a browser sends one (`en`, `ko-KR`): what the pages speak, by the person's choice. */
-const languageTag = z
+/** What `PATCH /api/v1/me` is sent: the language the person chose, or `null` to choose none. */
+/** The sizes of a tile on the front page (ADR-0061): a project's icon, and the widgets' family. */
+export const HOME_TILE_SIZES = ["icon", ...PLUGIN_WIDGET_SIZE_NAMES] as const;
+
+/** A tile by what it is: a project by its id, a widget by its plugin's key and its own. */
+const homeTileId = z
   .string()
   .check(
-    z.maxLength(MAX_LANGUAGE_TAG_LENGTH),
-    z.regex(/^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/, "must be a language tag"),
+    z.regex(
+      /^(?:project:[0-9a-f-]{36}|widget:[a-z][a-z0-9-]{0,31}:[a-z][a-z0-9-]{0,31})$/,
+      "must name a project or a widget",
+    ),
   );
 
-/** What `PATCH /api/v1/me` is sent: the language the person chose, or `null` to choose none. */
-export const restMePatchSchema = z.object({ language: z.nullable(languageTag) });
+/** One tile of a person's own front page, at a place of the grid and at a size. */
+export const restHomeTileSchema = z.object({
+  tile: homeTileId,
+  x: z.int().check(z.gte(0), z.lte(11)),
+  y: z.int().check(z.gte(0), z.lte(MAX_HOME_ROW)),
+  size: z.enum(HOME_TILE_SIZES),
+});
+export type RestHomeTile = z.infer<typeof restHomeTileSchema>;
+
+const homeLayoutSchema = z.array(restHomeTileSchema).check(z.maxLength(MAX_HOME_TILES));
+
+/**
+ * A person's own front page (ADR-0061): the tiles they took off it, which stay off, and what
+ * they arranged at each width of the grid, by its columns; what they have not seen yet takes
+ * the first room.
+ */
+export const restHomeSchema = z.object({
+  hidden: z.array(homeTileId).check(z.maxLength(MAX_HOME_TILES)),
+  layouts: z.object({
+    12: z.optional(homeLayoutSchema),
+    8: z.optional(homeLayoutSchema),
+    6: z.optional(homeLayoutSchema),
+    4: z.optional(homeLayoutSchema),
+  }),
+});
+export type RestHome = z.infer<typeof restHomeSchema>;
+
+/** What `PATCH /api/v1/me` is sent: the language, the front page, either or both; `null` lets the console choose. */
+export const restMePatchSchema = z
+  .object({
+    language: z.optional(z.nullable(languageTag)),
+    home: z.optional(z.nullable(restHomeSchema)),
+  })
+  .check(
+    z.refine(
+      (patch) => patch.language !== undefined || patch.home !== undefined,
+      "must name a language or the front page",
+    ),
+  );
 export type RestMePatch = z.infer<typeof restMePatchSchema>;
 
 /**
@@ -274,8 +342,13 @@ export const restMeSchema = z.object({
    * person's own knows it holds one. `null` on a session, and for nobody.
    */
   agent: z.nullable(z.string()),
-  /** The language the person chose for the pages (ADR-0012), or `null` for the browser's. */
+  /** The language the person reads in (ADR-0065): the one they chose, else the one the pages first saw them in; `null` until then. */
   language: z.nullable(languageTag),
+  /**
+   * The person's own front page (ADR-0061), or `null` while they have arranged nothing; answered
+   * from 0.4.4 and read as optional.
+   */
+  home: z.optional(z.nullable(restHomeSchema)),
   signIn: z.array(restProviderSchema),
   /**
    * The console's version and the range of command versions it takes, as npm spells one
@@ -313,11 +386,14 @@ export const restPersonPatchSchema = z
   .object({
     role: z.optional(z.enum(PERSON_ROLES)),
     status: z.optional(z.enum(PERSON_STATUSES)),
+    /** Whom the person reports to: another active person of the workspace, or `null` for nobody. */
+    managerId: z.optional(z.nullable(uuid)),
   })
   .check(
     z.refine(
-      (patch) => patch.role !== undefined || patch.status !== undefined,
-      "must name a role or a status",
+      (patch) =>
+        patch.role !== undefined || patch.status !== undefined || patch.managerId !== undefined,
+      "must name a role, a status or a manager",
     ),
   );
 export type RestPersonPatch = z.infer<typeof restPersonPatchSchema>;
@@ -505,6 +581,8 @@ export const restTaskSchema = z.object({
   owner: restPersonSchema,
   /** The plugin that made it, by key (ADR-0052), or `null`; left out by a console older than the plugins. */
   plugin: z.optional(z.nullable(z.string())),
+  /** The agent the task was written through, or `null` when a person wrote it themselves (ADR-0056); the owner may have changed since. Left out by an older console. */
+  agent: z.optional(z.nullable(z.string())),
   /** The people at work on it (ADR-0037), in the order they came to it; `[]` while nobody is. */
   workers: z.array(restPersonSchema),
   /** The task this one is part of, or `null`. */
@@ -615,6 +693,8 @@ export const restGoalSchema = z.object({
   /** The day the goal is meant to be reached by, or `null`. */
   dueOn: z.nullable(day),
   createdBy: restPersonSchema,
+  /** The agent the goal was set through, or `null` when a person set it themselves (ADR-0056); left out by an older console. */
+  agent: z.optional(z.nullable(z.string())),
   /** The tasks that work towards it, counted by state. */
   taskCounts: restTaskCountsSchema,
   createdAt: instant,
@@ -714,8 +794,15 @@ export const restDecisionSchema = z.object({
   /** The task's number, when there is a task, or `null`. */
   taskNumber: z.nullable(z.int()),
   raisedBy: restPersonSchema,
-  /** Who is to answer (ADR-0042): the raiser, unless another person of the project was named. */
+  /** The first of those to answer (ADR-0042): the raiser, unless others of the project were named. */
   decider: restPersonSchema,
+  /**
+   * Everyone the decision is addressed to (ADR-0057), `decider` first: each finds it among their
+   * decisions, any of them may answer, and the first answer ends it. Answered from 0.4.4 and read
+   * as optional, so that a console built on this package still reads an older console's
+   * decisions, where it is `[decider]`.
+   */
+  deciders: z.optional(z.array(restPersonSchema)),
   /** The run that raised it, as the agent asked, or `null` when a person did. */
   run: z.nullable(z.object({ id: uuid, agent: z.string() })),
   /** The plugin that raised it, by key (ADR-0052), or `null`; left out by a console older than the plugins. */
@@ -729,10 +816,24 @@ export const restDecisionSchema = z.object({
       note: z.nullable(z.string()),
       by: restPersonSchema,
       at: instant,
+      /**
+       * The agent the answer came through, when the person's agent wrote it in their name
+       * (`console answer`, ADR-0021), or `null` when they answered themselves (ADR-0056).
+       * Answered from 0.4.4 and read as optional, so that a console built on this package still
+       * reads an older console's decisions.
+       */
+      agent: z.optional(z.nullable(z.string())),
     }),
   ),
   /** What followed the decision, in Markdown, written afterwards; `null` until someone does. */
   outcome: z.nullable(z.string()),
+  /**
+   * Who wrote what followed, the agent they wrote it through (`null` when themselves) and when
+   * (ADR-0056); each `null` until someone does. Answered from 0.4.4 and read as optional.
+   */
+  outcomeBy: z.optional(z.nullable(restPersonSchema)),
+  outcomeAgent: z.optional(z.nullable(z.string())),
+  outcomeAt: z.optional(z.nullable(instant)),
   /**
    * The files put on it when it was raised (ADR-0055), in the order they came; a picture among
    * them is shown where the context names it as `![words](its name)`, else after it. Answered
@@ -820,6 +921,11 @@ export const restDecisionInputSchema = z.object({
   runId: z.optional(z.nullable(uuid)),
   /** Who is to answer (ADR-0042): a person who may work in the project; the asker when left out. */
   deciderId: z.optional(uuid),
+  /**
+   * Several to answer (ADR-0057), in place of `deciderId`: each a person who may work in the
+   * project, up to `MAX_DECIDERS`; any of them may answer, and the first answer ends the decision.
+   */
+  deciderIds: z.optional(z.array(uuid).check(z.minLength(1), z.maxLength(MAX_DECIDERS))),
 });
 export type RestDecisionInput = z.infer<typeof restDecisionInputSchema>;
 
@@ -873,6 +979,8 @@ export const restEventDataSchema = z.object({
   /** For `person.role_changed` and the events about a project's members: whose role, and what it became. */
   login: z.optional(z.string()),
   role: z.optional(z.string()),
+  /** For `person.manager_changed`: the login of whom the person reports to now, or `null` for nobody. */
+  manager: z.optional(z.nullable(z.string())),
   /** For the events about a project: its key and its name. */
   key: z.optional(z.string()),
   name: z.optional(z.string()),