taskchef 7.6.0 → 7.7.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.6.0",
+  "version": "7.7.0",
   "description": "Dispatch work from a data-only workspace to visible Codex project tasks.",
   "author": {
     "name": "Favo Yang",

package/README.md

@@ -180,6 +180,12 @@ Task and result times are relative through 29 days (with minute detail for the
 first six hours), then use a locale-aware calendar date. Each time is a keyboard-
 accessible toggle for its full locale-aware date and time, and one shared
 30-second timer keeps relative labels current without reloading the page.
+The Updates panel captures immutable event-time lifecycle notices. It identifies
+them by task, turn when available, and lifecycle event rather than dashboard
+revision, so reconnects and non-semantic rewrites do not replay a notice and a
+later task state cannot rewrite an older notice. A notice remains readable if
+its task disappears; selecting it then explains that current details are no
+longer available.
 It does not mutate TaskChef data and prints its local URL.
 When a compatible foreground dashboard already owns port 3210,
 `ensure_dashboard` reuses it but does not take ownership. If an unknown,
@@ -191,6 +197,8 @@ The health endpoint contains only a fixed service marker, health schema,
 TaskChef version, dashboard-server version, and canonical workspace. It exposes
 no task data, credentials, environment variables, process control, or secrets.
 
+![Immutable event-time dashboard notifications](docs/images/notification-event-snapshots.jpg)
+
 ![Task detail result history](docs/images/result-history-dashboard.jpg)
 
 ## Common recovery

package/docs/spec.md

@@ -327,6 +327,34 @@ current configuration before use.
 Snapshot and SSE list payloads MUST omit full `results` history and include the
 derived latest-result projection. The bounded per-task detail endpoint MAY
 return the full validated task so the dialog can render history newest first.
+Dashboard notifications MUST capture an immutable event-time projection of the
+task title, lifecycle state and event, turn ID when present, event timestamp,
+and relevant concise summary. Rendering MUST NOT resolve historical notice text
+from the task's later current state. Notice identity and deduplication MUST use
+task ID, turn ID, and lifecycle event; a creation notice without a turn ID MUST
+fall back to task ID plus the immutable creation timestamp. Dashboard revision
+MUST NOT be the sole identity. Identical snapshots, SSE reconnects, idempotent
+reports, schema normalization, and non-semantic rewrites MUST NOT add notices.
+Distinct working and semantic-result events for one turn MAY each be retained.
+When one compact snapshot first exposes both a latest semantic result and a
+newer working turn, the browser MUST reconcile both events. Temporary task
+absence MUST NOT discard the prior semantic signature or turn a later
+reappearance into another creation event. The first page snapshot MUST establish
+a quiet baseline rather than replay existing history. After that baseline, a
+new task first observed with a turn or semantic result MUST retain its creation
+event and each lifecycle event observable in that compact projection.
+
+Working with no prior result SHOULD be labeled as a task start. Working on a
+newer turn while a prior result remains projected SHOULD be labeled as a
+follow-up start. Creation, completion, input-needed, and failure labels MUST be
+distinct. The Updates panel MUST remain bounded and support individual dismiss
+and clear-all without resetting replay protection. A retained notice whose task
+is absent from the current list MUST remain readable; selecting it MUST NOT
+navigate or mutate data and SHOULD explain that current details are unavailable.
+The retained notice list MUST NOT be a live region that re-announces old notices
+when it rerenders. A separate polite status region MUST announce only newly
+reconciled events. Each notice control's accessible description MUST include
+its displayed summary when present, event time, and missing-task state.
 
 ## Task-log migration
 

package/docs/workflows.md

@@ -284,6 +284,28 @@ unnecessary history. A read-only per-task endpoint returns full history only
 when the dialog opens. Historical project paths are untrusted until matched
 against current configuration.
 
+The browser derives one immutable Updates-panel snapshot when it first observes
+a semantic lifecycle transition. The snapshot keeps its event-time title,
+state/event, turn ID, timestamp, and relevant summary. Its identity combines
+task ID, turn ID, and event, with creation time as the fallback when creation
+has no turn. A separate seen-identity set outlives the bounded visible notices,
+individual dismissals, and Clear all, preventing replay after reconnect,
+normalization, or disappearance and reappearance. Per-task semantic signatures
+also remain as tombstones while a task is absent. When one compact snapshot
+first reveals a latest semantic result plus a newer working turn, the browser
+captures both. The first page snapshot is a quiet baseline so opening or
+refreshing the dashboard does not replay existing history. If a task is first
+observed in a progressed state after that baseline, creation is retained
+alongside the observable result and working events. The current task list is
+used only as the navigation target: if the task is gone, the notice stays
+readable and selection reports that current details are unavailable.
+
+The retained toast list is not live. Reconciliation passes only its newly added
+snapshots to a separate polite status region, so reconnect, dismissal, Clear
+all, and ordinary rerendering do not re-announce retained history. Toast action
+labels remain concise while `aria-describedby` connects the visible summary,
+event time, and missing-task explanation for assistive technology.
+
 ## Schema 4/5 migration
 
 `taskchef workspace migrate` acquires the same workspace lock as lifecycle

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.6.0",
+  "version": "7.7.0",
   "description": "A non-blocking interactive dispatcher for visible Codex tasks.",
   "license": "MIT",
   "author": "Favo Yang",
@@ -26,6 +26,7 @@
     "docs/spec.md",
     "docs/workflows.md",
     "docs/firstmate-taskchef-comparison.md",
+    "docs/images/notification-event-snapshots.jpg",
     "docs/images/result-history-dashboard.jpg",
     "index.js",
     "mcp",

package/src/dashboard/app.js

@@ -1,19 +1,24 @@
 import {
+  clearNotifications,
+  dismissNotification,
   findCurrentTask,
   KNOWN_TASK_STATUSES,
   nextDateFilterRefreshDelay,
+  notificationDismissLabel,
+  notificationOpenLabel,
   notificationTitle,
   reconcileNotifications,
   taskStatusLabel,
   taskWithinDateFilter,
 } from "./state.js";
 import { openTaskFromControl } from "./actions.js";
-import { RelativeTimeController, parsedTimestamp } from "./time.js";
+import { formatRelativeTime, RelativeTimeController, parsedTimestamp } from "./time.js";
 
 const state = {
   tasks: [],
   signatures: new Map(),
   notifications: [],
+  seenNotificationIds: new Set(),
   initialized: false,
   selectedTask: null,
 };
@@ -39,6 +44,7 @@ const elements = {
   dismissDashboardMessage: document.querySelector("#dismiss-dashboard-message"),
   emptyState: document.querySelector("#empty-state"),
   notifications: document.querySelector("#notifications"),
+  notificationAnnouncer: document.querySelector("#notification-announcer"),
   openProject: document.querySelector("#open-codex"),
   projectFilter: document.querySelector("#project-filter"),
   statusFilter: document.querySelector("#status-filter"),
@@ -46,6 +52,7 @@ const elements = {
   taskList: document.querySelector("#task-list"),
   toastList: document.querySelector("#toast-list"),
 };
+let notificationDescriptionSerial = 0;
 
 function timestampControl(value, { accessibleName, key, prefix = "" }) {
   if (!parsedTimestamp(value)) {
@@ -108,17 +115,37 @@ function replaceOptions(select, values, allLabel) {
 
 function notificationToast(notification) {
   const task = findCurrentTask(state.tasks, notification.taskId);
-  if (!task) return null;
   const toast = document.createElement("div");
-  toast.className = "toast";
+  toast.className = `toast${task ? "" : " toast-missing"}`;
   const text = document.createElement("button");
   text.type = "button";
   text.className = "toast-content";
+  text.setAttribute("aria-label", notificationOpenLabel(notification, Boolean(task)));
+  const describedBy = [];
   const title = document.createElement("strong");
-  title.textContent = notificationTitle(task, notification.kind);
+  title.textContent = notificationTitle(notification);
   const description = document.createElement("span");
-  description.textContent = `${task.title} · ${taskStatusLabel(task)}`;
+  description.textContent = notification.title;
   text.append(title, description);
+  if (notification.summary) {
+    const summary = document.createElement("span");
+    summary.className = "toast-summary preserve-lines";
+    summary.id = `notification-description-${notificationDescriptionSerial += 1}`;
+    summary.textContent = notification.summary;
+    text.append(summary);
+    describedBy.push(summary.id);
+  }
+  const metadata = document.createElement("span");
+  metadata.className = "toast-metadata";
+  metadata.id = `notification-description-${notificationDescriptionSerial += 1}`;
+  const timestamp = document.createElement("time");
+  timestamp.dateTime = notification.timestamp ?? "";
+  timestamp.textContent = formatRelativeTime(notification.timestamp);
+  metadata.append(timestamp);
+  if (!task) metadata.append(" · Task no longer available");
+  text.append(metadata);
+  describedBy.push(metadata.id);
+  text.setAttribute("aria-describedby", describedBy.join(" "));
   text.addEventListener("click", () => {
     const current = findCurrentTask(state.tasks, notification.taskId);
     if (current) openDialog(current);
@@ -127,21 +154,37 @@ function notificationToast(notification) {
   const dismiss = document.createElement("button");
   dismiss.type = "button";
   dismiss.className = "icon-button";
-  dismiss.setAttribute("aria-label", `Dismiss notification for ${task.title}`);
+  dismiss.setAttribute("aria-label", notificationDismissLabel(notification));
+  dismiss.setAttribute("aria-describedby", describedBy.join(" "));
   dismiss.textContent = "×";
   dismiss.addEventListener("click", () => {
-    state.notifications = state.notifications.filter(({ id }) => id !== notification.id);
+    state.notifications = dismissNotification(state.notifications, notification.id);
     renderNotifications();
   });
   toast.append(text, dismiss);
   return toast;
 }
 
-function renderNotifications() {
+function notificationAnnouncement(notification) {
+  return [
+    notificationTitle(notification),
+    notification.title,
+    notification.summary,
+    notification.turnId ? `Turn ${notification.turnId}` : null,
+    formatRelativeTime(notification.timestamp),
+  ].filter(Boolean).join(". ");
+}
+
+function renderNotifications(additions = []) {
   elements.toastList.replaceChildren(
-    ...state.notifications.map(notificationToast).filter(Boolean),
+    ...state.notifications.map(notificationToast),
   );
   elements.notifications.hidden = state.notifications.length === 0;
+  if (additions.length > 0) {
+    elements.notificationAnnouncer.textContent = additions
+      .map(notificationAnnouncement)
+      .join(". ");
+  }
 }
 
 function detailRow(term, value) {
@@ -311,11 +354,13 @@ function applySnapshot(snapshot) {
   const reconciled = reconcileNotifications({
     initialized: state.initialized,
     notifications: state.notifications,
+    seenIds: state.seenNotificationIds,
     signatures: state.signatures,
-  }, snapshot.tasks, snapshot.revision);
+  }, snapshot.tasks);
   state.tasks = snapshot.tasks;
   state.signatures = reconciled.signatures;
   state.notifications = reconciled.notifications;
+  state.seenNotificationIds = reconciled.seenIds;
   state.initialized = true;
   if (snapshot.healthy === false) {
     showMessage("The task log is temporarily unavailable. Showing the last valid snapshot.");
@@ -336,7 +381,7 @@ function applySnapshot(snapshot) {
     const updated = state.tasks.find((task) => task.id === state.selectedTask.id);
     if (updated && elements.dialog.open) openDialog(updated);
   }
-  renderNotifications();
+  renderNotifications(reconciled.additions);
   render();
 }
 
@@ -363,7 +408,7 @@ elements.dismissDashboardMessage.addEventListener("click", () => {
   elements.dashboardMessage.hidden = true;
 });
 elements.clearNotifications.addEventListener("click", () => {
-  state.notifications = [];
+  state.notifications = clearNotifications();
   renderNotifications();
 });
 elements.closeDialog.addEventListener("click", () => elements.dialog.close());

package/src/dashboard/index.html

@@ -71,7 +71,8 @@
         <strong>Updates</strong>
         <button id="clear-notifications" class="text-button" type="button">Clear all</button>
       </div>
-      <div id="toast-list" class="toast-list" aria-live="polite"></div>
+      <p id="notification-announcer" class="visually-hidden" role="status" aria-live="polite"></p>
+      <div id="toast-list" class="toast-list"></div>
     </aside>
 
     <dialog id="task-dialog" aria-labelledby="dialog-title">

package/src/dashboard/state.js

@@ -7,6 +7,16 @@ export const KNOWN_TASK_STATUSES = [
   "unresolved",
 ];
 
+const NOTIFICATION_TITLES = new Map([
+  ["created", "Task created"],
+  ["task_started", "Task started"],
+  ["follow_up_started", "Follow-up started"],
+  ["completed", "Task completed"],
+  ["needs_input", "Task needs input"],
+  ["failed", "Task failed"],
+  ["unresolved", "Task updated"],
+]);
+
 const DATE_WINDOWS_MS = new Map([
   ["24h", 24 * 60 * 60 * 1_000],
   ["7d", 7 * 24 * 60 * 60 * 1_000],
@@ -21,8 +31,8 @@ export function taskStatusLabel(task) {
   return task.status === null ? "unresolved" : task.status.replaceAll("_", " ");
 }
 
-export function notificationTitle(task, kind) {
-  return kind === "new" ? "New task" : `Task ${taskStatusLabel(task)}`;
+export function notificationTitle(notification) {
+  return NOTIFICATION_TITLES.get(notification.event) ?? "Task updated";
 }
 
 export function taskWithinDateFilter(task, filter, now = Date.now()) {
@@ -44,41 +54,143 @@ export function nextDateFilterRefreshDelay(tasks, filter, now = Date.now()) {
 }
 
 export function taskSignature(task) {
-  return JSON.stringify([
-    task.threadId,
-    task.status,
-    task.summary,
-    task.turnId,
-    task.updatedAt,
-    task.updatedBy,
-    task.lastResult,
-  ]);
+  return JSON.stringify([task.id, task.turnId ?? null, task.status ?? "unresolved"]);
 }
 
 export function findCurrentTask(tasks, taskId) {
   return tasks.find((task) => task.id === taskId) ?? null;
 }
 
+function lifecycleEvent(task) {
+  if (task.status === "working") {
+    return task.lastResult ? "follow_up_started" : "task_started";
+  }
+  return task.status ?? "unresolved";
+}
+
+function notificationIdentity(task, event) {
+  if (event === "created") {
+    return JSON.stringify([task.id, null, event, task.createdAt ?? null]);
+  }
+  return JSON.stringify([task.id, task.turnId ?? null, event]);
+}
+
+function eventTimestamp(task, event) {
+  if (event === "created") return task.createdAt ?? task.updatedAt ?? null;
+  if (
+    task.lastResult?.status === task.status
+    && task.lastResult?.turnId === task.turnId
+  ) {
+    return task.lastResult.updatedAt;
+  }
+  return task.updatedAt ?? task.createdAt ?? null;
+}
+
+function eventSummary(task, event) {
+  if (!["completed", "needs_input", "failed"].includes(event)) return null;
+  if (
+    task.lastResult?.status === task.status
+    && task.lastResult?.turnId === task.turnId
+  ) {
+    return task.lastResult.summary;
+  }
+  return task.summary ?? null;
+}
+
+export function notificationSnapshot(task, event = lifecycleEvent(task)) {
+  const created = event === "created";
+  return Object.freeze({
+    id: notificationIdentity(task, event),
+    taskId: task.id,
+    title: task.title,
+    status: created ? "working" : task.status,
+    event,
+    turnId: created ? null : task.turnId ?? null,
+    timestamp: eventTimestamp(task, event),
+    summary: eventSummary(task, event),
+  });
+}
+
+function resultNotificationSnapshot(task) {
+  const result = task.lastResult;
+  if (!result) return null;
+  return Object.freeze({
+    id: notificationIdentity({ ...task, turnId: result.turnId }, result.status),
+    taskId: task.id,
+    title: task.title,
+    status: result.status,
+    event: result.status,
+    turnId: result.turnId ?? null,
+    timestamp: result.updatedAt,
+    summary: result.summary,
+  });
+}
+
+export function notificationOpenLabel(notification, available) {
+  const action = available ? "Open current task details" : "Show task availability";
+  return `${action} for ${notification.title}: ${notificationTitle(notification)}`;
+}
+
+export function notificationDismissLabel(notification) {
+  return `Dismiss ${notificationTitle(notification)} notification for ${notification.title}`;
+}
+
+export function dismissNotification(notifications, notificationId) {
+  return notifications.filter(({ id }) => id !== notificationId);
+}
+
+export function clearNotifications() {
+  return [];
+}
+
 export function reconcileNotifications(
-  { initialized, notifications, signatures },
+  { initialized, notifications, seenIds = new Set(), signatures },
   tasks,
-  revision,
 ) {
-  const nextSignatures = new Map(tasks.map((task) => [task.id, taskSignature(task)]));
-  if (!initialized) return { notifications, signatures: nextSignatures };
+  const nextSignatures = new Map(signatures);
+  for (const task of tasks) nextSignatures.set(task.id, taskSignature(task));
+  const nextSeenIds = new Set(seenIds);
+  if (!initialized) {
+    for (const task of tasks) {
+      nextSeenIds.add(notificationSnapshot(task, "created").id);
+      const resultNotification = resultNotificationSnapshot(task);
+      if (resultNotification) nextSeenIds.add(resultNotification.id);
+      nextSeenIds.add(notificationSnapshot(task).id);
+    }
+    return {
+      additions: [],
+      notifications,
+      seenIds: nextSeenIds,
+      signatures: nextSignatures,
+    };
+  }
   const additions = [];
   for (const task of tasks) {
-    let kind = null;
-    if (!signatures.has(task.id)) kind = "new";
-    else if (signatures.get(task.id) !== nextSignatures.get(task.id)) kind = "changed";
-    if (kind) additions.push({
-      id: `${revision}:${task.id}`,
-      kind,
-      taskId: task.id,
-    });
+    const candidates = [];
+    if (!signatures.has(task.id)) {
+      const resultNotification = resultNotificationSnapshot(task);
+      if (task.turnId || task.status !== "working" || resultNotification) {
+        candidates.push(notificationSnapshot(task));
+        if (resultNotification) candidates.push(resultNotification);
+      }
+      candidates.push(notificationSnapshot(task, "created"));
+    } else if (signatures.get(task.id) !== nextSignatures.get(task.id)) {
+      candidates.push(notificationSnapshot(task));
+      const resultNotification = resultNotificationSnapshot(task);
+      if (resultNotification) candidates.push(resultNotification);
+    }
+    for (const notification of candidates) {
+      if (!nextSeenIds.has(notification.id)) additions.push(notification);
+      nextSeenIds.add(notification.id);
+    }
+    const resultNotification = resultNotificationSnapshot(task);
+    if (resultNotification) nextSeenIds.add(resultNotification.id);
+    nextSeenIds.add(notificationSnapshot(task).id);
   }
   return {
+    additions,
     notifications: [...additions, ...notifications].slice(0, MAX_NOTIFICATIONS),
+    seenIds: nextSeenIds,
     signatures: nextSignatures,
   };
 }

package/src/dashboard/styles.css

@@ -105,6 +105,9 @@ time, .timestamp-missing { font-size: 0.78rem; }
 .toast { display: flex; align-items: flex-start; gap: 8px; padding: 10px; border-radius: 7px; background: var(--surface-muted); }
 .toast-content { display: grid; flex: 1; gap: 2px; padding: 0; border: 0; background: none; text-align: left; cursor: pointer; }
 .toast-content span { color: var(--muted); font-size: 0.85rem; }
+.toast-content .toast-summary { color: var(--text); }
+.toast-content .toast-metadata { font-size: 0.75rem; }
+.toast-missing { border: 1px dashed var(--border); }
 
 .text-button, .icon-button { border: 0; background: none; cursor: pointer; }
 .text-button { color: var(--accent); font-size: 0.82rem; font-weight: 700; }