@skillcdn/console 0.1.9 → 0.1.11

package/src/cli/cli.ts

@@ -7,18 +7,30 @@ import {
   type FetchLike,
   type ProjectClient,
 } from "../client.js";
-import { MAX_OPTIONS, MIN_OPTIONS } from "../limits.js";
-import type { RestClaim, RestDecision } from "../schemas.js";
-import { TASK_PRIORITIES, TASK_STATES, type TaskPriority, type TaskState } from "../vocabulary.js";
+import { addDays, dayOf as dayOfDate, isDay } from "../dates.js";
+import { DEFAULT_PAGE_LIMIT, LIST_LIMIT, MAX_OPTIONS, MIN_OPTIONS } from "../limits.js";
+import type { RestClaim, RestDecision, RestTaskPatch } from "../schemas.js";
+import {
+  GOAL_STATES,
+  type GoalState,
+  TASK_PRIORITIES,
+  TASK_STATES,
+  type TaskPriority,
+  type TaskState,
+} from "../vocabulary.js";
 import { loadWebRoot, type WebRoot, WebRootError } from "../web.js";
 import type { CredentialStore } from "./credentials.js";
 import type { DirectoryStore } from "./directory.js";
 import {
   formatAnswer,
+  formatCategoryLine,
   formatDecision,
   formatDecisionLine,
   formatDocument,
   formatDocuments,
+  formatGoal,
+  formatGoalLine,
+  formatMore,
   formatOptions,
   formatProjectLine,
   formatRun,
@@ -28,6 +40,7 @@ import {
   formatTaskLine,
   formatVersion,
   formatVersionLine,
+  formatWork,
 } from "./format.js";
 import { COMMAND_HELP, helpFor, usage } from "./help.js";
 import { createServeHandler, DEFAULT_SERVE_PORT, type Listen } from "./serve.js";
@@ -255,6 +268,79 @@ function priorityOf(value: string | undefined): TaskPriority | undefined {
   return found;
 }
 
+function goalStateOf(value: string | undefined): GoalState | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+  const found = GOAL_STATES.find((state) => state === value);
+  if (found === undefined) {
+    throw misuse(`Not a state of a goal: ${value}. One of ${GOAL_STATES.join(", ")}`);
+  }
+  return found;
+}
+
+/** Today by this machine's clock, as a day. */
+const todayOf = (io: CliIo): string => dayOfDate(new Date(io.now()));
+
+/**
+ * A day as a flag takes one: `2026-10-24`, `today`, `tomorrow`, or `+<n>` days from today; and
+ * `none` where a field may be cleared, which is `null` on the wire.
+ */
+function dayOf(io: CliIo, value: string | undefined, clearable = false): string | null | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (clearable && value === "none") {
+    return null;
+  }
+  if (value === "today") {
+    return todayOf(io);
+  }
+  if (value === "tomorrow") {
+    return addDays(todayOf(io), 1);
+  }
+  const ahead = /^\+(\d{1,3})$/.exec(value);
+  if (ahead !== null) {
+    return addDays(todayOf(io), Number(ahead[1]));
+  }
+  if (!isDay(value)) {
+    throw misuse(`Not a day: ${value}. Say it as 2026-10-24, today, tomorrow, or +7`);
+  }
+  return value;
+}
+
+/** A value a field is set to, or `none` to clear it, which is `null` on the wire. */
+const orNone = (value: string | undefined): string | null | undefined =>
+  value === "none" ? null : value;
+
+/** The id of the person a flag names: `me`, or a login of the workspace. */
+async function personIdOf(
+  session: Session,
+  value: string | undefined,
+): Promise<string | null | undefined> {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (value === "none") {
+    return null;
+  }
+  if (value === "me") {
+    const me = await session.client.me();
+    if (me.person === null) {
+      throw failed("The console does not know this token. Sign in again: console login");
+    }
+    return me.person.id;
+  }
+  const { items } = await session.client.people();
+  const found = items.find((person) => person.login.toLowerCase() === value.toLowerCase());
+  if (found === undefined) {
+    throw misuse(
+      `Nobody of the workspace is called ${value}. console people is not a command; the logins are as people sign in.`,
+    );
+  }
+  return found.id;
+}
+
 function secondsOf(value: string | undefined, fallback: number): number {
   if (value === undefined) {
     return fallback;
@@ -266,6 +352,26 @@ function secondsOf(value: string | undefined, fallback: number): number {
   return seconds;
 }
 
+/** The flags of a page of a listing: how many, from which one on. */
+const PAGE_OPTIONS: OptionSpec = { limit: { type: "string" }, offset: { type: "string" } };
+
+/** The page the flags ask for: `DEFAULT_PAGE_LIMIT` items from the first when nothing is said. */
+function pageOf(values: Values): { readonly limit: number; readonly offset: number } {
+  const limit = text(values, "limit");
+  const offset = text(values, "offset");
+  const page = {
+    limit: limit === undefined ? DEFAULT_PAGE_LIMIT : Number(limit),
+    offset: offset === undefined ? 0 : Number(offset),
+  };
+  if (!Number.isInteger(page.limit) || page.limit < 1 || page.limit > LIST_LIMIT) {
+    throw misuse(`Not a number of items, 1 to ${LIST_LIMIT}: ${limit}`);
+  }
+  if (!Number.isInteger(page.offset) || page.offset < 0) {
+    throw misuse(`Not a number of items to skip: ${offset}`);
+  }
+  return page;
+}
+
 /** One positional, and nothing else. */
 function theOne(positionals: readonly string[], ask: string): string {
   const [first] = positionals;
@@ -452,13 +558,69 @@ const use: Command = async (args, io) => {
 };
 
 const tasks: Command = async (args, io) => {
-  const { values } = parse(args, { state: { type: "string" } }, false);
+  const { values } = parse(
+    args,
+    {
+      state: { type: "string" },
+      open: { type: "boolean" },
+      mine: { type: "boolean" },
+      category: { type: "string" },
+      goal: { type: "string" },
+      due: { type: "string" },
+      ...PAGE_OPTIONS,
+    },
+    false,
+  );
   const state = stateOf(text(values, "state"));
+  const page = pageOf(values);
   const session = await open(io, values);
   const project = await session.project();
-  const found = await project.tasks(state === undefined ? {} : { state });
+  // What is due: a day, or the words for the usual windows; overdue keeps only the open ones.
+  const due = text(values, "due");
+  const today = todayOf(io);
+  const dueBy =
+    due === undefined
+      ? undefined
+      : due === "overdue"
+        ? addDays(today, -1)
+        : due === "week"
+          ? addDays(today, 6)
+          : (dayOf(io, due) ?? undefined);
+  const assignee = on(values, "mine")
+    ? ((await personIdOf(session, "me")) ?? undefined)
+    : undefined;
+  const found = await project.tasks({
+    ...(state === undefined ? {} : { state }),
+    ...(on(values, "open") || due === "overdue" ? { open: true } : {}),
+    ...(assignee === undefined ? {} : { assignee }),
+    ...(text(values, "category") === undefined ? {} : { category: text(values, "category") }),
+    ...(text(values, "goal") === undefined ? {} : { goal: text(values, "goal") }),
+    ...(dueBy === undefined ? {} : { dueBy }),
+    ...page,
+  });
   answer(io, session, found, () =>
-    found.items.length === 0 ? "No tasks." : found.items.map(formatTaskLine).join("\n"),
+    found.items.length === 0
+      ? "No tasks."
+      : found.items.map(formatTaskLine).join("\n") +
+        formatMore(found.more, page.limit, page.offset),
+  );
+  return EXIT.ok;
+};
+
+const work: Command = async (args, io) => {
+  const { values } = parse(args, {}, false);
+  const session = await open(io, values);
+  const found = await session.client.work();
+  answer(io, session, found, () => formatWork(found));
+  return EXIT.ok;
+};
+
+const categories: Command = async (args, io) => {
+  const { values } = parse(args, {}, false);
+  const session = await open(io, values);
+  const found = await session.client.categories();
+  answer(io, session, found, () =>
+    found.items.length === 0 ? "No categories." : found.items.map(formatCategoryLine).join("\n"),
   );
   return EXIT.ok;
 };
@@ -472,33 +634,105 @@ const skills: Command = async (args, io) => {
   return EXIT.ok;
 };
 
+/** The flags that set a task's fields, shared by writing one and changing one. */
+const TASK_FIELDS: OptionSpec = {
+  state: { type: "string" },
+  priority: { type: "string" },
+  category: { type: "string" },
+  goal: { type: "string" },
+  starts: { type: "string" },
+  due: { type: "string" },
+  assignee: { type: "string" },
+  parent: { type: "string" },
+};
+
+/** What the flags say of a task's fields, as the API takes them; `none` clears a field. */
+async function taskFieldsOf(
+  io: CliIo,
+  session: Session,
+  project: ProjectClient,
+  values: Values,
+): Promise<RestTaskPatch> {
+  const state = stateOf(text(values, "state"));
+  const priority = priorityOf(text(values, "priority"));
+  const category = orNone(text(values, "category"));
+  const goalId = orNone(text(values, "goal"));
+  const startsOn = dayOf(io, text(values, "starts"), true);
+  const dueOn = dayOf(io, text(values, "due"), true);
+  const assigneeId = await personIdOf(session, text(values, "assignee"));
+  const parent = text(values, "parent");
+  const parentId =
+    parent === undefined ? undefined : parent === "none" ? null : (await project.task(parent)).id;
+  return {
+    ...(state === undefined ? {} : { state }),
+    ...(priority === undefined ? {} : { priority }),
+    ...(category === undefined ? {} : { category }),
+    ...(goalId === undefined ? {} : { goalId }),
+    ...(startsOn === undefined ? {} : { startsOn }),
+    ...(dueOn === undefined ? {} : { dueOn }),
+    ...(assigneeId === undefined ? {} : { assigneeId }),
+    ...(parentId === undefined ? {} : { parentId }),
+  };
+}
+
 const newTask: Command = async (args, io) => {
   const { values, positionals } = parse(args, {
+    ...TASK_FIELDS,
     body: { type: "string" },
     file: { type: "string" },
-    state: { type: "string" },
-    priority: { type: "string" },
   });
   const title = theOne(positionals, 'Say the title: console task new "<title>"');
-  const state = stateOf(text(values, "state"));
-  const priority = priorityOf(text(values, "priority"));
   const body = await bodyOf(io, values, text(values, "body"));
   const session = await open(io, values);
   const project = await session.project();
+  const fields = await taskFieldsOf(io, session, project, values);
   const made = await project.createTask({
     title,
     ...(body === undefined ? {} : { body }),
-    ...(state === undefined ? {} : { state }),
-    ...(priority === undefined ? {} : { priority }),
+    ...fields,
   });
   answer(io, session, made, () => `Task #${made.number} written: ${made.title}\nid: ${made.id}`);
   return EXIT.ok;
 };
 
+const editTask: Command = async (args, io) => {
+  const { values, positionals } = parse(args, {
+    ...TASK_FIELDS,
+    title: { type: "string" },
+    body: { type: "string" },
+    file: { type: "string" },
+  });
+  const ref = theOne(
+    positionals,
+    "Say which task: console task edit <number|id> --due <day> [--category <key>] ...",
+  );
+  const body = await bodyOf(io, values, text(values, "body"));
+  const session = await open(io, values);
+  const project = await session.project();
+  const title = text(values, "title");
+  const patch: RestTaskPatch = {
+    ...(title === undefined ? {} : { title }),
+    ...(body === undefined ? {} : { body }),
+    ...(await taskFieldsOf(io, session, project, values)),
+  };
+  if (Object.keys(patch).length === 0) {
+    throw misuse(
+      "Say what to change: --title, --body, --state, --priority, --category, --goal, --starts, --due, --assignee or --parent; none clears a field.",
+    );
+  }
+  const found = await project.task(ref);
+  const changed = await project.updateTask(found.id, patch);
+  answer(io, session, changed, () => formatTask(changed));
+  return EXIT.ok;
+};
+
 const task: Command = async (args, io) => {
   if (args[0] === "new") {
     return newTask(args.slice(1), io);
   }
+  if (args[0] === "edit") {
+    return editTask(args.slice(1), io);
+  }
   const { values, positionals } = parse(args, {});
   const ref = theOne(positionals, "Say which task: console task <number|id>");
   const session = await open(io, values);
@@ -527,7 +761,7 @@ const take: Command = async (args, io) => {
   });
   answer(io, session, { run, task: found }, () =>
     [
-      `Run ${run.id} began on #${found.number} ${found.title}, as "${run.agent}" for ${run.person.login}. The task is in progress and theirs.`,
+      `Run ${run.id} began on #${found.number} ${found.title}, as "${run.agent}" for ${run.person.login}. The task is in progress and theirs. A run that was open on it is over now: the board cannot know whether its agent still ran, so taking it was deciding.`,
       "",
       formatTask(found),
       "",
@@ -864,13 +1098,102 @@ const restore: Command = async (args, io) => {
   return EXIT.ok;
 };
 
+const goals: Command = async (args, io) => {
+  const { values } = parse(args, {}, false);
+  const session = await open(io, values);
+  const project = await session.project();
+  const found = await project.goals();
+  answer(io, session, found, () =>
+    found.items.length === 0
+      ? "No goals. An owner sets one: console goal new <title> --due <day>"
+      : found.items.map(formatGoalLine).join("\n"),
+  );
+  return EXIT.ok;
+};
+
+const GOAL_FIELDS: OptionSpec = {
+  state: { type: "string" },
+  due: { type: "string" },
+  body: { type: "string" },
+  file: { type: "string" },
+};
+
+const newGoal: Command = async (args, io) => {
+  const { values, positionals } = parse(args, GOAL_FIELDS);
+  const title = theOne(positionals, 'Say the title: console goal new "<title>" [--due <day>]');
+  const state = goalStateOf(text(values, "state"));
+  const dueOn = dayOf(io, text(values, "due"));
+  const body = await bodyOf(io, values, text(values, "body"));
+  const session = await open(io, values);
+  const project = await session.project();
+  const made = await project.createGoal({
+    title,
+    ...(body === undefined ? {} : { body }),
+    ...(state === undefined ? {} : { state }),
+    ...(dueOn === undefined ? {} : { dueOn }),
+  });
+  answer(io, session, made, () => `Goal set: ${made.title}\nid: ${made.id}`);
+  return EXIT.ok;
+};
+
+const editGoal: Command = async (args, io) => {
+  const { values, positionals } = parse(args, { ...GOAL_FIELDS, title: { type: "string" } });
+  const id = theOne(positionals, "Say which goal: console goal edit <id> --state <state> ...");
+  const title = text(values, "title");
+  const state = goalStateOf(text(values, "state"));
+  const dueOn = dayOf(io, text(values, "due"), true);
+  const body = await bodyOf(io, values, text(values, "body"));
+  const patch = {
+    ...(title === undefined ? {} : { title }),
+    ...(body === undefined ? {} : { body }),
+    ...(state === undefined ? {} : { state }),
+    ...(dueOn === undefined ? {} : { dueOn }),
+  };
+  if (Object.keys(patch).length === 0) {
+    throw misuse(
+      "Say what to change: --title, --body, --state or --due; --due none clears the day.",
+    );
+  }
+  const session = await open(io, values);
+  const project = await session.project();
+  const changed = await project.updateGoal(id, patch);
+  answer(io, session, changed, () => formatGoal(changed));
+  return EXIT.ok;
+};
+
+const goal: Command = async (args, io) => {
+  if (args[0] === "new") {
+    return newGoal(args.slice(1), io);
+  }
+  if (args[0] === "edit") {
+    return editGoal(args.slice(1), io);
+  }
+  const { values, positionals } = parse(args, {});
+  const id = theOne(positionals, "Say which goal: console goal <id>");
+  const session = await open(io, values);
+  const project = await session.project();
+  const found = await project.goal(id);
+  const towards = await project.tasks({ goal: found.id });
+  answer(io, session, { goal: found, tasks: towards.items }, () =>
+    formatGoal(found, towards.items),
+  );
+  return EXIT.ok;
+};
+
 const decisions: Command = async (args, io) => {
-  const { values } = parse(args, { open: { type: "boolean" } }, false);
+  const { values } = parse(args, { open: { type: "boolean" }, ...PAGE_OPTIONS }, false);
+  const page = pageOf(values);
   const session = await open(io, values);
   const project = await session.project();
-  const found = await project.decisions(on(values, "open") ? { open: true } : {});
+  const found = await project.decisions({
+    ...(on(values, "open") ? { open: true } : {}),
+    ...page,
+  });
   answer(io, session, found, () =>
-    found.items.length === 0 ? "No decisions." : found.items.map(formatDecisionLine).join("\n"),
+    found.items.length === 0
+      ? "No decisions."
+      : found.items.map(formatDecisionLine).join("\n") +
+        formatMore(found.more, page.limit, page.offset),
   );
   return EXIT.ok;
 };
@@ -923,9 +1246,15 @@ const abandon: Command = async (args, io) => {
 const runs: Command = async (args, io) => {
   const { values } = parse(
     args,
-    { task: { type: "string" }, open: { type: "boolean" }, mine: { type: "boolean" } },
+    {
+      task: { type: "string" },
+      open: { type: "boolean" },
+      mine: { type: "boolean" },
+      ...PAGE_OPTIONS,
+    },
     false,
   );
+  const page = pageOf(values);
   const session = await open(io, values);
   const project = await session.project();
   const ref = text(values, "task");
@@ -934,9 +1263,12 @@ const runs: Command = async (args, io) => {
     ...(taskId === undefined ? {} : { task: taskId }),
     ...(on(values, "open") ? { open: true } : {}),
     ...(on(values, "mine") ? { mine: true } : {}),
+    ...page,
   });
   answer(io, session, found, () =>
-    found.items.length === 0 ? "No runs." : found.items.map(formatRunLine).join("\n"),
+    found.items.length === 0
+      ? "No runs."
+      : found.items.map(formatRunLine).join("\n") + formatMore(found.more, page.limit, page.offset),
   );
   return EXIT.ok;
 };
@@ -1024,8 +1356,12 @@ const COMMANDS: Readonly<Record<string, Command>> = {
   serve,
   projects,
   use,
+  work,
   tasks,
   task,
+  goals,
+  goal,
+  categories,
   skills,
   take,
   report,
@@ -1072,6 +1408,14 @@ function hintFor(error: ApiError): string {
       return "The page has moved on since the version you started from. Read it again, and write from there.\n";
     case "document.archived":
       return "The page is archived. console restore <path> brings it back first.\n";
+    case "task.invalid_category":
+      return "No category has that key. console categories lists them.\n";
+    case "task.invalid_goal":
+      return "No goal of this project has that id. console goals lists them.\n";
+    case "task.invalid_dates":
+      return "The due day is before the start. Say a due day on or after it.\n";
+    case "goal.not_found":
+      return "No goal of this project has that id. console goals lists them.\n";
     case "connect.too_many":
       return "The console holds as many connections as it may at once. Try again in a few minutes.\n";
     case "network":

package/src/cli/format.ts

@@ -1,15 +1,18 @@
 import type {
   RestArtifact,
+  RestCategory,
   RestDecision,
   RestDocument,
   RestDocumentSummary,
   RestDocuments,
+  RestGoal,
   RestProject,
   RestRun,
   RestSkills,
   RestTask,
   RestVersion,
   RestVersionSummary,
+  RestWork,
 } from "../schemas.js";
 
 // What the command prints: one line per thing in a list, a few lines for one thing in full.
@@ -36,26 +39,53 @@ export function formatProjectLine(project: RestProject): string {
   if (project.openDecisions > 0) {
     notes.push(`${plural(project.openDecisions, "decision")} waiting`);
   }
-  if (project.openRuns > 0) {
-    notes.push(`${plural(project.openRuns, "agent")} at work`);
-  }
   return `${project.key}  ${project.name}  (${notes.join("; ")})`;
 }
 
+/** The line under a page of a listing that has more after it: how to ask for the next page. */
+export function formatMore(more: boolean, limit: number, offset: number): string {
+  return more ? `\n... more: --offset ${offset + limit}` : "";
+}
+
 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.category !== null) {
+    notes.push(task.category.key);
+  }
+  if (task.dueOn !== null) {
+    notes.push(`due ${task.dueOn}`);
+  }
   if (task.openDecisions > 0) {
     notes.push(`${plural(task.openDecisions, "decision")} waiting`);
   }
-  if (task.openRuns > 0) {
-    notes.push("an agent at work");
-  }
   return `#${task.number}  ${task.state}  ${task.priority}  ${task.title}  (${notes.join("; ")})`;
 }
 
+/** The plan and what happened, as a line each, only where there is something to say. */
+function scheduleLines(task: RestTask): string[] {
+  const lines: string[] = [];
+  const plan = [
+    task.category === null ? undefined : `category: ${task.category.key}`,
+    task.goalId === null ? undefined : `goal: ${task.goalId}`,
+    task.startsOn === null ? undefined : `starts: ${task.startsOn}`,
+    task.dueOn === null ? undefined : `due: ${task.dueOn}`,
+  ].filter((part) => part !== undefined);
+  if (plan.length > 0) {
+    lines.push(plan.join("  "));
+  }
+  const happened = [
+    task.startedAt === null ? undefined : `started: ${task.startedAt}`,
+    task.doneAt === null ? undefined : `done: ${task.doneAt}`,
+  ].filter((part) => part !== undefined);
+  if (happened.length > 0) {
+    lines.push(happened.join("  "));
+  }
+  return lines;
+}
+
 /** One task in full; with the decisions about it and the runs on it, when given. */
 export function formatTask(
   task: RestTask,
@@ -66,6 +96,7 @@ export function formatTask(
     `#${task.number} ${task.title}`,
     `state: ${task.state}  priority: ${task.priority}  owner: ${task.owner.login}  assignee: ${task.assignee?.login ?? "nobody"}`,
     `id: ${task.id}${task.parentId === null ? "" : `  part of: ${task.parentId}`}`,
+    ...scheduleLines(task),
   ];
   if (task.links.length > 0) {
     lines.push("links:");
@@ -96,6 +127,9 @@ export function formatRunLine(run: RestRun): string {
   if (run.waitingFor !== null) {
     notes.push(`waiting for decision ${run.waitingFor}`);
   }
+  if (run.endedAt === null) {
+    notes.push(`last heard ${run.lastHeardAt}`);
+  }
   return `${run.id}  ${run.status}  ${run.agent} for ${run.person.login}  task #${run.taskNumber}  (${notes.join(", ")})`;
 }
 
@@ -165,6 +199,62 @@ export function formatSkills(skills: RestSkills): string {
   return lines.join("\n");
 }
 
+/** How far a goal is, from its tasks: the done, the at work, and the rest, in one phrase. */
+function progressOf(goal: RestGoal): string {
+  const counts = goal.taskCounts;
+  const total = counts.idea + counts.ready + counts.in_progress + counts.in_review + counts.done;
+  const working = counts.in_progress + counts.in_review;
+  return `${counts.done}/${total} done${working === 0 ? "" : `, ${working} in progress`}${counts.dropped === 0 ? "" : `, ${counts.dropped} dropped`}`;
+}
+
+/** One goal: its id, its state, its title, when it is due, and how far it is. */
+export function formatGoalLine(goal: RestGoal): string {
+  const notes = [goal.dueOn === null ? "no target day" : `due ${goal.dueOn}`, progressOf(goal)];
+  return `${goal.id}  ${goal.state}  ${goal.title}  (${notes.join("; ")})`;
+}
+
+/** One goal in full; with the tasks that work towards it, when given. */
+export function formatGoal(goal: RestGoal, tasks?: readonly RestTask[]): string {
+  const lines = [
+    `goal ${goal.id}: ${goal.title}`,
+    `state: ${goal.state}  due: ${goal.dueOn ?? "none"}  set by: ${goal.createdBy.login}`,
+    `progress: ${progressOf(goal)}`,
+  ];
+  if (goal.body.trim().length > 0) {
+    lines.push("", goal.body.trimEnd());
+  }
+  if (tasks !== undefined) {
+    lines.push("", tasks.length === 0 ? "tasks: none" : "tasks:");
+    for (const task of tasks) {
+      lines.push(`  ${formatTaskLine(task)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+/** One category: its key, what people call it, and its colour. */
+export function formatCategoryLine(category: RestCategory): string {
+  return `${category.key}  ${category.name}  (${category.color})`;
+}
+
+/** What is on a person's plate: their open tasks by project, and the decisions waiting. */
+export function formatWork(work: RestWork): string {
+  const lines: string[] = [];
+  if (work.tasks.length === 0) {
+    lines.push("No open task is assigned to you.");
+  } else {
+    lines.push("tasks assigned to you:");
+    for (const { project, task } of work.tasks) {
+      lines.push(`  ${project.key}  ${formatTaskLine(task)}`);
+    }
+  }
+  lines.push("", work.decisions.length === 0 ? "decisions waiting: none" : "decisions waiting:");
+  for (const { project, decision } of work.decisions) {
+    lines.push(`  ${project.key}  ${formatDecisionLine(decision)}`);
+  }
+  return lines.join("\n");
+}
+
 export function formatDecisionLine(decision: RestDecision): string {
   const state = decision.answer === null ? "waiting" : `answered ${decision.answer.option}`;
   return `${decision.id}  ${state}  ${decision.question}  (asked by ${asker(decision)})`;