@skillcdn/console 0.1.9 → 0.1.10

package/src/dates.ts

@@ -0,0 +1,143 @@
+// Days, as the plan is made in (ADR-0019): `2026-10-20`, read and written as the strings they
+// are, so that a deadline is the same day wherever the people are. The browser's own clock says
+// which day is today; nothing here looks at it unless asked.
+
+const DAY = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+/** Whether a string is a day as the API spells one. */
+export function isDay(value: string | null | undefined): value is string {
+  return value !== null && value !== undefined && DAY.test(value);
+}
+
+/** A day from a local date: the date the browser's clock shows, not the UTC one. */
+export function dayOf(date: Date): string {
+  const year = String(date.getFullYear()).padStart(4, "0");
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+/** Today, by the browser's clock. */
+export function today(now: Date = new Date()): string {
+  return dayOf(now);
+}
+
+/** A local date at noon of the day, so that a daylight-saving change never moves it a day. */
+export function dateOf(day: string): Date {
+  const match = DAY.exec(day);
+  if (match === null) {
+    return new Date(Number.NaN);
+  }
+  return new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]), 12);
+}
+
+/** The day `count` days after `day`; negative counts go back. */
+export function addDays(day: string, count: number): string {
+  const date = dateOf(day);
+  date.setDate(date.getDate() + count);
+  return dayOf(date);
+}
+
+/** How many days `to` is after `from`; negative when it is before. */
+export function daysBetween(from: string, to: string): number {
+  const millis = dateOf(to).getTime() - dateOf(from).getTime();
+  return Math.round(millis / 86_400_000);
+}
+
+/** The month a day is in: `2026-10`. */
+export function monthOf(day: string): string {
+  return day.slice(0, 7);
+}
+
+/** Whether a string is a month as the calendar's address spells one. */
+export function isMonth(value: string | null | undefined): value is string {
+  return value !== null && value !== undefined && /^\d{4}-(0[1-9]|1[0-2])$/.test(value);
+}
+
+/** The month `count` months after `month`; negative counts go back. */
+export function addMonths(month: string, count: number): string {
+  const year = Number(month.slice(0, 4));
+  const index = Number(month.slice(5, 7)) - 1 + count;
+  const date = new Date(year, index, 1, 12);
+  return `${String(date.getFullYear()).padStart(4, "0")}-${String(date.getMonth() + 1).padStart(2, "0")}`;
+}
+
+/** The weekday a week begins on where the language is spoken: 1 for Monday, 7 for Sunday. */
+export function firstDayOfWeek(language: string): number {
+  try {
+    const locale = new Intl.Locale(language) as Intl.Locale & {
+      readonly weekInfo?: { readonly firstDay: number };
+      readonly getWeekInfo?: () => { readonly firstDay: number };
+    };
+    const info = locale.getWeekInfo?.() ?? locale.weekInfo;
+    if (info !== undefined && info.firstDay >= 1 && info.firstDay <= 7) {
+      return info.firstDay;
+    }
+  } catch {
+    // A tag the browser does not know: the week begins on Monday.
+  }
+  return 1;
+}
+
+/** One cell of a month's grid: the day, and whether it is of the month shown or a neighbour's. */
+export interface GridDay {
+  readonly day: string;
+  readonly inMonth: boolean;
+}
+
+/**
+ * The weeks of a month as a calendar shows them: full weeks, beginning on `firstDay` (1 for
+ * Monday, 7 for Sunday), with the neighbouring months' days filling the first and the last.
+ */
+export function monthGrid(month: string, firstDay = 1): GridDay[][] {
+  const first = `${month}-01`;
+  const start = dateOf(first);
+  // getDay: 0 for Sunday; the grid counts Monday as 1 and Sunday as 7.
+  const weekday = start.getDay() === 0 ? 7 : start.getDay();
+  const back = (weekday - firstDay + 7) % 7;
+  let cursor = addDays(first, -back);
+  const weeks: GridDay[][] = [];
+  do {
+    const week: GridDay[] = [];
+    for (let column = 0; column < 7; column += 1) {
+      week.push({ day: cursor, inMonth: monthOf(cursor) === month });
+      cursor = addDays(cursor, 1);
+    }
+    weeks.push(week);
+  } while (monthOf(cursor) === month);
+  return weeks;
+}
+
+/** The weekdays in the order a week is shown, from `firstDay`, as the grid counts them. */
+export function weekdays(firstDay = 1): number[] {
+  return Array.from({ length: 7 }, (_, index) => ((firstDay - 1 + index) % 7) + 1);
+}
+
+/** A day as people read one in a language: the month and the day, with the year when it is not this year's. */
+export function formatDay(day: string, language?: string, now: Date = new Date()): string {
+  const date = dateOf(day);
+  if (Number.isNaN(date.getTime())) {
+    return day;
+  }
+  return date.toLocaleDateString(language, {
+    month: "short",
+    day: "numeric",
+    ...(date.getFullYear() === now.getFullYear() ? {} : { year: "numeric" }),
+  });
+}
+
+/** A month as people read one: the month and the year. */
+export function formatMonth(month: string, language?: string): string {
+  const date = dateOf(`${month}-01`);
+  if (Number.isNaN(date.getTime())) {
+    return month;
+  }
+  return date.toLocaleDateString(language, { month: "long", year: "numeric" });
+}
+
+/** A weekday as people read one, short, as the grid counts them: 1 for Monday, 7 for Sunday. */
+export function formatWeekday(weekday: number, language?: string): string {
+  // The week of 2024-01-01 began on a Monday.
+  const date = new Date(2024, 0, weekday, 12);
+  return date.toLocaleDateString(language, { weekday: "short" });
+}

package/src/i18n/en.ts

@@ -1,5 +1,7 @@
 import type { SignInFailure } from "../routes.js";
 import type {
+  CategoryColor,
+  GoalState,
   PersonRole,
   ProjectRole,
   ProjectVisibility,
@@ -47,6 +49,22 @@ export const en = {
       failed: "Failed",
       abandoned: "Abandoned",
     } satisfies Record<RunStatus, string>,
+    goalState: {
+      planned: "Planned",
+      active: "Active",
+      done: "Reached",
+      dropped: "Dropped",
+    } satisfies Record<GoalState, string>,
+    categoryColor: {
+      gray: "Gray",
+      blue: "Blue",
+      green: "Green",
+      orange: "Orange",
+      pink: "Pink",
+      purple: "Purple",
+      teal: "Teal",
+      yellow: "Yellow",
+    } satisfies Record<CategoryColor, string>,
   },
 
   common: {
@@ -81,9 +99,13 @@ export const en = {
 
   nav: {
     projects: "Projects",
+    work: "My work",
     people: "People",
     agents: "Agents",
+    categories: "Categories",
     board: "Board",
+    roadmap: "Roadmap",
+    calendar: "Calendar",
     docs: "Docs",
     decisions: "Decisions",
     feed: "Feed",
@@ -187,7 +209,25 @@ export const en = {
     decisionsTitle: "Decisions waiting for a person",
     agentAtWork: "agent at work",
     agentAtWorkTitle: "An agent is at work on it",
-    links: (n: number) => count(n, "link", "links"),
+    agentSince: (agent: string, since: string) => `${agent}, at work since ${since}`,
+    filters: {
+      aria: "Narrow the board",
+      everyone: "Everyone",
+      mine: "Mine",
+      anyCategory: "Any category",
+      noCategory: "No category",
+      anyGoal: "Any goal",
+      noGoal: "No goal",
+      clear: "Show everything",
+      showing: (n: number, of: number) => `${n} of ${count(of, "task", "tasks")}`,
+    },
+    due: {
+      overdue: (days: number) => `${count(days, "day", "days")} overdue`,
+      today: "Due today",
+      tomorrow: "Due tomorrow",
+      inDays: (days: number) => `Due in ${count(days, "day", "days")}`,
+      on: (day: string) => `Due ${day}`,
+    },
   },
 
   task: {
@@ -213,6 +253,19 @@ export const en = {
     history: "What happened",
     subtasks: "Subtasks",
     partOfIt: "Part of it",
+    category: "Category",
+    goal: "Goal",
+    plan: "Plan",
+    planned: (from: string | undefined, to: string | undefined) =>
+      from !== undefined && to !== undefined
+        ? `${from} to ${to}`
+        : from !== undefined
+          ? `from ${from}`
+          : to !== undefined
+            ? `by ${to}`
+            : "",
+    started: "Started",
+    done: "Done",
     form: {
       title: "Title",
       body: "Body",
@@ -221,6 +274,12 @@ export const en = {
       priority: "Priority",
       assignee: "Assignee",
       partOf: "Part of",
+      category: "Category",
+      noCategory: "No category",
+      goal: "Goal",
+      noGoal: "No goal",
+      startsOn: "Starts on",
+      dueOn: "Due on",
       links: "Links",
       label: "Label",
       addLink: "Add a link",
@@ -244,6 +303,10 @@ export const en = {
     },
     waiting: "Waiting",
     answered: "Answered",
+    record: "The record",
+    recordLead:
+      "Every decision answered, newest first: what was asked, what was chosen, by whom. Open one for its context, its rationale and what followed.",
+    openRecord: "Open",
     waitingForPerson: "Waiting for a person.",
     options: "Options",
     notePlaceholder: "A word about it, if any",
@@ -271,6 +334,112 @@ export const en = {
     },
   },
 
+  calendar: {
+    title: "Calendar",
+    lead: "The tasks by the day they are due. A task with a start is shown from it; one with no day waits at the bottom to be given one.",
+    grid: "The month",
+    previous: "The month before",
+    next: "The month after",
+    thisMonth: "This month",
+    nothingDue: "Nothing is due this month.",
+    overdue: "Overdue",
+    nothingOverdue: "Nothing is overdue.",
+    unscheduled: "No day set",
+    allScheduled: "Every open task has a day.",
+    starts: "starts",
+    workload: {
+      title: "Who has what",
+      lead: "The open tasks of each person, and what of them is late or due within the week.",
+      person: "Person",
+      open: "Open",
+      inProgress: "In progress",
+      dueSoon: "Due in 7 days",
+      overdue: "Overdue",
+      unassigned: "Nobody's yet",
+    },
+  },
+
+  roadmap: {
+    title: "Roadmap",
+    lead: "What the project works towards: each goal with the day it is meant to be reached by, and how far its tasks are. Progress is read from the board as it stands.",
+    setGoal: "Set a goal",
+    setGoalAria: "Set a goal",
+    editAria: "Change the goal",
+    one: "Goal",
+    all: "All goals",
+    empty: {
+      title: "No goal is set yet",
+      body: "An owner sets the first one: what to reach, and by when. Tasks are then written towards it.",
+    },
+    noSuch: {
+      title: "No such goal",
+      body: "It may belong to another project, or the link is wrong.",
+    },
+    onlyOwner: {
+      title: "Only an owner sets the roadmap",
+      body: "Ask one of the project's owners, or a workspace administrator.",
+    },
+    progress: (done: number, of: number) => `${done} of ${count(of, "task", "tasks")} done`,
+    inProgress: (n: number) => `${n} in progress`,
+    noTasks: "No task works towards it yet.",
+    tasks: "Tasks",
+    target: "Target",
+    noTarget: "No target day",
+    setBy: "Set by",
+    state: "State",
+    nothingMore: "Nothing more was written about it.",
+    form: {
+      title: "Title",
+      body: "What reaching it means",
+      bodyPlaceholder: "What is true once the goal is reached, in Markdown.",
+      state: "State",
+      dueOn: "Target day",
+      set: "Set the goal",
+    },
+  },
+
+  work: {
+    title: "My work",
+    lead: "What is on your plate across your projects: the open tasks assigned to you, by the day they are due, and the decisions that wait for a person.",
+    loading: "Loading your work",
+    couldNotLoad: "Your work could not be loaded.",
+    empty: {
+      title: "Nothing is assigned to you",
+      body: "A task assigned to you in any project you may see shows up here.",
+    },
+    overdue: "Overdue",
+    thisWeek: "Due this week",
+    later: "Later",
+    noDay: "No day set",
+    decisions: "Decisions waiting for a person",
+    noDecisions: "No decision waits.",
+    inProject: (project: string) => `in ${project}`,
+  },
+
+  categories: {
+    title: "Categories",
+    lead: "The kinds of work tasks are sorted into, the same in every project. A task carries one, the board is narrowed by one, and an administrator keeps the list.",
+    onlyAdmin: "An administrator adds, changes and removes them; everyone else reads them here.",
+    list: "Categories",
+    add: "Add a category",
+    addAria: "Add a category",
+    empty: {
+      title: "No categories",
+      body: "An administrator adds the first one here.",
+    },
+    inUse: "A category tasks are sorted into cannot be removed until they are moved out of it.",
+    form: {
+      name: "Name",
+      key: "Key",
+      keyHint:
+        "Lowercase letters, digits and hyphens: what the command and the filters say. It does not change.",
+      color: "Colour",
+      add: "Add",
+    },
+    nameOf: (key: string) => `Name of ${key}`,
+    colorOf: (key: string) => `Colour of ${key}`,
+  },
+
   feed: {
     title: "What happened",
     list: "What happened",
@@ -284,6 +453,8 @@ export const en = {
     something: "something",
     aQuestion: "a question",
     aFile: "a file",
+    aGoal: "a goal",
+    aCategory: "a category",
     thePage: (name: string) => `the page ${name}`.trimEnd(),
     role: {
       admin: "an administrator",
@@ -303,6 +474,12 @@ export const en = {
       visibility: "who is a member",
       skillsAddress: "the skills address",
       outcome: "what followed",
+      category: "the category",
+      goalId: "the goal",
+      startsOn: "the start",
+      dueOn: "the due date",
+      state: "the state",
+      color: "the colour",
     } as Readonly<Record<string, string>>,
     event: {
       personJoined: () => "joined the board",
@@ -315,6 +492,12 @@ export const en = {
       memberChanged: (login: string, role: string, project: string) =>
         `made ${login} ${role} of ${project}`,
       memberRemoved: (login: string, project: string) => `removed ${login} from ${project}`,
+      categoryCreated: (category: string) => `made the category ${category}`,
+      categoryUpdated: (fields: string, category: string) =>
+        `changed ${fields} of the category ${category}`,
+      categoryRemoved: (category: string) => `removed the category ${category}`,
+      goalCreated: (goal: string) => `set the goal ${goal}`,
+      goalUpdated: (fields: string, goal: string) => `changed ${fields} of the goal ${goal}`,
       taskCreated: (task: string) => `wrote ${task}`,
       taskMoved: (task: string, from: string, to: string) => `moved ${task} from ${from} to ${to}`,
       taskUpdated: (fields: string, task: string) => `changed ${fields} of ${task}`,

package/src/i18n/ko.ts

@@ -27,6 +27,17 @@ export const ko: Messages = {
       failed: "실패",
       abandoned: "중단됨",
     },
+    goalState: { planned: "계획됨", active: "진행 중", done: "달성", dropped: "중단" },
+    categoryColor: {
+      gray: "회색",
+      blue: "파랑",
+      green: "초록",
+      orange: "주황",
+      pink: "분홍",
+      purple: "보라",
+      teal: "청록",
+      yellow: "노랑",
+    },
   },
 
   common: {
@@ -61,9 +72,13 @@ export const ko: Messages = {
 
   nav: {
     projects: "프로젝트",
+    work: "내 작업",
     people: "사람들",
     agents: "에이전트",
+    categories: "카테고리",
     board: "보드",
+    roadmap: "로드맵",
+    calendar: "캘린더",
     docs: "문서",
     decisions: "결정",
     feed: "피드",
@@ -166,7 +181,25 @@ export const ko: Messages = {
     decisionsTitle: "사람을 기다리는 결정",
     agentAtWork: "에이전트 작업 중",
     agentAtWorkTitle: "에이전트가 이 작업을 하고 있습니다",
-    links: (n) => `링크 ${n}개`,
+    agentSince: (agent, since) => `${agent}, ${since}부터 작업 중`,
+    filters: {
+      aria: "보드 좁혀 보기",
+      everyone: "모두",
+      mine: "내 작업",
+      anyCategory: "모든 카테고리",
+      noCategory: "카테고리 없음",
+      anyGoal: "모든 목표",
+      noGoal: "목표 없음",
+      clear: "전체 보기",
+      showing: (n, of) => `작업 ${of}개 중 ${n}개`,
+    },
+    due: {
+      overdue: (days) => `${days}일 지남`,
+      today: "오늘 마감",
+      tomorrow: "내일 마감",
+      inDays: (days) => `${days}일 남음`,
+      on: (day) => `${day} 마감`,
+    },
   },
 
   task: {
@@ -192,6 +225,19 @@ export const ko: Messages = {
     history: "일어난 일",
     subtasks: "하위 작업",
     partOfIt: "하위 작업",
+    category: "카테고리",
+    goal: "목표",
+    plan: "일정",
+    planned: (from, to) =>
+      from !== undefined && to !== undefined
+        ? `${from}부터 ${to}까지`
+        : from !== undefined
+          ? `${from}부터`
+          : to !== undefined
+            ? `${to}까지`
+            : "",
+    started: "시작",
+    done: "완료",
     form: {
       title: "제목",
       body: "본문",
@@ -200,6 +246,12 @@ export const ko: Messages = {
       priority: "우선순위",
       assignee: "배정",
       partOf: "상위 작업",
+      category: "카테고리",
+      noCategory: "카테고리 없음",
+      goal: "목표",
+      noGoal: "목표 없음",
+      startsOn: "시작일",
+      dueOn: "기한",
       links: "링크",
       label: "이름",
       addLink: "링크 추가",
@@ -223,6 +275,10 @@ export const ko: Messages = {
     },
     waiting: "대기 중",
     answered: "답변됨",
+    record: "기록",
+    recordLead:
+      "답변된 모든 결정, 최신순. 무엇을 물었고, 무엇을 골랐고, 누가 골랐는지. 맥락과 근거, 그 뒤에 일어난 일은 각 결정을 열어 봅니다.",
+    openRecord: "열기",
     waitingForPerson: "사람을 기다리는 중입니다.",
     options: "선택지",
     notePlaceholder: "덧붙일 말이 있다면",
@@ -250,6 +306,111 @@ export const ko: Messages = {
     },
   },
 
+  calendar: {
+    title: "캘린더",
+    lead: "작업을 기한일에 놓고 봅니다. 시작일이 있는 작업은 그날부터 보이고, 날짜가 없는 작업은 아래에서 날짜를 기다립니다.",
+    grid: "이 달",
+    previous: "이전 달",
+    next: "다음 달",
+    thisMonth: "이번 달",
+    nothingDue: "이 달에 마감인 작업이 없습니다.",
+    overdue: "기한 지남",
+    nothingOverdue: "기한이 지난 작업이 없습니다.",
+    unscheduled: "날짜 없음",
+    allScheduled: "열린 작업마다 날짜가 있습니다.",
+    starts: "시작",
+    workload: {
+      title: "누가 무엇을",
+      lead: "사람마다 열린 작업과, 그중 늦은 것과 일주일 안에 마감인 것.",
+      person: "사람",
+      open: "열림",
+      inProgress: "진행 중",
+      dueSoon: "7일 내 마감",
+      overdue: "기한 지남",
+      unassigned: "아직 배정 없음",
+    },
+  },
+
+  roadmap: {
+    title: "로드맵",
+    lead: "프로젝트가 향하는 것. 목표마다 달성 목표일과, 그 아래 작업들이 어디까지 왔는지. 진행은 보드의 현재 상태에서 그대로 읽습니다.",
+    setGoal: "목표 세우기",
+    setGoalAria: "목표 세우기",
+    editAria: "목표 바꾸기",
+    one: "목표",
+    all: "모든 목표",
+    empty: {
+      title: "아직 세운 목표가 없습니다",
+      body: "소유자가 첫 목표를 세웁니다. 무엇을, 언제까지. 그 뒤 작업을 그 목표를 향해 씁니다.",
+    },
+    noSuch: {
+      title: "그런 목표가 없습니다",
+      body: "다른 프로젝트의 것이거나, 링크가 잘못됐습니다.",
+    },
+    onlyOwner: {
+      title: "로드맵은 소유자만 세웁니다",
+      body: "프로젝트 소유자나 워크스페이스 관리자에게 요청하세요.",
+    },
+    progress: (done, of) => `작업 ${of}개 중 ${done}개 완료`,
+    inProgress: (n) => `${n}개 진행 중`,
+    noTasks: "아직 이 목표를 향한 작업이 없습니다.",
+    tasks: "작업",
+    target: "목표일",
+    noTarget: "목표일 없음",
+    setBy: "세운 사람",
+    state: "상태",
+    nothingMore: "더 적힌 내용이 없습니다.",
+    form: {
+      title: "제목",
+      body: "달성의 의미",
+      bodyPlaceholder: "목표를 이루면 무엇이 참이 되는지, Markdown으로.",
+      state: "상태",
+      dueOn: "목표일",
+      set: "목표 세우기",
+    },
+  },
+
+  work: {
+    title: "내 작업",
+    lead: "내 프로젝트들에 걸쳐 내게 놓인 일. 내게 배정된 열린 작업을 기한순으로, 그리고 사람을 기다리는 결정.",
+    loading: "내 작업을 불러오는 중",
+    couldNotLoad: "내 작업을 불러올 수 없습니다.",
+    empty: {
+      title: "내게 배정된 작업이 없습니다",
+      body: "볼 수 있는 어느 프로젝트에서든 내게 배정된 작업이 여기에 나타납니다.",
+    },
+    overdue: "기한 지남",
+    thisWeek: "이번 주 마감",
+    later: "그 뒤",
+    noDay: "날짜 없음",
+    decisions: "사람을 기다리는 결정",
+    noDecisions: "기다리는 결정이 없습니다.",
+    inProject: (project) => `${project}에서`,
+  },
+
+  categories: {
+    title: "카테고리",
+    lead: "작업을 나누는 일의 종류이며, 모든 프로젝트에서 같습니다. 작업은 하나를 가지고, 보드는 하나로 좁혀 보며, 관리자가 목록을 관리합니다.",
+    onlyAdmin: "관리자가 추가하고 바꾸고 제거합니다. 다른 사람은 여기서 읽습니다.",
+    list: "카테고리",
+    add: "카테고리 추가",
+    addAria: "카테고리 추가",
+    empty: {
+      title: "카테고리가 없습니다",
+      body: "관리자가 여기서 첫 카테고리를 추가합니다.",
+    },
+    inUse: "작업이 속해 있는 카테고리는 그 작업들을 옮기기 전에는 제거할 수 없습니다.",
+    form: {
+      name: "이름",
+      key: "키",
+      keyHint: "소문자, 숫자, 하이픈. 명령과 필터가 부르는 이름이며 바뀌지 않습니다.",
+      color: "색",
+      add: "추가",
+    },
+    nameOf: (key) => `${key}의 이름`,
+    colorOf: (key) => `${key}의 색`,
+  },
+
   feed: {
     title: "일어난 일",
     list: "일어난 일",
@@ -263,6 +424,8 @@ export const ko: Messages = {
     something: "무언가",
     aQuestion: "질문",
     aFile: "파일",
+    aGoal: "목표",
+    aCategory: "카테고리",
     thePage: (name) => `페이지 ${name}`.trimEnd(),
     role: {
       admin: "관리자",
@@ -282,6 +445,12 @@ export const ko: Messages = {
       visibility: "멤버 범위",
       skillsAddress: "스킬 주소",
       outcome: "그 뒤에 일어난 일",
+      category: "카테고리",
+      goalId: "목표",
+      startsOn: "시작일",
+      dueOn: "기한",
+      state: "상태",
+      color: "색",
     },
     event: {
       personJoined: () => "보드에 들어왔습니다",
@@ -293,6 +462,11 @@ export const ko: Messages = {
       memberChanged: (login, role, project) =>
         `${login}을(를) ${project}의 ${role}(으)로 지정했습니다`,
       memberRemoved: (login, project) => `${login}을(를) ${project}에서 제외했습니다`,
+      categoryCreated: (category) => `카테고리 ${category}을(를) 만들었습니다`,
+      categoryUpdated: (fields, category) => `카테고리 ${category}의 ${fields}을(를) 바꿨습니다`,
+      categoryRemoved: (category) => `카테고리 ${category}을(를) 제거했습니다`,
+      goalCreated: (goal) => `목표 ${goal}을(를) 세웠습니다`,
+      goalUpdated: (fields, goal) => `목표 ${goal}의 ${fields}을(를) 바꿨습니다`,
       taskCreated: (task) => `${task}을(를) 썼습니다`,
       taskMoved: (task, from, to) => `${task}을(를) ${from}에서 ${to}(으)로 옮겼습니다`,
       taskUpdated: (fields, task) => `${task}의 ${fields}을(를) 바꿨습니다`,