taskchef 7.20.0 → 7.21.1

package/src/dashboard/app.js

@@ -1,22 +1,34 @@
 import {
   canArchiveTask,
+  canManuallyTransitionTask,
   clearNotifications,
   dismissNotification,
   filterTasks,
   findCurrentTask,
   latestTurnPresentation,
+  manualTransitionExpectedState,
   mergeProjectedTurns,
   nextDateFilterRefreshDelay,
   notificationDismissLabel,
   notificationOpenLabel,
   notificationTitle,
   reconcileNotifications,
+  reconcileManualTransition,
+  reconcileManualTransitionResponse,
   statusFilterCounts,
   statusFilterText,
   taskStatusLabel,
+  taskMatchesManualTransitionExpected,
   turnPresentation,
 } from "./state.js";
-import { archiveTaskFromControl, openTaskFromControl } from "./actions.js";
+import {
+  archiveTaskFromControl,
+  focusManualTransitionStatus,
+  handleManualTransitionEscape,
+  manuallyTransitionTaskFromControl,
+  openTaskFromControl,
+  restoreTaskActionMenuFocus,
+} from "./actions.js";
 import {
   githubReferenceAccessibleLabel,
   githubReferenceDisplayLabels,
@@ -29,12 +41,14 @@ const USAGE_POLL_INTERVAL_MS = 1_500;
 const MAX_USAGE_POLL_ATTEMPTS = 40;
 
 const state = {
+  archivePendingThreadIds: new Set(),
   archivedThreadIds: new Set(),
   tasks: [],
   signatures: new Map(),
   notifications: [],
   seenNotificationIds: new Set(),
   initialized: false,
+  manualTransition: null,
   selectedTask: null,
 };
 let dateRefreshTimer = null;
@@ -65,6 +79,12 @@ const elements = {
   emptyState: document.querySelector("#empty-state"),
   notifications: document.querySelector("#notifications"),
   notificationAnnouncer: document.querySelector("#notification-announcer"),
+  manualTransitionPanel: document.querySelector("#manual-transition-panel"),
+  manualTransitionError: document.querySelector("#manual-transition-error"),
+  manualTransitionStatus: document.querySelector("#manual-transition-status"),
+  markTaskCompleted: document.querySelector("#mark-task-completed"),
+  markTaskFailed: document.querySelector("#mark-task-failed"),
+  moreTaskActions: document.querySelector("#more-task-actions"),
   openProject: document.querySelector("#open-codex"),
   projectFilter: document.querySelector("#project-filter"),
   statusFilter: document.querySelector("#status-filter"),
@@ -426,6 +446,12 @@ function turnTimeline(task) {
       key: `detail:${task.id}:turn:${turnKey}`,
     });
     header.append(status, timestamp);
+    if (presentation.sourceLabel) {
+      const source = document.createElement("span");
+      source.className = "result-history-source";
+      source.textContent = presentation.sourceLabel;
+      header.insertBefore(source, timestamp);
+    }
     const requestLabel = document.createElement("h4");
     requestLabel.textContent = "Request";
     const request = document.createElement("p");
@@ -461,6 +487,139 @@ function turnTimeline(task) {
   });
 }
 
+function manualTransitionPending() {
+  return state.manualTransition?.stage === "pending";
+}
+
+function resetManualTransition({ focus = false } = {}) {
+  state.manualTransition = null;
+  elements.closeDialog.disabled = false;
+  if (state.selectedTask) renderManualTransition(state.selectedTask);
+  if (focus) elements.moreTaskActions.focus();
+}
+
+function replaceCurrentTask(task) {
+  state.tasks = state.tasks.map((candidate) => candidate.id === task.id ? task : candidate);
+  state.selectedTask = task;
+}
+
+function renderManualTransition(task) {
+  const activeElement = document.activeElement;
+  const focusWasInPanel = elements.manualTransitionPanel.contains?.(activeElement) ?? false;
+  const eligible = canManuallyTransitionTask(task);
+  state.manualTransition = reconcileManualTransition(state.manualTransition, task);
+  const pending = manualTransitionPending();
+  const expanded = Boolean(state.manualTransition);
+  elements.moreTaskActions.disabled = pending;
+  elements.moreTaskActions.textContent = expanded ? "←" : "…";
+  elements.moreTaskActions.setAttribute(
+    "aria-label",
+    expanded ? "Hide more task actions" : "More task actions",
+  );
+  elements.moreTaskActions.setAttribute("title", expanded ? "Hide more task actions" : "More task actions");
+  elements.moreTaskActions.setAttribute("aria-expanded", String(expanded));
+  elements.closeDialog.disabled = pending;
+  elements.manualTransitionPanel.hidden = state.manualTransition === null;
+  elements.manualTransitionPanel.setAttribute("aria-busy", String(pending));
+  elements.copyTaskId.disabled = pending || !task.id;
+  elements.markTaskCompleted.hidden = !eligible;
+  elements.markTaskFailed.hidden = !eligible;
+  elements.markTaskCompleted.disabled = pending;
+  elements.markTaskFailed.disabled = pending;
+  const archivePending = state.archivePendingThreadIds.has(task.threadId);
+  const archived = state.archivedThreadIds.has(task.threadId);
+  elements.archiveTask.disabled = pending || archivePending || archived;
+  elements.archiveTask.textContent = archived ? "Archived" : archivePending ? "Archiving…" : "Archive chat";
+  elements.archiveTask.setAttribute(
+    "aria-label",
+    archived
+      ? `${task.title} is archived in Codex`
+      : archivePending
+        ? `Archiving ${task.title} in Codex`
+        : `Archive ${task.title} in Codex`,
+  );
+  elements.manualTransitionStatus.hidden = !pending;
+  elements.manualTransitionStatus.textContent = pending ? "Saving task state…" : "";
+  const error = state.manualTransition?.error ?? "";
+  elements.manualTransitionError.hidden = !error;
+  elements.manualTransitionError.textContent = error;
+  if (!state.manualTransition) {
+    elements.closeDialog.disabled = false;
+    if (focusWasInPanel) elements.moreTaskActions.focus();
+    return;
+  }
+  if (pending) {
+    focusManualTransitionStatus(elements.manualTransitionPanel);
+  } else {
+    restoreTaskActionMenuFocus(
+      elements.manualTransitionPanel,
+      activeElement,
+      elements.moreTaskActions,
+    );
+  }
+}
+
+async function submitManualTransition(targetStatus, event) {
+  const task = state.selectedTask;
+  if (!task || !canManuallyTransitionTask(task) || manualTransitionPending()) return;
+  const previous = state.manualTransition;
+  const actionId = previous?.targetStatus === targetStatus && previous.actionId
+    ? previous.actionId
+    : crypto.randomUUID();
+  const attempt = {
+    ...previous,
+    taskId: task.id,
+    stage: "pending",
+    targetStatus,
+    actionId,
+    expected: previous?.expected ?? manualTransitionExpectedState(task),
+    error: null,
+  };
+  state.manualTransition = attempt;
+  renderManualTransition(task);
+  const result = await manuallyTransitionTaskFromControl(
+    event,
+    { ...task, ...attempt.expected },
+    targetStatus,
+    attempt.actionId,
+  );
+  const current = reconcileManualTransitionResponse({
+    requestTask: task,
+    expected: attempt.expected,
+    responseTask: result.task,
+    selectedTask: state.selectedTask,
+  });
+  if (result.ok) {
+    state.manualTransition = null;
+    if (current === result.task) replaceCurrentTask(result.task);
+    renderDialog(current);
+    render();
+    showMessage(result.task.summary);
+    elements.dialogTitle.focus?.();
+    return;
+  }
+  if (current === result.task) replaceCurrentTask(result.task);
+  if (
+    !canManuallyTransitionTask(current)
+    || !taskMatchesManualTransitionExpected(current, attempt.expected)
+  ) {
+    state.manualTransition = null;
+    renderDialog(current);
+    render();
+    showMessage("This task changed. Review its current state before trying again.");
+    elements.dialogTitle.focus?.();
+    return;
+  }
+  state.manualTransition = {
+    ...attempt,
+    stage: "choose",
+    error: result.message,
+    actionId: result.code === "stale_task" ? crypto.randomUUID() : attempt.actionId,
+  };
+  renderDialog(current);
+  elements.manualTransitionError.focus();
+}
+
 function renderDialog(task) {
   if (state.selectedTask?.id !== task.id) {
     copyTaskIdGeneration += 1;
@@ -526,13 +685,15 @@ function renderDialog(task) {
   configureOpenTaskControl(elements.openProject, `Open ${task.title} in Codex`);
   const canArchive = canArchiveTask(task);
   const archived = state.archivedThreadIds.has(task.threadId);
+  const archivePending = state.archivePendingThreadIds.has(task.threadId);
   elements.archiveTask.hidden = !canArchive;
-  elements.archiveTask.disabled = archived;
-  elements.archiveTask.textContent = archived ? "Archived" : "Archive chat";
+  elements.archiveTask.disabled = archived || archivePending;
+  elements.archiveTask.textContent = archived ? "Archived" : archivePending ? "Archiving…" : "Archive chat";
   elements.archiveTask.setAttribute(
     "aria-label",
     archived ? `${task.title} is archived in Codex` : `Archive ${task.title} in Codex`,
   );
+  renderManualTransition(detailedTask);
 }
 
 async function openDialog(task) {
@@ -715,9 +876,47 @@ elements.clearNotifications.addEventListener("click", () => {
   state.notifications = clearNotifications();
   renderNotifications();
 });
-elements.closeDialog.addEventListener("click", () => elements.dialog.close());
+elements.closeDialog.addEventListener("click", () => {
+  if (!manualTransitionPending()) elements.dialog.close();
+});
 elements.dialog.addEventListener("click", (event) => {
-  if (event.target === elements.dialog) elements.dialog.close();
+  if (event.target === elements.dialog && !manualTransitionPending()) elements.dialog.close();
+});
+elements.dialog.addEventListener("keydown", (event) => {
+  handleManualTransitionEscape(event, {
+    active: Boolean(state.manualTransition),
+    pending: manualTransitionPending(),
+    cancel: () => resetManualTransition({ focus: true }),
+  });
+});
+elements.dialog.addEventListener("cancel", (event) => {
+  if (!state.manualTransition) return;
+  event.preventDefault();
+  if (!manualTransitionPending()) resetManualTransition({ focus: true });
+});
+elements.dialog.addEventListener("close", () => {
+  if (!manualTransitionPending()) state.manualTransition = null;
+});
+elements.moreTaskActions.addEventListener("click", () => {
+  const task = state.selectedTask;
+  if (!task || manualTransitionPending()) return;
+  if (state.manualTransition) {
+    resetManualTransition({ focus: true });
+    return;
+  }
+  state.manualTransition = {
+    taskId: task.id,
+    stage: "choose",
+    expected: manualTransitionExpectedState(task),
+  };
+  renderManualTransition(task);
+  elements.copyTaskId.focus();
+});
+elements.markTaskCompleted.addEventListener("click", (event) => {
+  return submitManualTransition("completed", event);
+});
+elements.markTaskFailed.addEventListener("click", (event) => {
+  return submitManualTransition("failed", event);
 });
 elements.copyTaskId.addEventListener("click", async () => {
   const taskId = state.selectedTask?.id;
@@ -747,12 +946,20 @@ elements.openProject.addEventListener("click", async (event) => {
 });
 elements.archiveTask.addEventListener("click", async (event) => {
   const task = state.selectedTask;
-  if (!task || !canArchiveTask(task)) return;
-  await archiveTaskFromControl(event, task, {
-    onArchived: (threadId) => {
-      state.archivedThreadIds.add(threadId);
-      if (state.selectedTask?.id === task.id) renderDialog(state.selectedTask);
-    },
-    showMessage,
-  });
+  if (
+    !task
+    || !canArchiveTask(task)
+    || state.archivePendingThreadIds.has(task.threadId)
+  ) return;
+  state.archivePendingThreadIds.add(task.threadId);
+  renderManualTransition(task);
+  try {
+    await archiveTaskFromControl(event, task, {
+      onArchived: (threadId) => state.archivedThreadIds.add(threadId),
+      showMessage,
+    });
+  } finally {
+    state.archivePendingThreadIds.delete(task.threadId);
+    if (state.selectedTask?.id === task.id) renderDialog(state.selectedTask);
+  }
 });

package/src/dashboard/index.html

@@ -100,11 +100,11 @@
       <div class="dialog-header">
         <div>
           <p id="dialog-project" class="eyebrow"></p>
-          <h2 id="dialog-title"></h2>
+          <h2 id="dialog-title" tabindex="-1"></h2>
         </div>
         <button id="close-dialog" class="icon-button" type="button" aria-label="Close task details">×</button>
       </div>
-      <div class="dialog-actions">
+      <div class="dialog-actions" role="group" aria-label="Task actions">
         <button id="open-codex" class="primary-button task-action" type="button" aria-label="Open this task in Codex">
           <picture class="codex-icon" aria-hidden="true">
             <source srcset="/assets/codex-app-dark.png" media="(prefers-color-scheme: dark)">
@@ -112,8 +112,17 @@
           </picture>
           <span>Open task</span>
         </button>
-        <button id="copy-task-id" class="secondary-button" type="button" aria-label="Copy Task ID">Copy Task ID</button>
-        <button id="archive-codex" class="danger-button" type="button" aria-label="Archive this chat in Codex" hidden>Archive chat</button>
+        <button id="more-task-actions" class="secondary-button more-task-actions" type="button" aria-label="More task actions" aria-expanded="false" aria-controls="manual-transition-panel">…</button>
+        <div id="manual-transition-panel" class="manual-transition-panel" aria-busy="false" hidden>
+          <div class="manual-transition-controls">
+            <button id="copy-task-id" class="secondary-button" type="button" aria-label="Copy Task ID" data-manual-focus="copy">Copy Task ID</button>
+            <button id="mark-task-completed" class="secondary-button" type="button" data-manual-focus="target-completed">Mark completed</button>
+            <button id="mark-task-failed" class="danger-button" type="button" data-manual-focus="target-failed">Mark failed</button>
+            <button id="archive-codex" class="danger-button" type="button" aria-label="Archive this chat in Codex" hidden>Archive chat</button>
+          </div>
+          <p id="manual-transition-status" class="manual-transition-pending" role="status" aria-live="polite" tabindex="-1" data-manual-focus="pending" hidden></p>
+          <p id="manual-transition-error" class="manual-transition-error" role="alert" tabindex="-1" data-manual-focus="error" hidden></p>
+        </div>
       </div>
       <nav id="dialog-related-links" class="github-links" aria-label="Related GitHub links" hidden></nav>
       <section>

package/src/dashboard/state.js

@@ -22,6 +22,8 @@ const NOTIFICATION_TITLES = new Map([
   ["completed", "Task completed"],
   ["needs_input", "Task needs input"],
   ["failed", "Task failed"],
+  ["manual_completed", "Task manually completed"],
+  ["manual_failed", "Task manually failed"],
   ["unresolved", "Task updated"],
 ]);
 
@@ -45,6 +47,50 @@ export function canArchiveTask(task) {
     && CODEX_THREAD_ID_PATTERN.test(task.threadId);
 }
 
+export function canManuallyTransitionTask(task) {
+  return ["working", "needs_input"].includes(task.status);
+}
+
+export function manualTransitionExpectedState(task) {
+  return {
+    status: task.status,
+    turnRef: task.turnRef,
+    threadId: task.threadId,
+    updatedAt: task.updatedAt,
+  };
+}
+
+export function taskMatchesManualTransitionExpected(task, expected) {
+  return Boolean(expected)
+    && task.status === expected.status
+    && task.turnRef === expected.turnRef
+    && task.threadId === expected.threadId
+    && task.updatedAt === expected.updatedAt;
+}
+
+export function reconcileManualTransition(transition, task) {
+  if (!transition || transition.taskId !== task.id) return null;
+  if (transition.stage === "pending") return transition;
+  if (taskMatchesManualTransitionExpected(task, transition.expected)) return transition;
+  return {
+    taskId: task.id,
+    stage: "choose",
+    expected: manualTransitionExpectedState(task),
+  };
+}
+
+export function reconcileManualTransitionResponse({
+  requestTask,
+  expected,
+  responseTask,
+  selectedTask,
+}) {
+  const current = selectedTask?.id === requestTask.id ? selectedTask : requestTask;
+  return taskMatchesManualTransitionExpected(current, expected)
+    ? (responseTask ?? current)
+    : current;
+}
+
 export function latestTurnPresentation(task) {
   const turn = task.latestTurn ?? null;
   const result = turn?.result ?? null;
@@ -70,6 +116,9 @@ export function turnPresentation(turn) {
     status: result?.status ?? "working",
     summary: result?.summary ?? "In progress",
     updatedAt: result?.updatedAt ?? turn.startedAt,
+    ...(turn.provenance?.kind === "dashboard_manual"
+      ? { sourceLabel: "Manual dashboard change" }
+      : {}),
   };
 }
 
@@ -200,6 +249,9 @@ function lifecycleEvent(task) {
   if (task.status === "working") {
     return task.lastResult ? "follow_up_started" : "task_started";
   }
+  if (task.latestTurn?.provenance?.kind === "dashboard_manual") {
+    return `manual_${task.status}`;
+  }
   return task.status ?? "unresolved";
 }
 
@@ -223,7 +275,9 @@ function eventTimestamp(task, event) {
 }
 
 function eventSummary(task, event) {
-  if (!["completed", "needs_input", "failed"].includes(event)) return null;
+  if (!["completed", "needs_input", "failed", "manual_completed", "manual_failed"].includes(event)) {
+    return null;
+  }
   if (
     task.lastResult?.status === task.status
     && (task.lastResult?.turnRef ?? task.lastResult?.turnId)
@@ -252,16 +306,19 @@ export function notificationSnapshot(task, event = lifecycleEvent(task)) {
 function resultNotificationSnapshot(task) {
   const result = task.lastResult;
   if (!result) return null;
+  const event = result.provenance?.kind === "dashboard_manual"
+    ? `manual_${result.status}`
+    : result.status;
   return Object.freeze({
     id: notificationIdentity({
       ...task,
       turnRef: result.turnRef ?? result.turnId,
       turnId: result.turnId,
-    }, result.status),
+    }, event),
     taskId: task.id,
     title: task.title,
     status: result.status,
-    event: result.status,
+    event,
     turnRef: result.turnRef ?? result.turnId ?? null,
     turnId: result.turnId ?? null,
     timestamp: result.updatedAt,

package/src/dashboard/styles.css

@@ -11,6 +11,10 @@
   --danger: #8b3a35;
   --warning: #8a5c17;
   --shadow: 0 12px 30px rgb(24 33 29 / 10%);
+  --control-height: 38px;
+  --control-padding-inline: 11px;
+  --control-radius: 7px;
+  --control-font-size: 0.86rem;
   font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
 }
 
@@ -112,7 +116,7 @@ time, .timestamp-missing { font-size: 0.75rem; }
 .timestamp-toggle:hover time { color: var(--text); text-decoration: underline; text-underline-offset: 3px; }
 .task-footer { display: flex; align-items: center; justify-content: space-between; gap: 14px; }
 .task-open { flex: none; }
-.primary-button.task-action, .secondary-button.task-action { display: inline-flex; align-items: center; justify-content: center; gap: 6px; min-height: 34px; padding: 5px 9px; font-size: 0.78rem; line-height: 1.2; white-space: nowrap; }
+.primary-button.task-action, .secondary-button.task-action { display: inline-flex; align-items: center; justify-content: center; gap: 6px; min-height: var(--control-height); padding: 0 var(--control-padding-inline); font-size: var(--control-font-size); line-height: 1; white-space: nowrap; }
 .codex-icon { display: block; flex: none; width: 18px; height: 18px; }
 .codex-icon img { display: block; width: 100%; height: 100%; object-fit: contain; }
 
@@ -148,8 +152,15 @@ dialog { width: min(760px, calc(100vw - 32px)); max-height: min(82vh, 900px); pa
 dialog::backdrop { background: rgb(18 23 21 / 50%); backdrop-filter: blur(2px); }
 .dialog-header { display: flex; align-items: flex-start; justify-content: space-between; gap: 20px; }
 .dialog-header h2 { margin-bottom: 12px; font-size: 1.6rem; }
-.dialog-actions { display: flex; gap: 8px; margin-bottom: 26px; }
-.primary-button, .secondary-button, .danger-button { padding: 8px 12px; border-radius: 7px; font-weight: 700; cursor: pointer; }
+.dialog-actions { display: flex; align-items: flex-start; flex-wrap: wrap; gap: 8px; margin-bottom: 26px; }
+.more-task-actions { width: var(--control-height); min-width: var(--control-height); padding-inline: 0; font-size: 1.2rem; line-height: 1; }
+.manual-transition-panel, .manual-transition-controls { display: contents; }
+.manual-transition-panel[hidden] { display: none; }
+.manual-transition-error, .manual-transition-pending { flex-basis: 100%; margin: 0; }
+.manual-transition-controls > button[hidden] { display: none; }
+.manual-transition-error { color: var(--danger); font-size: 0.86rem; }
+.manual-transition-pending { color: var(--muted); font-size: 0.86rem; }
+.primary-button, .secondary-button, .danger-button { display: inline-flex; align-items: center; justify-content: center; min-height: var(--control-height); padding: 0 var(--control-padding-inline); border-radius: var(--control-radius); font-size: var(--control-font-size); font-weight: 700; line-height: 1; cursor: pointer; }
 .primary-button { border: 1px solid var(--accent); background: var(--accent); color: white; }
 .secondary-button { border: 1px solid var(--border); background: var(--surface); }
 .danger-button { border: 1px solid var(--danger); background: var(--surface); color: var(--danger); }
@@ -160,6 +171,8 @@ dialog section + section { margin-top: 24px; }
 .result-history-item { padding: 13px 14px; border: 1px solid var(--border); border-radius: 8px; background: var(--surface-muted); }
 .result-history-latest { border-color: var(--accent); background: var(--accent-soft); box-shadow: inset 3px 0 var(--accent); }
 .result-history-header { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 9px; }
+.result-history-header .timestamp-toggle { margin-left: auto; }
+.result-history-source { color: var(--muted); font-size: 0.72rem; font-weight: 700; }
 .result-history-item p { margin-bottom: 7px; }
 .result-history-item p:last-child { margin-bottom: 0; }
 .result-history-item h4 { margin: 10px 0 3px; color: var(--muted); font-size: 0.72rem; letter-spacing: 0.04em; text-transform: uppercase; }
@@ -182,6 +195,7 @@ pre { max-height: 280px; margin: 0; padding: 14px; overflow: auto; border-radius
 :focus-visible { outline: 3px solid rgb(33 95 74 / 35%); outline-offset: 3px; }
 
 @media (max-width: 650px) {
+  :root { --control-height: 40px; }
   .site-header { align-items: flex-start; gap: 14px; padding-top: 28px; }
   .title-row { align-items: flex-start; }
   .toolbar-primary { grid-template-columns: repeat(2, minmax(0, 1fr)); }
@@ -196,7 +210,6 @@ pre { max-height: 280px; margin: 0; padding: 14px; overflow: auto; border-radius
   .task-open { align-self: flex-start; }
   select { min-height: 40px; }
   .status-filter-option span { min-height: 38px; }
-  .primary-button.task-action, .secondary-button.task-action { min-height: 40px; }
   .dialog-actions { align-items: center; flex-flow: row wrap; }
   .metadata { grid-template-columns: 1fr; }
   .metadata dt { padding-bottom: 0; border-bottom: 0; }

package/src/dashboard.js

@@ -16,6 +16,7 @@ import {
   acquireWorkspaceLock,
   canonicalDirectory,
   canonicalGitRoot,
+  manuallyTransitionTask,
   parseTaskLogContent,
   readConfig,
   readTask,
@@ -31,6 +32,7 @@ const LOOPBACK_HOSTS = new Set(["127.0.0.1", "::1"]);
 const DEFAULT_MAX_FILE_BYTES = 16 * 1024 * 1024;
 const DEFAULT_MAX_TASKS = 2_000;
 const DEFAULT_MAX_EVENT_CLIENTS = 16;
+const MAX_MANUAL_TRANSITION_BODY_BYTES = 4 * 1024;
 export const DASHBOARD_HEALTH_PATH = "/api/health";
 export const DASHBOARD_HEALTH_MAX_BYTES = 8 * 1024;
 const CONTENT_SECURITY_POLICY = [
@@ -160,6 +162,11 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
       boundedText(turn.turnRef, 512, `${name} turn ${turnIndex + 1} turn ref`);
       boundedText(turn.turnId, 512, `${name} turn ${turnIndex + 1} turn ID`);
       boundedText(turn.result?.summary, 2_000, `${name} turn ${turnIndex + 1} result summary`);
+      boundedText(
+        turn.provenance?.actionId,
+        512,
+        `${name} turn ${turnIndex + 1} manual action ID`,
+      );
     }
     const results = task.results ?? [];
     if (results.length > 10_000) {
@@ -169,6 +176,11 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
       boundedText(result.summary, 2_000, `${name} result ${resultIndex + 1} summary`);
       boundedText(result.turnRef, 512, `${name} result ${resultIndex + 1} turn ref`);
       boundedText(result.turnId, 512, `${name} result ${resultIndex + 1} turn ID`);
+      boundedText(
+        result.provenance?.actionId,
+        512,
+        `${name} result ${resultIndex + 1} manual action ID`,
+      );
     }
     boundedText(task.project.name, 1_000, `${name} project name`);
     boundedText(task.project.path, 8_192, `${name} project path`);
@@ -383,6 +395,79 @@ function sendJson(response, status, value) {
   response.end(`${JSON.stringify(value)}\n`);
 }
 
+async function readBoundedJsonBody(request, maximumBytes = MAX_MANUAL_TRANSITION_BODY_BYTES) {
+  const contentType = request.headers["content-type"] ?? "";
+  if (!/^application\/json(?:\s*;|$)/i.test(contentType)) {
+    const error = new Error("Request content type must be application/json.");
+    error.code = "unsupported_media_type";
+    throw error;
+  }
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of request) {
+    total += chunk.length;
+    if (total > maximumBytes) {
+      const error = new Error("Request body is too large.");
+      error.code = "body_too_large";
+      throw error;
+    }
+    chunks.push(chunk);
+  }
+  let value;
+  try {
+    value = JSON.parse(Buffer.concat(chunks, total).toString("utf8"));
+  } catch {
+    const error = new Error("Request body must be valid JSON.");
+    error.code = "malformed_json";
+    throw error;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    const error = new Error("Request body must be a JSON object.");
+    error.code = "invalid_request";
+    throw error;
+  }
+  return value;
+}
+
+function manualTransitionInput(body) {
+  const fields = new Set(["schemaVersion", "actionId", "expected", "targetStatus"]);
+  const unexpected = Object.keys(body).find((key) => !fields.has(key));
+  const missing = [...fields].find((key) => !(key in body));
+  if (unexpected || missing || body.schemaVersion !== 1) {
+    const error = new Error("Manual transition request has an invalid shape.");
+    error.code = "invalid_request";
+    throw error;
+  }
+  const { schemaVersion: _schemaVersion, ...input } = body;
+  return input;
+}
+
+function manualTransitionErrorResponse(error) {
+  const definitions = new Map([
+    ["malformed_json", [400, "Request body must be valid JSON."]],
+    ["invalid_request", [400, "Manual transition request is invalid."]],
+    ["task_not_found", [404, "Task not found."]],
+    ["stale_task", [409, "This task changed. Review its current state and try again."]],
+    ["invalid_transition", [409, "This task can no longer be changed manually."]],
+    ["idempotency_conflict", [409, "This manual action ID was already used."]],
+    ["body_too_large", [413, "Request body is too large."]],
+    ["unsupported_media_type", [415, "Request content type must be application/json."]],
+    ["ELOCKED", [503, "TaskChef is busy updating the workspace. Try again."]],
+  ]);
+  const definition = definitions.get(error?.code);
+  const [status, message] = definition ?? [500, "Dashboard request failed."];
+  return {
+    status,
+    body: {
+      code: error?.code === "ELOCKED"
+        ? "workspace_busy"
+        : (definition ? error.code : "dashboard_error"),
+      message,
+      ...(error?.task ? { task: taskDetailProjection(error.task) } : {}),
+    },
+  };
+}
+
 function ssePayload(event, value) {
   return `event: ${event}\ndata: ${JSON.stringify(value)}\n\n`;
 }
@@ -591,6 +676,37 @@ export async function createDashboardServer({
       return;
     }
 
+    const transitionMatch = url.pathname.match(
+      /^\/api\/tasks\/([a-zA-Z0-9._-]+)\/manual-transition$/,
+    );
+    if (transitionMatch && method === "POST") {
+      if (request.headers.origin !== allowedOrigin) {
+        sendJson(response, 403, {
+          code: "invalid_origin",
+          message: "Dashboard origin validation failed.",
+        });
+        return;
+      }
+      try {
+        const body = await readBoundedJsonBody(request);
+        const result = await manuallyTransitionTask(
+          monitor.workspace,
+          transitionMatch[1],
+          manualTransitionInput(body),
+        );
+        await monitor.refresh({ force: true }).catch(() => {});
+        sendJson(response, 200, {
+          schemaVersion: 1,
+          task: taskDetailProjection(result.task),
+          idempotent: result.idempotent,
+        });
+      } catch (error) {
+        const failure = manualTransitionErrorResponse(error);
+        sendJson(response, failure.status, failure.body);
+      }
+      return;
+    }
+
     const taskMatch = url.pathname.match(/^\/api\/tasks\/([a-zA-Z0-9._-]+)\/open-codex$/);
     if (taskMatch && method === "POST") {
       if (request.headers.origin !== allowedOrigin) {