@skillcdn/console 0.3.0 → 0.3.2

package/src/client.ts

@@ -44,6 +44,8 @@ import {
   type RestMemberPatch,
   type RestMembers,
   type RestMePatch,
+  type RestPackConnect,
+  type RestPackConnectStarted,
   type RestPackTokenInput,
   type RestPeople,
   type RestPerson,
@@ -76,6 +78,9 @@ import {
   type RestVersion,
   type RestVersions,
   type RestWork,
+  type RestWorkspace,
+  type RestWorkspacePackConnect,
+  type RestWorkspacePatch,
   restArchivedTasksSchema,
   restCategoriesSchema,
   restCategorySchema,
@@ -96,6 +101,8 @@ import {
   restMemberSchema,
   restMembersSchema,
   restMeSchema,
+  restPackConnectSchema,
+  restPackConnectStartedSchema,
   restPeopleSchema,
   restPersonSchema,
   restPersonWorkSchema,
@@ -117,6 +124,8 @@ import {
   restVersionSchema,
   restVersionsSchema,
   restWorkSchema,
+  restWorkspacePackConnectSchema,
+  restWorkspaceSchema,
 } from "./schemas.js";
 import type { GoalState, TaskState } from "./vocabulary.js";
 
@@ -205,14 +214,18 @@ export interface Page {
   readonly offset?: number | undefined;
 }
 
-/** What the board is narrowed to: one state, the open ones, a category, a goal, an assignee, or what is due by a day. */
-/** What the roadmap is narrowed by: the goals in one state, or sorted into one category (ADR-0026). */
-export interface GoalFilter {
+/** What the roadmap is narrowed by: the goals in one state, the open ones, those sorted into one category (ADR-0026), or those whose title has some words; and which page of it. */
+export interface GoalFilter extends Page {
   readonly state?: GoalState | undefined;
+  /** True for the goals planned or active; false for the reached and the dropped. */
+  readonly open?: boolean | undefined;
   /** The key of a category of the workspace. */
   readonly category?: string | undefined;
+  /** Words of the title, each found in it whatever the case. */
+  readonly q?: string | undefined;
 }
 
+/** What the board is narrowed to: one state, the open ones, a category, a goal, a worker, what is due by a day, or words of the title; and which page of it. */
 export interface TaskFilter extends Page {
   readonly state?: TaskState | undefined;
   /** True for the tasks not done or dropped; false for the rest. */
@@ -221,10 +234,12 @@ export interface TaskFilter extends Page {
   readonly category?: string | undefined;
   /** The id of a goal. */
   readonly goal?: string | undefined;
-  /** The id of the person the tasks are assigned to. */
-  readonly assignee?: string | undefined;
-  /** True for the tasks assigned to nobody. */
+  /** The id of a person among the workers of the tasks. */
+  readonly worker?: string | undefined;
+  /** True for the tasks with no worker. */
   readonly unassigned?: boolean | undefined;
+  /** Words of the title, each found in it whatever the case; `#12` or `12` finds the task of that number too. */
+  readonly q?: string | undefined;
   /** A day (`2026-10-20`): the tasks due on it or before it. */
   readonly dueBy?: string | undefined;
   /** True for the tasks put away alone (ADR-0029); false, or left out, for the current ones. */
@@ -345,6 +360,12 @@ export interface ProjectClient {
   setPackToken(input: RestPackTokenInput): Promise<RestProject>;
   /** Takes the pack token away; for an owner. */
   removePackToken(): Promise<RestProject>;
+  /** Asks the deployment to connect the project's pack with a code a person approves (ADR-0036); for an owner. */
+  connectPackToken(): Promise<RestPackConnectStarted>;
+  /** How that connection stands; the token is kept when the person approved. For an owner. */
+  packTokenConnection(signal?: AbortSignal): Promise<RestPackConnect>;
+  /** Gives the connection up; for an owner. */
+  cancelPackTokenConnection(): Promise<void>;
   /** The rules that hold in the project (ADR-0023): the workspace's, and what the project adds. */
   rules(signal?: AbortSignal): Promise<RestProjectRules>;
   /** A folder's pages and folders, or the pages a search finds. */
@@ -365,8 +386,7 @@ export interface ProjectClient {
   attachFile(path: string, input: FileUpload): Promise<RestDocument>;
   /** Where the bytes of a file attached to a document are read, by the file's id. */
   documentFileUrl(path: string, fileId: string): string;
-  /** The roadmap (ADR-0019): the goals, the active first, each with its tasks counted by state. */
-  /** The roadmap, or what the filter keeps of it: the active goals first. */
+  /** The roadmap (ADR-0019), or what the filter keeps of it, a page at a time: the active goals first, each with its tasks counted by state. */
   goals(filter?: GoalFilter, signal?: AbortSignal): Promise<RestGoals>;
   goal(id: string, signal?: AbortSignal): Promise<RestGoal>;
   /** Sets a goal; for an owner, with a session or a token. */
@@ -380,7 +400,26 @@ export interface ConsoleClient {
   giveUpToken(): Promise<void>;
   /** Keeps the person's choice of language, or none; for a person signed in. */
   updateMe(patch: RestMePatch): Promise<RestMe>;
+  /** Changes the workspace's settings (ADR-0035); for an administrator, with a session or a token. */
+  updateWorkspace(patch: RestWorkspacePatch): Promise<RestWorkspace>;
+  /**
+   * The workspace's SkillCDN token (ADR-0036), which reads the organization's pack for every
+   * project that names no address and holds no token of its own; an administrator's. Set from
+   * a token made by hand, taken away, or connected with a code a person approves at SkillCDN,
+   * asked after until the token is kept or the request ended.
+   */
+  setWorkspacePackToken(input: RestPackTokenInput): Promise<RestWorkspace>;
+  removeWorkspacePackToken(): Promise<RestWorkspace>;
+  connectWorkspacePackToken(): Promise<RestPackConnectStarted>;
+  workspacePackTokenConnection(signal?: AbortSignal): Promise<RestWorkspacePackConnect>;
+  cancelWorkspacePackTokenConnection(): Promise<void>;
+  /** The people the asker may see: everyone, or those they share a project with (ADR-0035). */
   people(signal?: AbortSignal): Promise<RestPeople>;
+  /**
+   * One person of the workspace by their exact login, compared without regard to case, or
+   * nobody: what an owner lists someone by when the People page does not show them.
+   */
+  findPerson(login: string, signal?: AbortSignal): Promise<RestPerson | undefined>;
   /** Changes what a person is, or whether they are in; for an administrator. */
   updatePerson(id: string, patch: RestPersonPatch): Promise<RestPerson>;
   /** Lets a login in (ADR-0022): whoever signs in with that account becomes a person; for an administrator. */
@@ -608,9 +647,10 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
             open: flag(filter.open),
             category: filter.category,
             goal: filter.goal,
-            assignee: filter.assignee,
+            worker: filter.worker,
             unassigned: flag(filter.unassigned),
             dueBy: filter.dueBy,
+            q: filter.q,
             limit: number(filter.limit),
             offset: number(filter.offset),
           }),
@@ -766,6 +806,23 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
         request("PUT", `${base}${at()}/pack-token`, input, restProjectSchema),
       removePackToken: () =>
         request("DELETE", `${base}${at()}/pack-token`, undefined, restProjectSchema),
+      connectPackToken: () =>
+        request(
+          "POST",
+          `${base}${at()}/pack-token/connect`,
+          undefined,
+          restPackConnectStartedSchema,
+        ),
+      packTokenConnection: (signal) =>
+        request(
+          "GET",
+          `${base}${at()}/pack-token/connect`,
+          undefined,
+          restPackConnectSchema,
+          signal,
+        ),
+      cancelPackTokenConnection: () =>
+        request("DELETE", `${base}${at()}/pack-token/connect`, undefined, undefined),
       rules: (signal) =>
         request("GET", `${base}${at("rules")}`, undefined, restProjectRulesSchema, signal),
       documents: (filter = {}, signal) =>
@@ -811,7 +868,14 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
       goals: (filter = {}, signal) =>
         request(
           "GET",
-          withQuery(at("goals"), { state: filter.state, category: filter.category }),
+          withQuery(at("goals"), {
+            state: filter.state,
+            open: flag(filter.open),
+            category: filter.category,
+            q: filter.q,
+            limit: number(filter.limit),
+            offset: number(filter.offset),
+          }),
           undefined,
           restGoalsSchema,
           signal,
@@ -829,6 +893,39 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
     giveUpToken: () => request("DELETE", `${base}${REST_ROUTES.meToken}`, undefined, undefined),
     people: (signal) =>
       request("GET", `${base}${REST_ROUTES.people}`, undefined, restPeopleSchema, signal),
+    findPerson: async (login, signal) => {
+      const found = await request(
+        "GET",
+        withQuery(REST_ROUTES.people, { login }),
+        undefined,
+        restPeopleSchema,
+        signal,
+      );
+      return found.items[0];
+    },
+    updateWorkspace: (patch) =>
+      request("PATCH", `${base}${REST_ROUTES.workspace}`, patch, restWorkspaceSchema),
+    setWorkspacePackToken: (input) =>
+      request("PUT", `${base}${REST_ROUTES.workspacePackToken}`, input, restWorkspaceSchema),
+    removeWorkspacePackToken: () =>
+      request("DELETE", `${base}${REST_ROUTES.workspacePackToken}`, undefined, restWorkspaceSchema),
+    connectWorkspacePackToken: () =>
+      request(
+        "POST",
+        `${base}${REST_ROUTES.workspacePackToken}/connect`,
+        undefined,
+        restPackConnectStartedSchema,
+      ),
+    workspacePackTokenConnection: (signal) =>
+      request(
+        "GET",
+        `${base}${REST_ROUTES.workspacePackToken}/connect`,
+        undefined,
+        restWorkspacePackConnectSchema,
+        signal,
+      ),
+    cancelWorkspacePackTokenConnection: () =>
+      request("DELETE", `${base}${REST_ROUTES.workspacePackToken}/connect`, undefined, undefined),
     updatePerson: (id, patch) =>
       request("PATCH", `${base}${restPath("people", id)}`, patch, restPersonSchema),
     createListing: (input) =>

package/src/compat.ts

@@ -1,9 +1,10 @@
-// Whether the command and the console go together (ADR-0025). The command names its version on
+// Whether the command and the console go together (ADR-0025, ADR-0038). The command names its version on
 // every request, in the product token of its user-agent; the console answers every request of
 // the API with its own version and the range of command versions it takes, and refuses a
 // command outside the range with `426` and the words to update. One rule for both sides, kept
 // here so that the command and the console read the same one, and narrowed by the console's
-// policy below only, never widened: what the rule promises stays predictable.
+// policy below only, never widened: what the rule promises stays predictable. The command holds
+// the console to a floor of its own the same way (ADR-0038).
 
 /** The product token the command names itself with: `skillcdn-console/<version>`. */
 export const CLIENT_PRODUCT = "skillcdn-console";
@@ -74,15 +75,19 @@ export function inRange(version: Version, range: VersionRange): boolean {
 }
 
 /**
- * The common rule. Before 1.0, a command from the console's own version on and within the
- * console's minor (`^0.1.18`): any release may change the contract until then (ADR-0034), so the
- * console's own version is the floor, and the minor is the line. From 1.0, the console's major
- * and a minor within one of the console's, either way, whatever the patch: a minor adds and a
- * major breaks, as the version promises from then on.
+ * The common rule. Before 1.0, the line: a command and a console of one major.minor go
+ * together whatever the patch, since the minor is SkillCDN's line and a patch is a release of
+ * the console's own (ADR-0034), and a release that changes what passes between them raises the
+ * floors below instead (ADR-0038). From 1.0, the console's major and a minor within one of the
+ * console's, either way, whatever the patch: a minor adds and a major breaks, as the version
+ * promises from then on.
  */
 export function commonRange(server: Version): VersionRange {
   if (server.major === 0) {
-    return { atLeast: server, below: { major: 0, minor: server.minor + 1, patch: 0 } };
+    return {
+      atLeast: { major: 0, minor: server.minor, patch: 0 },
+      below: { major: 0, minor: server.minor + 1, patch: 0 },
+    };
   }
   return {
     atLeast: { major: server.major, minor: Math.max(0, server.minor - 1), patch: 0 },
@@ -103,13 +108,25 @@ export interface ClientPolicy {
   readonly refused?: readonly string[] | undefined;
 }
 
-/** The console's policy today: the common rule as it is. */
-export const CLIENT_POLICY: ClientPolicy = {};
+/**
+ * The console's policy: the oldest command this console answers, raised by the release that
+ * last changed what the command reads or sends (ADR-0038), whose changelog entry begins with
+ * `Breaking:`; `pnpm check` holds it to a version the package has, or is about to have.
+ */
+export const CLIENT_POLICY: ClientPolicy = { atLeast: "0.3.2" };
 
-/** The range of command versions a console of `server` takes: the common rule, narrowed by the policy's floor where that floor is within it. */
-export function clientRange(server: Version, policy: ClientPolicy = CLIENT_POLICY): VersionRange {
-  const common = commonRange(server);
-  const floor = parseVersion(policy.atLeast);
+/**
+ * The oldest console this command works with (ADR-0038): raised by the release that last
+ * changed what the command asks of the console, whose changelog entry begins with `Breaking:`.
+ * The command compares it with the version every answer names and refuses a console below it
+ * itself, naming the command to install instead; `pnpm check` holds it as it holds the
+ * console's floor.
+ */
+export const CONSOLE_AT_LEAST = "0.3.2";
+
+/** `common` from `atLeast` on, where that floor is within it; `common` as it is otherwise. */
+function narrowed(common: VersionRange, atLeast: string | undefined): VersionRange {
+  const floor = parseVersion(atLeast);
   return floor !== undefined &&
     compareVersions(floor, common.atLeast) > 0 &&
     compareVersions(floor, common.below) < 0
@@ -117,6 +134,16 @@ export function clientRange(server: Version, policy: ClientPolicy = CLIENT_POLIC
     : common;
 }
 
+/** The range of command versions a console of `server` takes: the common rule, narrowed by the policy's floor where that floor is within it. */
+export function clientRange(server: Version, policy: ClientPolicy = CLIENT_POLICY): VersionRange {
+  return narrowed(commonRange(server), policy.atLeast);
+}
+
+/** The range of console versions a command of `client` works with: the common rule, narrowed by the command's floor where that floor is within it. */
+export function consoleRange(client: Version, atLeast: string = CONSOLE_AT_LEAST): VersionRange {
+  return narrowed(commonRange(client), atLeast);
+}
+
 /**
  * What a command of one version is to a console of another: within the range and the same
  * (`current`), older (`behind`) or newer (`ahead`), which the console answers; or outside it,
@@ -152,6 +179,28 @@ export function judgeClient(
   return { verdict: order === 0 ? "current" : order < 0 ? "behind" : "ahead", range };
 }
 
+/**
+ * What a console of one version is to a command of another (ADR-0038): within the range the
+ * command works with, the same (`current`), older (`behind`) or newer (`ahead`); below it
+ * (`outdated`), which the command refuses itself, naming the command to install; or beyond it
+ * (`too_new`), which the console refuses the command for.
+ */
+export function judgeConsole(
+  server: Version,
+  client: Version,
+  atLeast: string = CONSOLE_AT_LEAST,
+): ClientJudgement {
+  const range = consoleRange(client, atLeast);
+  if (compareVersions(server, range.atLeast) < 0) {
+    return { verdict: "outdated", range };
+  }
+  if (compareVersions(server, range.below) >= 0) {
+    return { verdict: "too_new", range };
+  }
+  const order = compareVersions(server, client);
+  return { verdict: order === 0 ? "current" : order < 0 ? "behind" : "ahead", range };
+}
+
 /** What the command sends as its user-agent: its product token, and, in a comment, where it runs. */
 export function userAgentOf(version: string, comment?: string): string {
   // A comment holds printable ASCII without parentheses or backslashes; nothing else is said.

package/src/components/board.tsx

@@ -20,7 +20,6 @@ import { useWords } from "../i18n/index.js";
 import type { BoardFilter } from "../router.js";
 import { isPlainClick } from "./shell.js";
 import {
-  Avatar,
   Badge,
   Button,
   CategoryBadge,
@@ -28,6 +27,7 @@ import {
   DueBadge,
   PriorityBadge,
   personName,
+  Workers,
 } from "./ui.js";
 
 // The board: one column per state, the tasks in it, the sooner due first and the newest after.
@@ -165,7 +165,7 @@ export function TaskCard(props: TaskCardProps) {
           </Badge>
         )}
         <span className="sc-card-spacer" />
-        {task.assignee !== null && <Avatar person={task.assignee} size="sm" />}
+        <Workers workers={task.workers} size="sm" />
       </div>
     </article>
   );
@@ -584,10 +584,16 @@ export function filterTasks(
     if (filter.goal !== undefined && (task.goalId ?? "") !== filter.goal) {
       return false;
     }
-    if (filter.person !== undefined && task.assignee?.id !== filter.person) {
+    if (
+      filter.person !== undefined &&
+      !task.workers.some((worker) => worker.id === filter.person)
+    ) {
       return false;
     }
-    if (filter.mine === true && (me === undefined || task.assignee?.id !== me.id)) {
+    if (
+      filter.mine === true &&
+      (me === undefined || !task.workers.some((worker) => worker.id === me.id))
+    ) {
       return false;
     }
     return true;

package/src/components/calendar.tsx

@@ -1,15 +1,17 @@
-import { type ReactNode, type SyntheticEvent, useState } from "react";
+import { type CSSProperties, type ReactNode, type SyntheticEvent, useState } from "react";
 import {
   OPEN_TASK_STATES,
   type RestCategory,
   type RestGoal,
   type RestPerson,
   type RestTask,
+  type WeekStart,
 } from "../api.js";
 import {
   addDays,
   addMonths,
   daysBetween,
+  deviceLanguage,
   firstDayOfWeek,
   formatDay,
   formatDays,
@@ -23,7 +25,7 @@ import {
   weekOf,
 } from "../dates.js";
 import { useLanguage, useWords } from "../i18n/index.js";
-import { Avatar, CategoryBadge, cx, PersonChip, personName, StateBadge, Time } from "./ui.js";
+import { CategoryBadge, cx, PersonChip, personName, StateBadge, Time, Workers } from "./ui.js";
 
 // The calendar of a project (ADR-0019): the month as a grid, or one week on its own. A task
 // planned from a start to a due day lies across its days as a bar, in a lane of its own within
@@ -55,6 +57,8 @@ export interface CalendarProps {
   readonly goalHref?: ((goal: RestGoal) => string) | undefined;
   /** Where the calendar is on another month. */
   readonly monthHref: (month: string) => string;
+  /** The day the weeks begin on, as the workspace says (ADR-0035); the language's when left out. */
+  readonly weekStart?: WeekStart | undefined;
 }
 
 /** One task's stretch across one week: which columns it covers, and in which lane it lies. */
@@ -258,12 +262,18 @@ export function TaskTip(props: TaskTipProps) {
           </dd>
         </div>
         <div>
-          <dt>{words.task.assignee}</dt>
+          <dt>{words.task.workers}</dt>
           <dd>
-            {task.assignee === null ? (
+            {task.workers.length === 0 ? (
               <span className="sc-muted">{words.common.nobody}</span>
             ) : (
-              <PersonChip person={task.assignee} />
+              <ul className="sc-worker-list">
+                {task.workers.map((worker) => (
+                  <li key={worker.id}>
+                    <PersonChip person={worker} />
+                  </li>
+                ))}
+              </ul>
             )}
           </dd>
         </div>
@@ -352,6 +362,9 @@ function goalsOnDays(goals: readonly RestGoal[]): ReadonlyMap<string, readonly R
   return on;
 }
 
+/** How many days a bar has in the week, for its title to run along: a custom property the stylesheet reads. */
+const spanStyle = (span: number): CSSProperties => ({ "--sc-span": span }) as CSSProperties;
+
 /** One week as a row of cells: the bars across the days in their lanes, then the tasks on each day. */
 function WeekRow(props: WeekRowProps) {
   const { week, segments, now } = props;
@@ -367,9 +380,7 @@ function WeekRow(props: WeekRowProps) {
       <TaskTip task={task} goals={props.goals} place={props.pointed.place} />
     ) : null;
   const who = (task: RestTask): ReactNode =>
-    props.people === true && task.assignee !== null ? (
-      <Avatar person={task.assignee} size="xs" />
-    ) : null;
+    props.people === true ? <Workers workers={task.workers} size="xs" shown={2} /> : null;
   const lanes = segments.reduce((most, segment) => Math.max(most, segment.lane + 1), 0);
   return (
     <tr>
@@ -409,6 +420,13 @@ function WeekRow(props: WeekRowProps) {
               return <span key={lane} className="sc-calendar-lane" aria-hidden="true" />;
             }
             const { task } = segment;
+            // The first piece carries the title; with more days in the week, the title runs along
+            // the bar as far as they reach, over the pieces after it, instead of stopping at the
+            // first day's edge.
+            const span = segment.to - segment.from + 1;
+            const spanning = segment.from === column && span > 1;
+            // Every piece of the task under the pointer lights together, in every week it crosses.
+            const pointed = props.pointed !== null && props.pointed.task.id === task.id;
             return (
               <a
                 key={task.id}
@@ -417,8 +435,11 @@ function WeekRow(props: WeekRowProps) {
                   `sc-category-${task.category?.color ?? "gray"}`,
                   segment.from === column && segment.begins && "sc-calendar-bar-begins",
                   segment.to === column && segment.ends && "sc-calendar-bar-ends",
+                  spanning && "sc-calendar-bar-spanning",
+                  pointed && "sc-calendar-bar-pointed",
                   tone(task, now),
                 )}
+                style={spanning ? spanStyle(span) : undefined}
                 href={props.taskHref(task)}
                 {...pointing(task, cell.day)}
               >
@@ -426,7 +447,14 @@ function WeekRow(props: WeekRowProps) {
                   <>
                     {props.markOf?.(task)}
                     {who(task)}
-                    <span className="sc-calendar-task-title">{task.title}</span>
+                    <span
+                      className={cx(
+                        "sc-calendar-task-title",
+                        spanning && "sc-calendar-task-title-spanning",
+                      )}
+                    >
+                      {task.title}
+                    </span>
                   </>
                 )}
                 {tipIn(task, cell.day)}
@@ -469,7 +497,7 @@ export function Calendar(props: CalendarProps) {
   const { tag } = useLanguage();
   const [pointed, point, leave] = usePointed();
   const now = props.today ?? todayOf();
-  const firstDay = firstDayOfWeek(tag);
+  const firstDay = firstDayOfWeek(deviceLanguage(tag), props.weekStart);
   const weeks = monthGrid(props.month, firstDay);
   const on = onDays(props.tasks);
   const goalsOn = props.goalHref === undefined ? undefined : goalsOnDays(props.goals ?? []);
@@ -567,6 +595,8 @@ export interface WeekProps {
   readonly weekHref: (day: string) => string;
   /** What stands before a task's title where the tasks are of several projects: the project's mark. */
   readonly markOf?: ((task: RestTask) => ReactNode) | undefined;
+  /** The day the week begins on, as the workspace says (ADR-0035); the language's when left out. */
+  readonly weekStart?: WeekStart | undefined;
 }
 
 /** One week on its own: the days as columns, the tasks on them, and the weeks around a step away. */
@@ -575,7 +605,7 @@ export function Week(props: WeekProps) {
   const { tag } = useLanguage();
   const [pointed, point, leave] = usePointed();
   const now = props.today ?? todayOf();
-  const firstDay = firstDayOfWeek(tag);
+  const firstDay = firstDayOfWeek(deviceLanguage(tag), props.weekStart);
   const days = weekOf(props.day ?? now, firstDay);
   const first = days[0] ?? now;
   const last = days[days.length - 1] ?? now;
@@ -638,39 +668,44 @@ export function Week(props: WeekProps) {
 
 /** One person's share of the open work, as the table of who has what says it. */
 export interface WorkloadRow {
-  /** The person, or nobody for the tasks assigned to no one. */
+  /** The person, or nobody for the tasks with no worker. */
   readonly person: RestPerson | undefined;
   readonly open: number;
   readonly inProgress: number;
-  /** Open, and due within the next seven days from today. */
-  readonly dueSoon: number;
+  /** Open, and due from today through the last day of this week, as the workspace begins its weeks (ADR-0039). */
+  readonly dueThisWeek: number;
   /** Open, and past its day. */
   readonly overdue: number;
 }
 
-/** Who has what, from the open tasks: by login, with the unassigned last. */
-export function workloadOf(tasks: readonly RestTask[], today: string): WorkloadRow[] {
+/**
+ * Who has what, from the open tasks: a task counted for each of its workers, by name, and the
+ * tasks with none last; this week is the days from today through the week's last day, the week
+ * beginning on `firstDay` (1 for Monday, 7 for Sunday).
+ */
+export function workloadOf(tasks: readonly RestTask[], today: string, firstDay = 1): WorkloadRow[] {
+  const weekEnd = weekOf(today, firstDay).at(-1) ?? today;
   const rows = new Map<string, { person: RestPerson | undefined; tasks: RestTask[] }>();
   for (const task of tasks.filter(isOpen)) {
-    const key = task.assignee?.id ?? "";
-    const row = rows.get(key);
-    if (row === undefined) {
-      rows.set(key, { person: task.assignee ?? undefined, tasks: [task] });
-    } else {
-      row.tasks.push(task);
+    const workers: readonly (RestPerson | undefined)[] =
+      task.workers.length === 0 ? [undefined] : task.workers;
+    for (const worker of workers) {
+      const key = worker?.id ?? "";
+      const row = rows.get(key);
+      if (row === undefined) {
+        rows.set(key, { person: worker, tasks: [task] });
+      } else {
+        row.tasks.push(task);
+      }
     }
   }
   const count = (list: readonly RestTask[]): Omit<WorkloadRow, "person"> => ({
     open: list.length,
     inProgress: list.filter((task) => task.state === "in_progress" || task.state === "in_review")
       .length,
-    dueSoon: list.filter((task) => {
-      if (task.dueOn === null) {
-        return false;
-      }
-      const days = daysBetween(today, task.dueOn);
-      return days >= 0 && days <= 7;
-    }).length,
+    dueThisWeek: list.filter(
+      (task) => task.dueOn !== null && task.dueOn >= today && task.dueOn <= weekEnd,
+    ).length,
     overdue: list.filter((task) => task.dueOn !== null && task.dueOn < today).length,
   });
   return [...rows.values()]
@@ -689,14 +724,21 @@ export function workloadOf(tasks: readonly RestTask[], today: string): WorkloadR
 export interface WorkloadProps {
   readonly tasks: readonly RestTask[];
   readonly today?: string | undefined;
-  /** Where the board is, narrowed to one person's tasks, or to the unassigned. */
+  /** The day the week begins on, as the workspace says (ADR-0035); the language's when left out. */
+  readonly weekStart?: WeekStart | undefined;
+  /** Where the board is, narrowed to one person's tasks, or to those with no worker. */
   readonly personHref?: ((person: RestPerson | undefined) => string) | undefined;
 }
 
-/** Who has what: a row per person, and what of theirs is late or due soon. */
+/** Who has what: a row per person, and what of theirs is late or due this week. */
 export function Workload(props: WorkloadProps) {
   const words = useWords().calendar.workload;
-  const rows = workloadOf(props.tasks, props.today ?? todayOf());
+  const { tag } = useLanguage();
+  const rows = workloadOf(
+    props.tasks,
+    props.today ?? todayOf(),
+    firstDayOfWeek(deviceLanguage(tag), props.weekStart),
+  );
   if (rows.length === 0) {
     return null;
   }
@@ -707,7 +749,7 @@ export function Workload(props: WorkloadProps) {
           <th scope="col">{words.person}</th>
           <th scope="col">{words.open}</th>
           <th scope="col">{words.inProgress}</th>
-          <th scope="col">{words.dueSoon}</th>
+          <th scope="col">{words.dueThisWeek}</th>
           <th scope="col">{words.overdue}</th>
         </tr>
       </thead>
@@ -725,7 +767,7 @@ export function Workload(props: WorkloadProps) {
               <th scope="row">{href === undefined ? who : <a href={href}>{who}</a>}</th>
               <td>{row.open}</td>
               <td>{row.inProgress}</td>
-              <td className={cx(row.dueSoon > 0 && "sc-workload-soon")}>{row.dueSoon}</td>
+              <td className={cx(row.dueThisWeek > 0 && "sc-workload-soon")}>{row.dueThisWeek}</td>
               <td className={cx(row.overdue > 0 && "sc-workload-late")}>{row.overdue}</td>
             </tr>
           );

package/src/components/event-feed.tsx

@@ -46,6 +46,8 @@ export function describeEvent(event: RestEvent, words: Messages = en): string {
       return feed.event.personDeactivated(login);
     case "person.reactivated":
       return feed.event.personReactivated(login);
+    case "workspace.updated":
+      return feed.event.workspaceUpdated(fields);
     case "project.created":
       return feed.event.projectCreated(project);
     case "project.updated":