@skillcdn/console 0.3.1 → 0.3.2

package/src/cli/format.ts

@@ -147,10 +147,14 @@ export function formatMore(more: boolean, limit: number, offset: number): string
   return more ? `\n... more: --offset ${offset + limit}` : "";
 }
 
+/** The logins of the people at work on a task, in the order they came to it. */
+const logins = (people: readonly RestPerson[]): string =>
+  people.map((person) => person.login).join(", ");
+
 export function formatTaskLine(task: RestTask): string {
   const notes = [`owner ${task.owner.login}`];
-  if (task.assignee !== null) {
-    notes.push(`assigned to ${task.assignee.login}`);
+  if (task.workers.length > 0) {
+    notes.push(`workers ${logins(task.workers)}`);
   }
   if (task.category !== null) {
     notes.push(task.category.key);
@@ -199,7 +203,7 @@ export function formatTask(
 ): string {
   const lines = [
     `#${task.number} ${task.title}`,
-    `state: ${task.state}  priority: ${task.priority}  owner: ${task.owner.login}  assignee: ${task.assignee?.login ?? "nobody"}`,
+    `state: ${task.state}  priority: ${task.priority}  owner: ${task.owner.login}  workers: ${task.workers.length === 0 ? "nobody" : logins(task.workers)}`,
     `id: ${task.id}${task.parentId === null ? "" : `  part of: ${task.parentId}`}`,
     ...scheduleLines(task),
   ];
@@ -375,9 +379,9 @@ export function formatCategoryLine(category: RestCategory): string {
 export function formatWork(work: RestWork): string {
   const lines: string[] = [];
   if (work.tasks.length === 0) {
-    lines.push("No open task is assigned to you.");
+    lines.push("No open task is on your plate.");
   } else {
-    lines.push("tasks assigned to you:");
+    lines.push("tasks you work on:");
     for (const { project, task } of work.tasks) {
       lines.push(`  ${project.key}  ${formatTaskLine(task)}`);
     }
@@ -392,10 +396,10 @@ export function formatWork(work: RestWork): string {
 /** Another person's plate: their open tasks, each with its project; no decisions, which wait for anyone. */
 export function formatPersonWork(person: RestPerson, work: RestPersonWork): string {
   if (work.tasks.length === 0) {
-    return `No open task is assigned to ${person.login}.`;
+    return `No open task is on ${person.login}'s plate.`;
   }
   return [
-    `tasks assigned to ${person.login}:`,
+    `tasks ${person.login} works on:`,
     ...work.tasks.map(({ project, task }) => `  ${project.key}  ${formatTaskLine(task)}`),
   ].join("\n");
 }

package/src/cli/help.ts

@@ -23,9 +23,11 @@ import {
   MAX_QUESTION_LENGTH,
   MAX_REPORTS_PER_RUN,
   MAX_RULES_LENGTH,
+  MAX_SEARCH_LENGTH,
   MAX_SUMMARY_LENGTH,
   MAX_TITLE_LENGTH,
   MAX_VERSIONS_PER_DOCUMENT,
+  MAX_WORKERS,
   MIN_OPTIONS,
 } from "../limits.js";
 import { COLOR_NAMES } from "../vocabulary.js";
@@ -84,17 +86,17 @@ const DAY = "a day as 2026-10-24, today, tomorrow, or +7 for seven days from tod
 const COLORS = `one of ${COLOR_NAMES.join(", ")}`;
 const KEY = "lowercase letters, digits and hyphens";
 const TASK_FIELD_FLAGS =
-  "[--state <state>] [--priority <priority>] [--category <key>] [--goal <id>] [--starts <day>] [--due <day>] [--assignee <login|me>] [--parent <number|id>]";
+  "[--state <state>] [--priority <priority>] [--category <key>] [--goal <id>] [--starts <day>] [--due <day>] [--worker <login|me|none>]... [--parent <number|id>]";
 const TASK_FIELD_LIMITS = [
   `starts, due: ${DAY}; the due day is not before the start`,
   "category: the key of one of the workspace's categories (console categories); goal: the id of one of the project's goals (console goals)",
-  "assignee: a login of the workspace, or me; parent: a task of the project",
+  `worker: a login of the workspace, or me; given again, or with commas between, for several, up to ${MAX_WORKERS}, in place of the workers there were; none alone for nobody. parent: a task of the project, by its number or its id; console tasks --search <words> finds one by its title`,
 ];
 const TASK_FIELD_REFUSALS = [
   "task.invalid_category: no category has that key",
   "task.invalid_goal: the goal is not one of this project",
   "task.invalid_dates: the due day is before the start",
-  "task.invalid_assignee: the person may not work in the project",
+  "task.invalid_worker: a person named as a worker may not work in the project",
   "task.invalid_parent: the parent is not a task of the project, or would make a loop",
 ];
 
@@ -147,14 +149,15 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
     synopsis:
       "What is on your plate across your projects: your open tasks, and the decisions waiting.",
     about:
-      "What is on your plate across the projects you may see: the open tasks assigned to you, the sooner due first, each with its project; and the decisions waiting for a person. Needs no project. --person <login> shows another person's plate, for an administrator or for an owner of a project they are in: their open tasks within the projects you may see, without the decisions, which wait for anyone.",
+      "What is on your plate across the projects you may see: the open tasks you work on, the sooner due first, each with its project; and the decisions waiting for a person. Needs no project. --person <login> shows another person's plate, for an administrator or for an owner of a project they are in: the open tasks they work on within the projects you may see, without the decisions, which wait for anyone.",
   },
   tasks: {
     usage:
-      "tasks [--state <state>] [--open] [--mine] [--category <key>] [--goal <id>] [--due <day|today|week|overdue>] [--unassigned] [--archived] [--limit <n>] [--offset <n>]",
+      "tasks [--state <state>] [--open] [--mine] [--category <key>] [--goal <id>] [--due <day|today|week|overdue>] [--unassigned] [--search <words>] [--archived] [--limit <n>] [--offset <n>]",
     synopsis:
-      "The tasks on the board, newest first, narrowed by state, owner, category, goal or due day.",
-    about: `The tasks on the board, newest first: number, state, priority, title, who owns and works on each, its category and its due day, and what waits on it. --open keeps the ones not done or dropped, --mine those assigned to you, --unassigned those assigned to nobody (not with --mine), --category and --goal those sorted into one, --due those due by a day: today, within the week, or overdue (the open ones past their day). The tasks put away (ADR-0029) are left out unless --archived asks for them alone. A page at a time: ${DEFAULT_PAGE_LIMIT} unless --limit says otherwise, from --offset on; a last line says when there is more. States: idea, ready, in_progress, in_review, done, dropped.`,
+      "The tasks on the board, newest first, narrowed by state, worker, category, goal, due day or words of the title.",
+    about: `The tasks on the board, newest first: number, state, priority, title, who owns and who works on each, its category and its due day, and what waits on it. --open keeps the ones not done or dropped, --mine those you work on, --unassigned those nobody works on (not with --mine), --category and --goal those sorted into one, --due those due by a day: today, this week (through its last day, the week beginning as the workspace says, console workspace, or as your language has it), or overdue (the open ones past their day), --search those whose title has every word given, whatever the case, and the task of that number for a number (12 or #12): how a task is found by its title, as a parent or otherwise. The tasks put away (ADR-0029) are left out unless --archived asks for them alone. A page at a time: ${DEFAULT_PAGE_LIMIT} unless --limit says otherwise, from --offset on; a last line says when there is more. States: idea, ready, in_progress, in_review, done, dropped.`,
+    limits: [`search: 1 to ${MAX_SEARCH_LENGTH} characters`],
   },
   task: {
     usage: `task <number|id>  |  task new <title> [--body <markdown>|--file <path>] ${TASK_FIELD_FLAGS}  |  task edit <number|id> [--title <title>] [--body <markdown>|--file <path>] ${TASK_FIELD_FLAGS}  |  task archive <number|id>  |  task archive --goal <id>  |  task restore <number|id>`,
@@ -171,10 +174,11 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
     refusals: ["task.not_found: no task has that number or id", ...TASK_FIELD_REFUSALS],
   },
   goals: {
-    usage: "goals [--category <key>] [--state <state>]",
+    usage:
+      "goals [--category <key>] [--state <state>] [--search <words>] [--limit <n>] [--offset <n>]",
     synopsis: "The roadmap: the project's goals, with their state, their days and how far each is.",
-    about:
-      "The roadmap of the project: its goals, the active first, each with its id, its state (planned, active, done, dropped), its category, the days it starts and is meant to be reached by, and how far it is, counted from the tasks that work towards it. --category keeps those sorted into one, --state those in one state.",
+    about: `The roadmap of the project: its goals, the active first, each with its id, its state (planned, active, done, dropped), its category, the days it starts and is meant to be reached by, and how far it is, counted from the tasks that work towards it. --category keeps those sorted into one, --state those in one state, --search those whose title has every word given, whatever the case: how a goal's id is found for --goal. A page at a time: ${DEFAULT_PAGE_LIMIT} unless --limit says otherwise, from --offset on; a last line says when there is more.`,
+    limits: [`search: 1 to ${MAX_SEARCH_LENGTH} characters`],
   },
   goal: {
     usage:
@@ -206,7 +210,7 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
     usage: "people",
     synopsis: "The people you see, by login, with what each is in the workspace.",
     about:
-      "The people of the workspace you see, by login, with their name where the host gives one and what they are in it: admin, who configures the workspace, or member, who works in the projects they are in; a person taken out is marked deactivated. Everyone, unless the workspace shows a member only the people they share a project with (console workspace says which; an administrator sees everyone). Then, where you see everyone, the logins an administrator let in that nobody has signed in with yet. The logins are what --assignee, member and person take; a login is found exactly, so an owner lists someone the list does not show.",
+      "The people of the workspace you see, by login, with their name where the host gives one and what they are in it: admin, who configures the workspace, or member, who works in the projects they are in; a person taken out is marked deactivated. Everyone, unless the workspace shows a member only the people they share a project with (console workspace says which; an administrator sees everyone). Then, where you see everyone, the logins an administrator let in that nobody has signed in with yet. The logins are what --worker, member and person take; a login is found exactly, so an owner lists someone the list does not show.",
   },
   workspace: {
     usage:

package/src/cli/main.ts

@@ -60,6 +60,7 @@ process.exitCode = await runCli(process.argv.slice(2), {
     exists: existsSync,
   }),
   notices: createNoticeStore(configDir),
+  locale: Intl.DateTimeFormat().resolvedOptions().locale,
   skillsDir: existsSync(skillsDir) ? skillsDir : undefined,
   listen: listenOn,
 });

package/src/client.ts

@@ -214,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. */
@@ -230,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. */
@@ -380,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. */
@@ -642,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),
           }),
@@ -862,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,

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,4 +1,4 @@
-import { type ReactNode, type SyntheticEvent, useState } from "react";
+import { type CSSProperties, type ReactNode, type SyntheticEvent, useState } from "react";
 import {
   OPEN_TASK_STATES,
   type RestCategory,
@@ -25,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
@@ -262,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>
@@ -356,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;
@@ -371,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>
@@ -413,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}
@@ -421,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)}
               >
@@ -430,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)}
@@ -644,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()]
@@ -695,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;
   }
@@ -713,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>
@@ -731,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>
           );