coding-agent-harness 1.0.7 → 1.1.0

package/templates/dashboard/assets/app.js

@@ -7,7 +7,7 @@ let labels = window.HarnessI18n?.[locale] || {};
 const state = {
   query: "",
   taskState: "all",
-  taskGroupMode: "migration",
+  taskGroupMode: localStorage.getItem("harness.taskGroupMode") || ((Array.isArray(bundle.modules) && bundle.modules.length > 0) ? "module" : "migration"),
   taskPageByGroup: {},
   taskGroupPage: 1,
   warningFilter: "all",
@@ -24,6 +24,10 @@ const state = {
   presetSeedForce: false,
   presetUninstallScope: "project",
   presetUninstallConfirm: "",
+  reviewBulkSelection: {},
+  reviewBulkResult: null,
+  lessonBulkSelection: {},
+  lessonBulkResult: null,
   renderMode: "rendered",
   theme: localStorage.getItem("harness.theme") || "system",
   taskLayout: localStorage.getItem("harness.taskLayout") || "list",
@@ -57,6 +61,10 @@ function t(key) {
   return labels[key] || key;
 }
 
+function formatMessage(key, values = {}) {
+  return escapeHtml(t(key)).replace(/\{([^}]+)\}/g, (_, name) => escapeHtml(values[name] ?? ""));
+}
+
 function setLocale(nextLocale) {
   locale = window.HarnessI18n?.[nextLocale] ? nextLocale : "en";
   labels = window.HarnessI18n?.[locale] || {};
@@ -83,6 +91,7 @@ function shell() {
         ${routeLink("#/", t("overview"), "overview")}
         ${routeLink("#/tasks", t("taskIndex"), "tasks")}
         ${routeLink("#/review", t("reviewQueue"), "review")}
+        ${routeLink("#/archive", t("archive"), "archive")}
         ${routeLink("#/modules", t("moduleView"), "modules")}
         ${routeLink("#/presets", t("presetCatalog"), "presets")}
         <button data-language-toggle>${locale === "zh" ? "EN" : "中文"}</button>
@@ -110,6 +119,7 @@ function renderRoute() {
   if (route.name === "task") return taskDetail(route);
   if (route.name === "reviewTask") return reviewWorkspace(route);
   if (route.name === "review") return reviewQueue();
+  if (route.name === "archive") return archiveView();
   if (route.name === "modules") return modulesView(route.id);
   if (route.name === "presets") return presetsView();
   if (route.name === "tasks") return taskIndex();
@@ -122,6 +132,7 @@ function currentRoute() {
   if (parts[0] === "tasks" && parts[1]) return { name: "task", id: parts[1], doc: parts[2] === "docs" ? parts[3] || "" : "" };
   if (parts[0] === "review" && parts[1]) return { name: "reviewTask", id: parts[1] };
   if (parts[0] === "review") return { name: "review" };
+  if (parts[0] === "archive") return { name: "archive" };
   if (parts[0] === "modules") return { name: "modules", id: parts[1] || "" };
   if (parts[0] === "presets") return { name: "presets" };
   if (parts[0] === "tasks") return { name: "tasks" };
@@ -157,7 +168,7 @@ function statusStrip() {
   const displayState = snapshotOnly ? "snapshot" : status;
   const failures = bundle.status?.checkState?.failures || 0;
   const warnings = bundle.status?.checkState?.warnings || 0;
-  const tasks = bundle.status?.tasks || [];
+  const tasks = normalCycleTasks();
   const summary = bundle.status?.summary || {};
   const visual = summary.visualMapCoverage || {};
   const withBrief = tasks.filter((task) => task.briefSource === "standalone").length;
@@ -189,7 +200,7 @@ function nextActionText() {
   if (dataOnly && !isWorkbenchRuntime()) return t("snapshotNotValidated");
   const failures = bundle.status?.checkState?.failures || 0;
   if (failures > 0) return t("resolveBlockers");
-  const missingBriefs = (bundle.status?.tasks || []).filter((task) => task.briefSource !== "standalone").length;
+  const missingBriefs = normalCycleTasks().filter((task) => task.briefSource !== "standalone").length;
   if (missingBriefs > 0) return `${missingBriefs} ${t("missingBriefs")}`;
   const warnings = bundle.status?.checkState?.warnings || 0;
   if (warnings > 0) return t("reviewAdvice");
@@ -202,7 +213,7 @@ function isWorkbenchRuntime() {
 }
 
 function flowPanel() {
-  const tasks = bundle.status?.tasks || [];
+  const tasks = normalCycleTasks();
   const total = tasks.length;
   if (total === 0) return "";
   const active = tasks.filter((task) => isActiveTaskState(task.state)).length;
@@ -261,14 +272,14 @@ function projectMermaid() {
 
 function usesAggregateFlow() {
   const graph = bundle.graph || { nodes: [], edges: [] };
-  const taskCount = (bundle.status?.tasks || []).length;
+  const taskCount = normalCycleTasks().length;
   const taskNodes = (graph.nodes || []).filter((node) => node.type === "task").length;
   const usefulEdges = (graph.edges || []).filter((edge) => ["depends_on", "current_step"].includes(edge.type)).length;
   return taskCount > 80 || taskNodes > 80 || ((graph.nodes || []).length > 80 && usefulEdges < 6);
 }
 
 function migrationAggregateMermaid() {
-  const tasks = bundle.status?.tasks || [];
+  const tasks = normalCycleTasks();
   const warnings = warningQueue();
   const activeContracts = warnings.filter((warning) => warning.phase === "active-task-contracts").length;
   const moduleCount = new Set(tasks.map(taskModuleKey)).size;
@@ -284,7 +295,7 @@ function migrationAggregateMermaid() {
 }
 
 function migrationRunwayBreakdown() {
-  const tasks = bundle.status?.tasks || [];
+  const tasks = normalCycleTasks();
   const warnings = warningQueue();
   const phases = [
     ["baseline", t("runwayBaseline"), tasks.length, t("tasks"), "#/tasks"],
@@ -306,7 +317,7 @@ function mermaidFromBriefs() {
 
 function graphSummary() {
   const graph = bundle.graph || { nodes: [], edges: [] };
-  if (usesAggregateFlow()) return `${t("aggregateMigrationView")} · ${(bundle.status?.tasks || []).length} ${t("tasks")}`;
+  if (usesAggregateFlow()) return `${t("aggregateMigrationView")} · ${normalCycleTasks().length} ${t("tasks")}`;
   return `${graph.nodes?.length || 0} ${t("nodes")} · ${graph.edges?.length || 0} ${t("edges")}`;
 }
 
@@ -330,7 +341,7 @@ function activeTaskBriefs() {
 }
 
 function activeTasks() {
-  const tasks = bundle.status?.tasks || [];
+  const tasks = normalCycleTasks();
   const active = tasks.filter((task) => isActiveTaskState(task.state) || ["planned", "not_started"].includes(task.state));
   if (active.length > 0) return sortTasksByTime(active);
   return sortTasksByTime(tasks.filter((task) => task.briefSource === "standalone"));
@@ -396,6 +407,22 @@ function stateToColorVar(state) {
   return map[state] || "--muted";
 }
 
+function taskStatRows(tasks) {
+  return [
+    { state: "in_progress", label: t("statInProgress"), className: "in-progress" },
+    { state: "review", label: t("statReview"), className: "review" },
+    { state: "blocked", label: t("statBlocked"), className: "blocked" },
+    { state: "done", label: t("statDone"), className: "done" },
+    { state: "planned", label: label("planned"), className: "planned" },
+    { state: "not_started", label: label("not_started"), className: "not-started" },
+    { state: "unknown", label: label("unknown"), className: "unknown" },
+  ].map((row) => ({
+    ...row,
+    count: tasks.filter((task) => task.state === row.state).length,
+    colorVar: stateToColorVar(row.state),
+  })).filter((row) => row.count > 0);
+}
+
 function taskSortLabel() {
   return state.taskSortOrder === "asc" ? t("sortOldest") : t("sortNewest");
 }
@@ -430,6 +457,23 @@ function sortTasksByTime(tasks) {
   return [...tasks].sort(compareTasksByTime);
 }
 
+function isArchivedTask(task) {
+  const archiveState = String(task?.archiveMetadata?.state || "").toLowerCase();
+  return task?.deletionState === "archived" || archiveState === "archived";
+}
+
+function normalCycleTasks() {
+  return (bundle.status?.tasks || []).filter((task) => !isArchivedTask(task));
+}
+
+function archivedTasks() {
+  return (bundle.status?.tasks || []).filter(isArchivedTask);
+}
+
+function archiveBucket(task) {
+  return task?.archiveMetadata?.["retention bucket"] || task?.archiveMetadata?.["Retention Bucket"] || t("archiveUnclassified");
+}
+
 function taskFolderName(task) {
   const fromPath = String(task?.path || "").split("/").filter(Boolean).pop();
   const fromId = String(task?.id || "").split("/").filter(Boolean).pop();
@@ -458,7 +502,7 @@ function taskToolbarCard(filteredCount) {
     <div class="select-group">
       <label>${t("stateFilter")}</label>
       <select data-state-filter aria-label="${t("stateFilter")}">
-        ${["all", "in_progress", "review", "blocked", "planned", "done", "unknown"].map((value) => `<option value="${value}" ${state.taskState === value ? "selected" : ""}>${label(value)}</option>`).join("")}
+        ${["all", "in_progress", "review", "blocked", "planned", "not_started", "done", "unknown"].map((value) => `<option value="${value}" ${state.taskState === value ? "selected" : ""}>${label(value)}</option>`).join("")}
       </select>
     </div>
     <div class="select-group">
@@ -478,6 +522,10 @@ function taskToolbarCard(filteredCount) {
           <svg style="width:12px;height:12px;vertical-align:middle" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="3" width="7" height="7"/><rect x="14" y="3" width="7" height="7"/><rect x="14" y="14" width="7" height="7"/><rect x="3" y="14" width="7" height="7"/></svg>
           ${t("layoutGrid")}
         </button>
+        <button class="layout-btn ${state.taskLayout === "swimlane" ? "active" : ""}" data-layout="swimlane" aria-label="${t("layoutSwimlane")}">
+          <svg style="width:12px;height:12px;vertical-align:middle" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M4 6h16"/><path d="M4 12h16"/><path d="M4 18h16"/><path d="M8 4v16"/><path d="M16 4v16"/></svg>
+          ${t("layoutSwimlane")}
+        </button>
       </div>
     </div>
     <div class="select-group">
@@ -492,13 +540,13 @@ function taskToolbarCard(filteredCount) {
       </div>
     </div>
     <div class="search-stats">
-      ${t("showing")} <strong>${filteredCount}</strong> / ${(bundle.status?.tasks || []).length} ${t("tasks")}
+      ${t("showing")} <strong>${filteredCount}</strong> / ${normalCycleTasks().length} ${t("tasks")}
     </div>
   </section>`;
 }
 
 function taskStatsCard() {
-  const allTasks = bundle.status?.tasks || [];
+  const allTasks = normalCycleTasks();
   const avgCompletion = allTasks.length ? clampCompletion(allTasks.reduce((sum, task) => sum + clampCompletion(task.completion), 0) / allTasks.length) : 0;
   return `<section class="sidebar-card">
     <h3>${t("releaseHealth")}</h3>
@@ -507,13 +555,7 @@ function taskStatsCard() {
       <span class="gauge-label">${t("statOverall")}</span>
     </div>
     <div class="stats-breakdown">
-      ${[
-        { state: "in_progress", label: t("statInProgress"), colorVar: "--accent" },
-        { state: "review", label: t("statReview"), colorVar: "--accent-2" },
-        { state: "blocked", label: t("statBlocked"), colorVar: "--danger" },
-        { state: "done", label: t("statDone"), colorVar: "--ok" }
-      ].map(({ state, label, colorVar }) => {
-        const count = allTasks.filter(t => t.state === state).length;
+      ${taskStatRows(allTasks).map(({ label, colorVar, count }) => {
         return `<div class="stats-breakdown-row">
           <span class="stat-label">
             <span class="state-dot" style="background:var(${colorVar})"></span>
@@ -549,11 +591,7 @@ function taskLegendCard() {
 }
 
 function taskStatsBar() {
-  const allTasks = bundle.status?.tasks || [];
-  const inProgress = allTasks.filter(t => t.state === "in_progress").length;
-  const blocked = allTasks.filter(t => t.state === "blocked").length;
-  const done = allTasks.filter(t => t.state === "done").length;
-  const review = allTasks.filter(t => t.state === "review").length;
+  const allTasks = normalCycleTasks();
   const avgCompletion = allTasks.length ? clampCompletion(allTasks.reduce((sum, task) => sum + clampCompletion(task.completion), 0) / allTasks.length) : 0;
 
   return `<section class="task-stats-bar">
@@ -561,22 +599,10 @@ function taskStatsBar() {
       <span class="stat-value">${allTasks.length}</span>
       <span class="stat-label">${t("statTotal")}</span>
     </div>
-    <div class="stat-chip in-progress">
-      <span class="stat-value">${inProgress}</span>
-      <span class="stat-label">${t("statInProgress")}</span>
-    </div>
-    <div class="stat-chip review">
-      <span class="stat-value">${review}</span>
-      <span class="stat-label">${t("statReview")}</span>
-    </div>
-    <div class="stat-chip blocked">
-      <span class="stat-value">${blocked}</span>
-      <span class="stat-label">${t("statBlocked")}</span>
-    </div>
-    <div class="stat-chip done">
-      <span class="stat-value">${done}</span>
-      <span class="stat-label">${t("statDone")}</span>
-    </div>
+    ${taskStatRows(allTasks).map((row) => `<div class="stat-chip ${escapeAttr(row.className)}" style="--stat-color: var(${row.colorVar})">
+      <span class="stat-value">${row.count}</span>
+      <span class="stat-label">${escapeHtml(row.label)}</span>
+    </div>`).join("")}
     <div class="stat-chip completion">
       <div class="stat-bar-track"><div class="stat-bar-fill" style="width:${avgCompletion}%"></div></div>
       <div style="text-align:right">
@@ -593,12 +619,14 @@ function taskRow(task) {
   const mapReady = !!taskDocument(task, "visual_map.md");
   const briefLabel = briefReady ? t("briefReady") : t("briefMissing");
   const mapLabel = mapReady ? t("mapReady") : t("mapMissing");
+  const moduleLabel = taskModuleLabel(task);
+  const lifecycle = [task.lifecycleState, task.reviewStatus, task.closeoutStatus].filter(Boolean).map((item) => label(item)).join(" · ");
 
   return `<article class="task-row-card" data-open-drawer="${escapeAttr(task.id)}" style="--row-accent: var(${stateToColorVar(task.state)})">
     <div class="row-accent-bar"></div>
     <div class="row-main">
       <strong>${escapeHtml(task.title)}</strong>
-      <span class="row-meta">${escapeHtml(task.id)} · ${escapeHtml(taskModuleKey(task))}</span>
+      <span class="row-meta">${escapeHtml(task.id)} · ${escapeHtml(moduleLabel)}${lifecycle ? ` · ${escapeHtml(lifecycle)}` : ""}</span>
       ${taskCopyButton(task, "row-copy")}
     </div>
     <div class="row-status">${tag(task.state)}</div>
@@ -628,15 +656,16 @@ function taskIndex() {
   const groupPageCount = Math.max(1, Math.ceil(orderedGroups.length / taskGroupsPerPage));
   const groupPage = Math.min(Math.max(1, Number(state.taskGroupPage) || 1), groupPageCount);
   const visibleGroups = orderedGroups.slice((groupPage - 1) * taskGroupsPerPage, groupPage * taskGroupsPerPage);
+  const swimlane = state.taskLayout === "swimlane";
 
   return `<div class="tasks-grid">
     <div class="tasks-main stack">
       ${taskStatsBar()}
-      ${visibleGroups.map(([group, groupTasks]) => taskGroup(group, groupTasks)).join("")}
-      <section class="group-pager">
+      ${swimlane ? taskSwimlane(tasks) : visibleGroups.map(([group, groupTasks]) => taskGroup(group, groupTasks)).join("")}
+      ${swimlane ? "" : `<section class="group-pager">
         <span>${t("showingGroups")} ${visibleGroups.length ? (groupPage - 1) * taskGroupsPerPage + 1 : 0}-${Math.min(groupPage * taskGroupsPerPage, orderedGroups.length)} / ${orderedGroups.length}</span>
         ${pager("task-groups", groupPage, groupPageCount)}
-      </section>
+      </section>`}
     </div>
     <aside class="tasks-sidebar stack">
       ${taskToolbarCard(tasks.length)}
@@ -699,6 +728,7 @@ function taskGroup(group, tasks) {
   const start = (page - 1) * taskPageSize;
   const visibleTasks = orderedTasks.slice(start, start + taskPageSize);
   const avgCompletion = orderedTasks.length ? clampCompletion(orderedTasks.reduce((sum, task) => sum + clampCompletion(task.completion), 0) / orderedTasks.length) : 0;
+  const groupContext = taskGroupContext(group, orderedTasks);
 
   const isGrid = state.taskLayout === "grid";
   const layoutClass = isGrid ? "task-card-grid" : "task-list";
@@ -714,8 +744,10 @@ function taskGroup(group, tasks) {
   return `<section class="task-group">
       <div class="section-head">
         <div>
-          <h2>${taskGroupLabel(group)}</h2>
-          <p class="subtle">${t("showing")} ${Math.min(start + 1, orderedTasks.length)}-${Math.min(start + visibleTasks.length, orderedTasks.length)} / ${orderedTasks.length}</p>
+          <p class="eyebrow">${escapeHtml(groupContext.eyebrow)}</p>
+          <h2>${escapeHtml(groupContext.title)}</h2>
+          <p class="subtle">${escapeHtml(groupContext.summary)} · ${t("showing")} ${Math.min(start + 1, orderedTasks.length)}-${Math.min(start + visibleTasks.length, orderedTasks.length)} / ${orderedTasks.length}</p>
+          ${groupContext.chips.length ? `<div class="module-chip-row">${groupContext.chips.map((chip) => `<span class="module-chip">${escapeHtml(chip)}</span>`).join("")}</div>` : ""}
         </div>
         <div class="group-actions">
           <div class="group-progress" aria-label="${escapeAttr(t("groupCompletion"))}">
@@ -739,6 +771,7 @@ function taskCard(task) {
   const mapReady = !!taskDocument(task, "visual_map.md");
   const briefLabel = briefReady ? t("briefReady") : t("briefMissing");
   const mapLabel = mapReady ? t("mapReady") : t("mapMissing");
+  const lifecycle = [task.lifecycleState, task.reviewStatus, task.closeoutStatus].filter(Boolean).map((item) => label(item)).join(" · ");
 
   return `<article class="task-card" data-open-drawer="${escapeAttr(task.id)}" style="--row-accent: var(${stateColor})">
     <div class="card-header">
@@ -752,8 +785,9 @@ function taskCard(task) {
     <div class="card-meta">
       <span class="meta-module" title="${escapeAttr(taskModuleKey(task))}">
         <svg style="width:12px;height:12px;vertical-align:middle;margin-right:2px" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"/></svg>
-        ${escapeHtml(taskModuleKey(task))}
+        ${escapeHtml(taskModuleLabel(task))}
       </span>
+      ${lifecycle ? `<span class="meta-lifecycle" title="${escapeAttr(lifecycle)}">${escapeHtml(lifecycle)}</span>` : ""}
     </div>
     <div class="card-progress">
       <div class="card-progress-track"><div class="card-progress-fill" style="width:${completion}%"></div></div>
@@ -776,7 +810,7 @@ function taskGroupLabel(group) {
   if (group === "active") return t("activeCurrent");
   if (group === "brief-ready") return t("briefReadyGroup");
   if (group.startsWith("legacy:")) return `${t("legacyMonth")} ${group.slice("legacy:".length)}`;
-  if (group.startsWith("module:")) return `${t("inferredModule")} · ${group.slice("module:".length)}`;
+  if (group.startsWith("module:")) return taskGroupContext(group, []).title;
   if (group.startsWith("month:")) return `${t("legacyMonth")} ${group.slice("month:".length)}`;
   if (group.startsWith("state:")) return `${t("columnState")} · ${label(group.slice("state:".length))}`;
   return label(group);
@@ -784,7 +818,7 @@ function taskGroupLabel(group) {
 
 function filteredTasks() {
   const query = state.query.trim().toLowerCase();
-  return sortTasksByTime((bundle.status?.tasks || []).filter((task) => {
+  return sortTasksByTime(normalCycleTasks().filter((task) => {
     const stateMatch = state.taskState === "all" || task.state === state.taskState;
     if (!stateMatch) return false;
     if (!query) return true;
@@ -796,6 +830,390 @@ function taskModuleKey(task) {
   return task.module || task.inferredModule || "legacy-unclassified";
 }
 
+function taskModuleDisplayLabel(key) {
+  if (key === "base") return t("baseModule");
+  if (key === "legacy-unclassified") return t("unclassifiedModule");
+  return key;
+}
+
+function archiveView() {
+  const tasks = sortTasksByTime(archivedTasks());
+  const groups = Object.entries(groupBy(tasks, archiveBucket)).sort(([left], [right]) => left.localeCompare(right));
+  return `<main class="stack archive-view">
+    <section class="flow-panel">
+      <div class="section-head">
+        <div>
+          <p class="eyebrow">${t("archive")}</p>
+          <h2>${t("archiveView")}</h2>
+          <p class="subtle">${t("archiveSubtitle")}</p>
+        </div>
+        <a href="#/tasks">${t("openTaskIndex")}</a>
+      </div>
+      <div class="archive-summary-grid">
+        ${metric(t("archivedTasks"), tasks.length)}
+        ${metric(t("archiveBuckets"), groups.length)}
+      </div>
+    </section>
+    ${groups.map(([bucket, bucketTasks]) => archiveGroup(bucket, bucketTasks)).join("") || emptyState(t("noArchivedTasks"))}
+  </main>`;
+}
+
+function archiveGroup(bucket, tasks) {
+  const orderedTasks = sortTasksByTime(tasks);
+  return `<section class="archive-group">
+    <div class="section-head">
+      <div>
+        <h2>${escapeHtml(bucket)}</h2>
+        <p class="subtle">${orderedTasks.length} ${t("tasks")}</p>
+      </div>
+    </div>
+    <div class="archive-task-list">
+      ${orderedTasks.map(archiveTaskRow).join("")}
+    </div>
+  </section>`;
+}
+
+function archiveTaskRow(task) {
+  const archiveMetadata = task.archiveMetadata || {};
+  const archivedBy = archiveMetadata?.["archived by"] || t("unknown");
+  const archivedAt = archiveMetadata?.["archived at"] || "";
+  const reviewConfirmedBy = archiveMetadata?.["review confirmed by"] || t("unknown");
+  const reviewConfirmedAt = archiveMetadata?.["review confirmed at"] || "";
+  const reviewConfirmationId = archiveMetadata?.["review confirmation id"] || "";
+  const releasePackage = archiveMetadata?.["release package"] || "";
+  const reason = task.deleteReason || archiveMetadata?.reason || "";
+  return `<article class="archive-task-row">
+    <div class="archive-task-main">
+      <a href="#/tasks/${encodeURIComponent(task.id)}">${escapeHtml(task.title || task.id)}</a>
+      <span>${escapeHtml(task.id)}</span>
+      ${reason ? `<p>${escapeHtml(reason)}</p>` : ""}
+    </div>
+    <dl class="archive-meta-grid">
+      <div><dt>${t("archivedBy")}</dt><dd>${escapeHtml(archivedBy)}</dd></div>
+      <div><dt>${t("archivedAt")}</dt><dd>${escapeHtml(archivedAt || t("unknown"))}</dd></div>
+      <div><dt>${t("reviewConfirmedBy")}</dt><dd>${escapeHtml(reviewConfirmedBy)}</dd></div>
+      <div><dt>${t("reviewConfirmedAt")}</dt><dd>${escapeHtml(reviewConfirmedAt || t("unknown"))}</dd></div>
+      ${reviewConfirmationId ? `<div><dt>${t("reviewConfirmationId")}</dt><dd>${escapeHtml(reviewConfirmationId)}</dd></div>` : ""}
+      ${releasePackage ? `<div><dt>${t("releasePackage")}</dt><dd>${escapeHtml(releasePackage)}</dd></div>` : ""}
+    </dl>
+  </article>`;
+}
+
+const swimlaneStageOrder = [
+  ["planned", "swimlaneStagePlanned"],
+  ["in_progress", "swimlaneStageInProgress"],
+  ["evidence", "swimlaneStageEvidence"],
+  ["review", "swimlaneStageReview"],
+  ["confirmed", "swimlaneStageConfirmed"],
+  ["closeout", "swimlaneStageCloseout"],
+  ["blocked", "swimlaneStageBlocked"],
+];
+const swimlaneCellPageSize = 10;
+const swimlaneMiniColumnLimit = 5;
+
+function taskSwimlaneModel(tasks) {
+  const cards = sortTasksByTime(tasks)
+    .filter((task) => taskVisibleInSwimlane(task))
+    .map((task) => {
+      const lane = taskModuleKey(task);
+      const stage = taskSwimlaneStage(task);
+      return {
+        task,
+        lane,
+        stage,
+        id: task.id,
+        title: task.title,
+        reason: taskSwimlaneReason(task),
+      };
+    });
+  const laneKeys = [...new Set(cards.map((card) => card.lane))].sort((left, right) => {
+    if (left === "legacy-unclassified") return 1;
+    if (right === "legacy-unclassified") return -1;
+    return left.localeCompare(right);
+  });
+  return {
+    stages: swimlaneStageOrder.map(([key, labelKey]) => ({ key, label: t(labelKey) })),
+    lanes: laneKeys.map((key) => ({ key, label: taskModuleDisplayLabel(key) })),
+    cards,
+  };
+}
+
+function taskVisibleInSwimlane(task) {
+  const stateValue = String(task.state || "");
+  const closeout = String(task.closeoutStatus || "");
+  if (["done", "closed", "finalized"].includes(stateValue)) return false;
+  if (["closed", "finalized"].includes(closeout)) return false;
+  if (clampCompletion(task.completion) >= 100 && !["review", "blocked", "reopened", "current-evidence"].includes(stateValue)) return false;
+  return ["active", "planned", "not_started", "in_progress", "review", "blocked", "reopened", "current-evidence"].includes(stateValue)
+    || ["ready-to-confirm", "needs-material", "review-blocked"].includes(String(task.reviewQueueState || ""))
+    || ["agent-reviewed", "confirmed", "blocked-open-findings"].includes(String(task.reviewStatus || ""));
+}
+
+function taskSwimlaneStage(task) {
+  const stateValue = String(task.state || "");
+  const review = String(task.reviewStatus || "");
+  const reviewQueue = String(task.reviewQueueState || "");
+  const closeout = String(task.closeoutStatus || "");
+  if (stateValue === "blocked" || review.includes("blocked") || reviewQueue.includes("blocked")) return "blocked";
+  if (review === "confirmed" && taskHasPendingLessonWork(task)) return "closeout";
+  if (review === "confirmed" && ["missing", "pending", "required", "closing"].includes(closeout)) return "closeout";
+  if (review === "confirmed") return "confirmed";
+  if (stateValue === "review" || reviewQueue === "ready-to-confirm" || (task.taskQueues || []).includes("review") || ["agent-reviewed", "in_review"].includes(review)) return "review";
+  if (["planned", "not_started"].includes(stateValue)) return "planned";
+  if (taskNeedsEvidence(task)) return "evidence";
+  if (["active", "in_progress", "reopened", "current-evidence"].includes(stateValue)) return "in_progress";
+  return "planned";
+}
+
+function taskNeedsEvidence(task) {
+  if (["missing", "legacy-only"].includes(String(task.visualMapStatus || ""))) return true;
+  if (task.briefSource && task.briefSource !== "standalone") return true;
+  return (task.phases || []).some((phase) => ["missing", "partial"].includes(String(phase.evidenceStatus || "")));
+}
+
+function taskSwimlaneReason(task) {
+  const reasons = Array.isArray(task.queueReasons) ? task.queueReasons.filter(Boolean) : [];
+  if (reasons.length) return reasons[0];
+  if (taskNeedsEvidence(task)) return t("swimlaneNeedsEvidence");
+  if (task.reviewQueueState === "ready-to-confirm") return t("swimlaneReadyToConfirm");
+  if (task.closeoutStatus === "missing") return t("swimlaneNeedsCloseout");
+  return "";
+}
+
+function taskSwimlane(tasks) {
+  const model = taskSwimlaneModel(tasks);
+  if (!model.cards.length) return `<section class="task-swimlane empty-state">${escapeHtml(t("swimlaneEmpty"))}</section>`;
+  const view = taskSwimlaneHeatmapModel(model);
+  const active = taskSwimlaneActiveExpansion(view);
+  return `<section class="task-swimlane" aria-label="${escapeAttr(t("layoutSwimlane"))}">
+    <div class="swimlane-header">
+      <div>
+        <p class="eyebrow">${t("swimlaneEyebrow")}</p>
+        <h2>${t("swimlaneTitle")}</h2>
+      </div>
+      <span class="subtle">${model.cards.length} · ${t("tasks")}</span>
+    </div>
+    ${taskSwimlaneHeatmap(view, active)}
+    ${taskSwimlaneMobileList(view, active)}
+    ${taskSwimlaneDrilldown(view, active)}
+  </section>`;
+}
+
+function taskSwimlaneHeatmapModel(model) {
+  const stageTotals = Object.fromEntries(model.stages.map((stage) => [stage.key, 0]));
+  const lanes = taskSwimlaneRenderLanes(model).map((lane) => {
+    const stageCards = Object.fromEntries(model.stages.map((stage) => [stage.key, []]));
+    for (const card of model.cards) {
+      if (card.lane !== lane.key) continue;
+      stageCards[card.stage] = stageCards[card.stage] || [];
+      stageCards[card.stage].push(card);
+      stageTotals[card.stage] = (stageTotals[card.stage] || 0) + 1;
+    }
+    const total = Object.values(stageCards).reduce((sum, cards) => sum + cards.length, 0);
+    return { ...lane, total, stageCards };
+  }).sort((left, right) => {
+    if (left.key === "legacy-unclassified") return 1;
+    if (right.key === "legacy-unclassified") return -1;
+    const totalDiff = right.total - left.total;
+    return totalDiff || left.label.localeCompare(right.label);
+  });
+  const total = model.cards.length;
+  const columnTemplate = model.stages.map((stage) => {
+    const count = stageTotals[stage.key] || 0;
+    if (count === 0) return "minmax(44px, 0.36fr)";
+    if (count <= 3) return "minmax(74px, 0.7fr)";
+    if (count <= 7) return "minmax(88px, 1fr)";
+    return "minmax(104px, 1.16fr)";
+  }).join(" ");
+  return { stages: model.stages, lanes, stageTotals, total, columnTemplate };
+}
+
+function taskSwimlaneRenderLanes(model) {
+  const lanes = new Map(model.lanes.map((lane) => [lane.key, { ...lane }]));
+  const modules = typeof dashboardModules === "function" ? dashboardModules() : [];
+  for (const module of modules) {
+    const key = String(module.key || "").trim();
+    if (!key || key === "legacy-unclassified") continue;
+    const label = key === "base" ? taskModuleDisplayLabel(key) : String(module.title || taskModuleDisplayLabel(key) || key);
+    lanes.set(key, { ...(lanes.get(key) || { key }), key, label });
+  }
+  return [...lanes.values()];
+}
+
+function taskSwimlaneHeatmap(view, active) {
+  const style = `--swimlane-stage-columns: ${escapeAttr(view.columnTemplate)}`;
+  return `<div class="swimlane-heatmap" data-swimlane-heatmap="true" style="${style}" aria-label="${escapeAttr(t("swimlaneHeatmapLabel"))}">
+    <div class="swimlane-heatmap-row swimlane-heatmap-head">
+      <div class="swimlane-axis-label">${escapeHtml(t("swimlaneModuleColumn"))}</div>
+      ${view.stages.map((stage) => {
+        const total = view.stageTotals[stage.key] || 0;
+        return `<div class="swimlane-stage-header" data-swimlane-stage-total="${escapeAttr(stage.key)}" data-total="${total}">
+          <span>${escapeHtml(stage.label)}</span>
+          <strong>${total}</strong>
+        </div>`;
+      }).join("")}
+      <div class="swimlane-total-header">${escapeHtml(t("swimlaneTotalColumn"))}</div>
+    </div>
+    ${view.lanes.map((lane) => taskSwimlaneHeatmapRow(lane, view, active)).join("")}
+  </div>`;
+}
+
+function taskSwimlaneHeatmapRow(lane, view, active) {
+  const laneActive = active?.mode === "lane" && active.lane === lane.key;
+  return `<div class="swimlane-heatmap-row" data-swimlane-row="${escapeAttr(lane.key)}" data-swimlane-row-total="${lane.total}">
+    <button class="swimlane-lane-button ${laneActive ? "active" : ""}" type="button" data-swimlane-expand="lane" data-lane="${escapeAttr(lane.key)}" aria-expanded="${laneActive ? "true" : "false"}" aria-controls="swimlane-drilldown-panel">
+      <strong>${escapeHtml(lane.label)}</strong>
+      <span>${lane.total}</span>
+    </button>
+    ${view.stages.map((stage) => taskSwimlaneHeatmapCell(lane, stage, active)).join("")}
+    <div class="swimlane-row-total"><strong>${lane.total}</strong></div>
+  </div>`;
+}
+
+function taskSwimlaneHeatmapCell(lane, stage, active) {
+  const cards = lane.stageCards[stage.key] || [];
+  const count = cards.length;
+  const cellActive = active?.mode === "cell" && active.lane === lane.key && active.stage === stage.key;
+  const disabled = count === 0 ? " disabled" : "";
+  const label = `${lane.label} · ${stage.label} · ${count} ${t("tasks")}`;
+  return `<button class="swimlane-heat-cell heat-${taskSwimlaneHeatLevel(count)} ${cellActive ? "active" : ""}" type="button" data-swimlane-expand="cell" data-lane="${escapeAttr(lane.key)}" data-swimlane-stage="${escapeAttr(stage.key)}" data-count="${count}" aria-label="${escapeAttr(label)}" aria-expanded="${cellActive ? "true" : "false"}" aria-controls="swimlane-drilldown-panel"${disabled}>
+    <span>${count}</span>
+  </button>`;
+}
+
+function taskSwimlaneMobileList(view, active) {
+  return `<div class="swimlane-mobile-list" aria-label="${escapeAttr(t("swimlaneHeatmapLabel"))}">
+    ${view.lanes.map((lane) => {
+      const laneActive = active?.mode === "lane" && active.lane === lane.key;
+      return `<button class="swimlane-mobile-module ${laneActive ? "active" : ""}" type="button" data-swimlane-expand="lane" data-lane="${escapeAttr(lane.key)}" aria-expanded="${laneActive ? "true" : "false"}" aria-controls="swimlane-drilldown-panel">
+        <span><strong>${escapeHtml(lane.label)}</strong><small>${lane.total} · ${t("tasks")}</small></span>
+        <span class="swimlane-mobile-stages">${view.stages.map((stage) => {
+          const count = (lane.stageCards[stage.key] || []).length;
+          return count ? `<em>${escapeHtml(stage.label)} ${count}</em>` : "";
+        }).join("")}</span>
+      </button>`;
+    }).join("")}
+  </div>`;
+}
+
+function taskSwimlaneDrilldown(view, active) {
+  if (!active) return `<div class="swimlane-drilldown-host" data-swimlane-drilldown-host="true"></div>`;
+  const lane = view.lanes.find((candidate) => candidate.key === active.lane);
+  if (!lane) return `<div class="swimlane-drilldown-host" data-swimlane-drilldown-host="true"></div>`;
+  const cards = active.mode === "cell" ? (lane.stageCards[active.stage] || []) : Object.values(lane.stageCards).flat();
+  const title = active.mode === "cell"
+    ? `${lane.label} · ${view.stages.find((stage) => stage.key === active.stage)?.label || active.stage}`
+    : lane.label;
+  return `<div class="swimlane-drilldown-host open" data-swimlane-drilldown-host="true">
+    <section class="swimlane-drilldown" id="swimlane-drilldown-panel" aria-label="${escapeAttr(t("swimlaneDrilldownLabel"))}">
+      <div class="swimlane-drilldown-head">
+        <div>
+          <p class="eyebrow">${escapeHtml(t("swimlaneDrilldownLabel"))}</p>
+          <h3>${escapeHtml(title)}</h3>
+        </div>
+        <div class="swimlane-drilldown-actions">
+          <span>${cards.length} · ${t("tasks")}</span>
+          <button type="button" data-swimlane-collapse>${escapeHtml(t("swimlaneCollapse"))}</button>
+        </div>
+      </div>
+      ${active.mode === "lane" ? taskSwimlaneLaneBoard(lane, view.stages) : taskSwimlanePagedCardList(cards, active.page || 0)}
+    </section>
+  </div>`;
+}
+
+function taskSwimlaneLaneBoard(lane, stages) {
+  return `<div class="swimlane-mini-board">
+    ${stages.map((stage) => {
+      const cards = lane.stageCards[stage.key] || [];
+      const visibleCards = cards.slice(0, swimlaneMiniColumnLimit);
+      const hidden = Math.max(0, cards.length - visibleCards.length);
+      return `<div class="swimlane-mini-column">
+        <div class="swimlane-mini-column-head"><span>${escapeHtml(stage.label)}</span><strong>${cards.length}</strong></div>
+        <div class="swimlane-card-list">${visibleCards.map((card) => taskSwimlaneCard(card)).join("") || `<span class="swimlane-mini-empty">${escapeHtml(t("none"))}</span>`}</div>
+        ${hidden ? `<button class="swimlane-stage-drilldown" type="button" data-swimlane-expand="cell" data-swimlane-stage-drilldown="${escapeAttr(stage.key)}" data-lane="${escapeAttr(lane.key)}" data-swimlane-stage="${escapeAttr(stage.key)}">
+          <span>+${hidden}</span>
+          <strong>${escapeHtml(t("swimlaneViewStage"))}</strong>
+        </button>` : ""}
+      </div>`;
+    }).join("")}
+  </div>`;
+}
+
+function taskSwimlanePagedCardList(cards, page) {
+  const total = cards.length;
+  const pageCount = Math.max(1, Math.ceil(total / swimlaneCellPageSize));
+  const safePage = Math.max(0, Math.min(pageCount - 1, Number(page) || 0));
+  const start = safePage * swimlaneCellPageSize;
+  const end = Math.min(total, start + swimlaneCellPageSize);
+  const visibleCards = cards.slice(start, end);
+  return `<div class="swimlane-paged-list">
+    <div class="swimlane-card-list">${visibleCards.map((card) => taskSwimlaneCard(card)).join("")}</div>
+    ${total > swimlaneCellPageSize ? `<div class="swimlane-pager" data-swimlane-page="${safePage}" aria-label="${escapeAttr(t("swimlanePageLabel"))}">
+      <button type="button" data-swimlane-page-action="prev" data-page="${safePage - 1}" ${safePage <= 0 ? "disabled" : ""}>${escapeHtml(t("swimlanePrevPage"))}</button>
+      <span>${start + 1}-${end} / ${total}</span>
+      <button type="button" data-swimlane-page-action="next" data-page="${safePage + 1}" ${safePage >= pageCount - 1 ? "disabled" : ""}>${escapeHtml(t("swimlaneNextPage"))}</button>
+    </div>` : ""}
+  </div>`;
+}
+
+function taskSwimlaneCard(card) {
+  const task = card.task;
+  const completion = clampCompletion(task.completion);
+  return `<article class="swimlane-card ${escapeAttr(card.stage)}" data-open-drawer="${escapeAttr(task.id)}" style="--row-accent: var(${stateToColorVar(task.state)}); --task-progress: ${completion}%">
+    <span class="swimlane-status-dot" aria-hidden="true"></span>
+    <strong>${escapeHtml(task.title)}</strong>
+    <span class="swimlane-progress" aria-label="${completion}%"><i></i></span>
+  </article>`;
+}
+
+function taskSwimlaneHeatLevel(count) {
+  if (count <= 0) return 0;
+  if (count <= 3) return 1;
+  if (count <= 7) return 2;
+  return 3;
+}
+
+function taskSwimlaneActiveExpansion(view) {
+  if (!swimlaneExpansion) return null;
+  const lane = view.lanes.find((candidate) => candidate.key === swimlaneExpansion.lane);
+  if (!lane) return null;
+  if (swimlaneExpansion.mode === "cell" && !view.stages.some((stage) => stage.key === swimlaneExpansion.stage)) return null;
+  if (swimlaneExpansion.mode !== "cell") return swimlaneExpansion;
+  const count = (lane.stageCards[swimlaneExpansion.stage] || []).length;
+  const pageCount = Math.max(1, Math.ceil(count / swimlaneCellPageSize));
+  const page = Math.max(0, Math.min(pageCount - 1, Number(swimlaneExpansion.page) || 0));
+  return { ...swimlaneExpansion, page };
+}
+
+let swimlaneExpansion = null;
+
+if (typeof window !== "undefined" && typeof document !== "undefined" && typeof document.addEventListener === "function" && !window.__HARNESS_SWIMLANE_BOUND__) {
+  window.__HARNESS_SWIMLANE_BOUND__ = true;
+  document.addEventListener("click", (event) => {
+    const collapse = event.target.closest?.("[data-swimlane-collapse]");
+    const pager = event.target.closest?.("[data-swimlane-page-action]");
+    const trigger = event.target.closest?.("[data-swimlane-expand]");
+    if (!collapse && !pager && !trigger) return;
+    event.preventDefault();
+    if (collapse) {
+      swimlaneExpansion = null;
+      app();
+      return;
+    }
+    if (pager && swimlaneExpansion?.mode === "cell") {
+      swimlaneExpansion = { ...swimlaneExpansion, page: Number(pager.dataset.page) || 0 };
+      app();
+      return;
+    }
+    const mode = trigger.dataset.swimlaneExpand;
+    const lane = trigger.dataset.lane;
+    const stage = trigger.dataset.swimlaneStage || "";
+    const same = swimlaneExpansion?.mode === mode && swimlaneExpansion?.lane === lane && (swimlaneExpansion?.stage || "") === stage;
+    swimlaneExpansion = same ? null : { mode, lane, stage, page: 0 };
+    app();
+  });
+}
+
 function taskDetail(route) {
   const taskId = route.id;
   const task = (bundle.status?.tasks || []).find((item) => item.id === taskId);
@@ -1024,26 +1442,41 @@ function reviewActionPanel(task, { mode = "summary" } = {}) {
   if (!isTaskInReviewQueue(task)) return "";
   const blocking = task.reviewStatus === "blocked-open-findings" || (task.risks || []).some((risk) => /^P[0-2]$/i.test(risk.severity || "") && (risk.open || risk.blocksRelease));
   const confirmed = task.reviewStatus === "confirmed";
+  const readyForCloseout = taskReadyForCloseout(task);
+  const hasLessonWork = taskHasPendingLessonWork(task);
   const candidateBlocked = task.budget !== "simple" && !task.lessonCandidateDecisionComplete;
   const candidateStatus = task.lessonCandidateStatus || "missing";
   if (mode !== "workspace") {
+    const summaryMessage = confirmed && hasLessonWork ? t("reviewConfirmedLessonPending") : confirmed && readyForCloseout ? t("reviewConfirmedCloseoutReady") : confirmed ? t("reviewAlreadyConfirmed") : t("reviewOpenInWorkspace");
     return `<section class="side-panel review-actions">
       <h3>${t("reviewActions")}</h3>
-      <p>${escapeHtml(confirmed ? t("reviewAlreadyConfirmed") : t("reviewOpenInWorkspace"))}</p>
+      <p>${escapeHtml(summaryMessage)}</p>
       <p>${escapeHtml(t("lessonCandidateStatus"))}: ${tag(candidateStatus)}</p>
       <a href="#/review/${encodeURIComponent(task.id)}">${t("openReviewWorkspace")}</a>
     </section>`;
   }
-  if (!canUseWorkbenchAction("review-complete")) {
+  if (confirmed) {
+    if (hasLessonWork) {
+      return `<section class="side-panel review-actions">
+        <h3>${t("reviewActions")}</h3>
+        <p>${escapeHtml(t("reviewConfirmedLessonPending"))}</p>
+        <p>${escapeHtml(t("lessonCandidateStatus"))}: ${tag(candidateStatus)}</p>
+        ${lessonCandidatePanel(task, { context: "detail", limit: 3 })}
+      </section>`;
+    }
+    const closeoutDisabled = !readyForCloseout || !canUseWorkbenchAction("task-complete");
     return `<section class="side-panel review-actions">
       <h3>${t("reviewActions")}</h3>
-      <p>${escapeHtml(t("staticReadOnlyDetail"))}</p>
+      <p>${escapeHtml(readyForCloseout ? t("reviewConfirmedCloseoutReady") : t("reviewAlreadyConfirmed"))}</p>
+      <p>${escapeHtml(t("lessonCandidateStatus"))}: ${tag(candidateStatus)}</p>
+      <button data-task-complete="${escapeAttr(task.id)}" ${closeoutDisabled ? "disabled" : ""}>${t("completeTaskCloseout")}</button>
+      <div class="review-result" data-task-complete-result="${escapeAttr(task.id)}"></div>
     </section>`;
   }
-  if (confirmed) {
+  if (!canUseWorkbenchAction("review-complete")) {
     return `<section class="side-panel review-actions">
       <h3>${t("reviewActions")}</h3>
-      <p>${escapeHtml(t("reviewAlreadyConfirmed"))}</p>
+      <p>${escapeHtml(t("staticReadOnlyDetail"))}</p>
     </section>`;
   }
   const missingWalkthrough = task.budget !== "simple" && !task.walkthroughPath;
@@ -1075,6 +1508,21 @@ function taskCanBeHumanConfirmed(task) {
   return task?.reviewQueueState === "ready-to-confirm" && Array.isArray(task?.taskQueues) && task.taskQueues.includes("review");
 }
 
+function taskHasPendingLessonWork(task) {
+  const queues = Array.isArray(task?.taskQueues) ? task.taskQueues : [];
+  const candidates = Array.isArray(task?.lessonCandidateRows) ? task.lessonCandidateRows : [];
+  return queues.includes("lessons")
+    || task?.lessonCandidateStatus === "needs-promotion"
+    || task?.lessonCandidatePromotionState === "queued"
+    || candidates.some((candidate) => ["ready-for-review", "needs-promotion"].includes(String(candidate?.status || "")));
+}
+
+function taskReadyForCloseout(task) {
+  if (!task || task.reviewStatus !== "confirmed" || task.closeoutStatus === "closed") return false;
+  if (taskHasPendingLessonWork(task)) return false;
+  return ["no-candidate-accepted", "promoted", "rejected"].includes(String(task.lessonCandidateStatus || ""));
+}
+
 function evidenceList(task) {
   const evidence = task.evidence || [];
   return `<section class="side-panel">
@@ -1083,63 +1531,279 @@ function evidenceList(task) {
   </section>`;
 }
 
+function dashboardModules() {
+  const structured = Array.isArray(bundle.modules) ? bundle.modules : [];
+  if (structured.length > 0) return structured;
+  const graphModules = (bundle.graph?.nodes || []).filter((node) => node.type === "module").map((node) => ({
+    key: String(node.id || "").replace(/^module:/, ""),
+    title: node.label,
+    status: node.state,
+    currentStep: node.currentStep,
+    source: "graph",
+    briefPath: node.briefPath,
+    modulePlanPath: node.modulePlanPath,
+  })).filter((module) => module.key);
+  return graphModules;
+}
+
+function moduleDefinition(key) {
+  return dashboardModules().find((module) => module.key === key) || null;
+}
+
+function taskModuleLabel(task) {
+  const key = taskModuleKey(task);
+  if (key === "base" || key === "legacy-unclassified") return taskModuleDisplayLabel(key);
+  return moduleDefinition(key)?.title || key;
+}
+
+function taskGroupContext(group, tasks) {
+  if (group.startsWith("module:")) {
+    const key = group.slice("module:".length);
+    const counts = moduleCountsForTasks(tasks);
+    if (key === "base") {
+      return {
+        eyebrow: t("baseModuleEyebrow"),
+        title: t("baseModule"),
+        summary: `${tasks.length} ${t("tasks")} · ${counts.active} ${t("active")} · ${counts.review} ${t("statReview")} · ${counts.blocked} ${t("statBlocked")}`,
+        chips: [`${tasks.length} ${t("tasks")}`, `${counts.risk} ${t("moduleRisks")}`],
+      };
+    }
+    if (key === "legacy-unclassified") {
+      return {
+        eyebrow: t("unclassifiedWarning"),
+        title: t("unclassifiedModule"),
+        summary: t("unclassifiedSummary").replace("{count}", String(tasks.length)),
+        chips: [`${tasks.length} ${t("tasks")}`, `${counts.risk} ${t("moduleRisks")}`],
+      };
+    }
+    const module = moduleDefinition(key) || { key, title: key, source: "inferred" };
+    const chips = [
+      module.status ? `${t("columnState")}: ${label(module.status)}` : "",
+      module.owner ? `${t("moduleOwner")}: ${module.owner}` : "",
+      module.currentStep ? `${t("moduleCurrentStep")}: ${module.currentStep}` : "",
+      module.dependsOn?.length ? `${t("moduleDependsOn")}: ${module.dependsOn.join(", ")}` : "",
+      module.scope?.length ? `${t("moduleScope")}: ${module.scope.join(", ")}` : "",
+    ].filter(Boolean);
+    return {
+      eyebrow: module.source === "registry" ? t("registeredModule") : t("inferredModule"),
+      title: module.title || key,
+      summary: `${tasks.length} ${t("tasks")} · ${counts.active} ${t("active")} · ${counts.review} ${t("statReview")} · ${counts.blocked} ${t("statBlocked")}`,
+      chips,
+    };
+  }
+  return {
+    eyebrow: t("groupBy"),
+    title: taskGroupLabel(group),
+    summary: `${tasks.length} ${t("tasks")}`,
+    chips: [],
+  };
+}
+
+function moduleCountsForTasks(tasks) {
+  return {
+    active: tasks.filter((task) => ["in_progress", "review", "blocked", "planned", "not_started"].includes(task.state)).length,
+    review: tasks.filter((task) => task.state === "review").length,
+    blocked: tasks.filter((task) => task.state === "blocked").length,
+    risk: tasks.filter(uiDashboardTaskHasRisk).length,
+  };
+}
+
 function modulesView(moduleId = "") {
-  const graph = bundle.graph || { nodes: [], edges: [] };
-  const explicitModules = (graph.nodes || []).filter((node) => node.type === "module");
-  const moduleMap = new Map(explicitModules.map((module) => [module.id.replace(/^module:/, ""), module]));
-  for (const task of bundle.status?.tasks || []) {
+  const modules = modulesWithTaskFallback();
+  const selectedKey = moduleId || state.selectedModuleKey || modules[0]?.key || "";
+  state.selectedModuleKey = selectedKey;
+  const selected = modules.find((module) => module.key === selectedKey) || modules[0] || null;
+  const unclassified = normalCycleTasks().filter((task) => taskModuleKey(task) === "legacy-unclassified");
+  return `<main class="stack module-console">
+    ${moduleRunStrip(modules, unclassified)}
+    <section class="module-console-grid">
+      <nav class="module-list-panel" aria-label="${escapeAttr(t("moduleView"))}">
+        ${modules.map((module) => moduleListItem(module, selected?.key === module.key)).join("") || emptyState(t("noModules"))}
+      </nav>
+      <article class="module-detail-panel">
+        ${selected ? moduleDetail(selected) : emptyState(t("noModules"))}
+      </article>
+    </section>
+    ${unclassified.length ? moduleUnclassifiedPanel(unclassified) : ""}
+  </main>`;
+}
+
+function modulesWithTaskFallback() {
+  const moduleMap = new Map(dashboardModules().map((module) => [module.key, {
+    ...module,
+    counts: emptyUiModuleCounts(),
+    tasks: [],
+  }]));
+  for (const task of normalCycleTasks()) {
     const key = taskModuleKey(task);
-    if (!moduleMap.has(key)) moduleMap.set(key, { id: `module:${key}`, type: "module", label: key, state: task.classificationSource || "inferred" });
+    if (key === "legacy-unclassified") continue;
+    if (!moduleMap.has(key)) {
+      moduleMap.set(key, {
+        key,
+        title: taskModuleDisplayLabel(key),
+        source: key === "base" ? "structure" : "inferred",
+        status: task.classificationSource || "inferred",
+        counts: emptyUiModuleCounts(),
+        tasks: [],
+      });
+    }
+    const module = moduleMap.get(key);
+    accumulateUiModuleTask(module, task);
+  }
+  return [...moduleMap.values()].sort((left, right) => {
+    const leftActive = Number(left.counts?.active || 0);
+    const rightActive = Number(right.counts?.active || 0);
+    if (leftActive !== rightActive) return rightActive - leftActive;
+    return left.key.localeCompare(right.key);
+  });
+}
+
+function emptyUiModuleCounts() {
+  return { total: 0, active: 0, review: 0, blocked: 0, risk: 0, missingDocs: 0 };
+}
+
+function accumulateUiModuleTask(module, task) {
+  if (!module || !task) return;
+  const stateValue = String(task.state || "unknown");
+  if (!module.tasks.some((item) => item.id === task.id)) module.tasks.push(task);
+  module.counts.total = (module.counts.total || 0) + 1;
+  if (["in_progress", "review", "blocked", "planned", "not_started"].includes(stateValue)) {
+    module.counts.active = (module.counts.active || 0) + 1;
+  }
+  if (stateValue !== "active") module.counts[stateValue] = (module.counts[stateValue] || 0) + 1;
+  if (uiDashboardTaskHasRisk(task)) {
+    module.counts.risk = (module.counts.risk || 0) + 1;
   }
-  const modules = [...moduleMap.values()];
-  return `<main class="stack">
-    <section class="module-grid">
-      ${modules.map((module) => moduleCard(module)).join("") || emptyState(t("noModules"))}
+  if (task.briefSource && task.briefSource !== "standalone") {
+    module.counts.missingDocs = (module.counts.missingDocs || 0) + 1;
+  }
+}
+
+function uiDashboardTaskHasRisk(task) {
+  if (task.state === "blocked") return true;
+  if (String(task.reviewStatus || "").includes("blocked")) return true;
+  if (Array.isArray(task.materialIssues) && task.materialIssues.length > 0) return true;
+  if (Array.isArray(task.queueReasons) && task.queueReasons.length > 0) return true;
+  if (String(task.visualMapStatus || "") === "missing") return true;
+  return false;
+}
+
+function moduleRunStrip(modules, unclassified) {
+  const active = modules.filter((module) => Number(module.counts?.active || 0) > 0).length;
+  const risk = modules.reduce((sum, module) => sum + Number(module.counts?.risk || 0), 0);
+  const registered = modules.filter((module) => module.source === "registry").length;
+  return `<section class="module-run-strip">
+    ${metric(t("moduleRegistered"), registered)}
+    ${metric(t("moduleActive"), active)}
+    ${metric(t("moduleRisks"), risk)}
+    ${metric(t("moduleUnclassified"), unclassified.length)}
+  </section>`;
+}
+
+function moduleListItem(module, active) {
+  const counts = module.counts || emptyUiModuleCounts();
+  return `<a class="module-list-item ${active ? "active" : ""}" href="#/modules/${encodeURIComponent(module.key)}" data-module-select="${escapeAttr(module.key)}">
+    <span>
+      <strong>${escapeHtml(module.key === "base" ? t("baseModule") : module.title || module.key)}</strong>
+      <small>${escapeHtml(module.key)} · ${escapeHtml(module.source || "registry")}</small>
+    </span>
+    <span class="module-list-counts">
+      <b>${Number(counts.active || 0)}</b>
+      ${tag(module.status || "planned")}
+    </span>
+  </a>`;
+}
+
+function moduleDetail(module) {
+  const tasks = normalCycleTasks().filter((task) => taskModuleKey(task) === module.key);
+  const activeTasks = tasks.filter((task) => ["in_progress", "review", "blocked", "planned", "not_started"].includes(task.state));
+  const riskTasks = tasks.filter((task) => task.state === "blocked" || String(task.reviewStatus || "").includes("blocked") || String(task.visualMapStatus || "") === "missing");
+  const brief = findDocument(module.briefPath || `TARGET:coding-agent-harness/planning/modules/${module.key}/brief.md`);
+  const plan = findDocument(module.modulePlanPath || "");
+  return `<div class="module-detail-stack">
+    <header class="module-detail-header">
+      <div>
+        <p class="eyebrow">${escapeHtml(module.key === "base" ? t("baseModuleEyebrow") : module.source === "registry" ? t("registeredModule") : t("inferredModule"))}</p>
+        <h2>${escapeHtml(module.key === "base" ? t("baseModule") : module.title || module.key)}</h2>
+        <p class="subtle">${escapeHtml(module.key)}${module.currentStep ? ` · ${escapeHtml(module.currentStep)}` : ""}</p>
+      </div>
+      ${tag(module.status || "planned")}
+    </header>
+    <div class="module-chip-row">
+      ${module.owner ? `<span class="module-chip">${t("moduleOwner")}: ${escapeHtml(module.owner)}</span>` : ""}
+      ${module.branch ? `<span class="module-chip">${t("moduleBranch")}: ${escapeHtml(module.branch)}</span>` : ""}
+      ${module.dependsOn?.length ? `<span class="module-chip">${t("moduleDependsOn")}: ${escapeHtml(module.dependsOn.join(", "))}</span>` : ""}
+    </div>
+    <section class="module-boundary-grid">
+      ${moduleBoundaryBlock(t("moduleScope"), module.scope)}
+      ${moduleBoundaryBlock(t("moduleShared"), module.shared)}
+      ${moduleBoundaryBlock(t("moduleDependsOn"), module.dependsOn)}
     </section>
-  </main>`;
+    <section class="module-work-panel">
+      <div class="section-head">
+        <div>
+          <h3>${t("moduleCurrentWork")}</h3>
+          <p class="subtle">${activeTasks.length} ${t("active")} · ${riskTasks.length} ${t("moduleRisks")}</p>
+        </div>
+        <a href="#/tasks">${t("openTaskIndex")}</a>
+      </div>
+      <div class="module-task-list">
+        ${activeTasks.slice(0, 10).map(moduleTaskRow).join("") || `<p>${t("noModuleTasks")}</p>`}
+      </div>
+    </section>
+    ${riskTasks.length ? `<section class="module-risk-panel">
+      <h3>${t("moduleRiskPanel")}</h3>
+      <div class="module-task-list">${riskTasks.slice(0, 8).map(moduleTaskRow).join("")}</div>
+    </section>` : ""}
+    <section class="module-doc-panel">
+      <h3>${t("sourceDocuments")}</h3>
+      <div class="module-doc-links">
+        ${moduleDocLink(t("brief"), module.briefPath, brief)}
+        ${moduleDocLink(t("taskPlan"), module.modulePlanPath, plan)}
+      </div>
+      <div class="markdown module-doc-preview">${brief ? window.HarnessMarkdown.render(brief.content, "rendered") : `<p>${t("moduleBriefMissing")}</p>`}</div>
+    </section>
+  </div>`;
+}
+
+function moduleBoundaryBlock(title, values) {
+  const items = Array.isArray(values) && values.length ? values : [t("none")];
+  return `<div class="module-boundary-block">
+    <strong>${escapeHtml(title)}</strong>
+    ${items.map((item) => `<span>${escapeHtml(item)}</span>`).join("")}
+  </div>`;
+}
+
+function moduleDocLink(labelText, pathValue, document) {
+  if (!pathValue && !document) return `<span class="module-doc-link missing">${escapeHtml(labelText)} · ${t("documentMissing")}</span>`;
+  return `<span class="module-doc-link">${escapeHtml(labelText)} · ${escapeHtml(pathValue || document.path || t("ready"))}</span>`;
 }
 
 function moduleTaskRow(task) {
   const dotClass = /fail|blocked|open/i.test(task.state) ? "state-fail" : /warn|advice|planned|missing|unknown/i.test(task.state) ? "state-warn" : "state-pass";
+  const lifecycle = [task.lifecycleState, task.reviewStatus, task.closeoutStatus].filter(Boolean).map((item) => label(item)).join(" · ");
   return `<a class="module-task-row" href="#/tasks/${encodeURIComponent(task.id)}" data-open-drawer="${escapeAttr(task.id)}">
     <div class="module-task-left">
       <i class="module-task-dot ${dotClass}" title="${escapeAttr(task.state)}"></i>
-      <span class="module-task-title">${escapeHtml(task.title)}</span>
+      <span class="module-task-title">${escapeHtml(task.title || task.id)}</span>
+      ${lifecycle ? `<small>${escapeHtml(lifecycle)}</small>` : ""}
     </div>
-    <span class="module-task-pct">${task.completion}%</span>
+    <span class="module-task-pct">${clampCompletion(task.completion)}%</span>
   </a>`;
 }
 
-function moduleCard(module) {
-  const moduleKey = module.id.replace(/^module:/, "");
-  const tasks = (bundle.status?.tasks || []).filter((task) => taskModuleKey(task) === moduleKey);
-
-  // Inline Pagination
-  state.modulePages = state.modulePages || {};
-  const currentPage = state.modulePages[moduleKey] || 1;
-  const pageCount = Math.ceil(tasks.length / 8) || 1;
-  const visibleTasks = tasks.slice((currentPage - 1) * 8, currentPage * 8);
-
-  const brief = findDocument(module.briefPath || `TARGET:coding-agent-harness/planning/modules/${moduleKey}/brief.md`);
-
-  let pagerHtml = "";
-  if (tasks.length > 8) {
-    pagerHtml = `<div class="module-pager">
-      <button ${currentPage <= 1 ? "disabled" : ""} onclick="window.setModulePage('${escapeAttr(moduleKey)}', ${currentPage - 1})">${t("prevPage")}</button>
-      <span>${currentPage} / ${pageCount}</span>
-      <button ${currentPage >= pageCount ? "disabled" : ""} onclick="window.setModulePage('${escapeAttr(moduleKey)}', ${currentPage + 1})">${t("nextPage")}</button>
-    </div>`;
-  }
-
-  return `<article class="module-card">
-    <div class="card-head"><h2>${escapeHtml(module.label || moduleKey)}</h2>${tag(module.state || "unknown")}</div>
-    <div class="markdown">${brief ? window.HarnessMarkdown.render(brief.content, "rendered") : `<p>${t("moduleBriefMissing")}</p>`}</div>
-    <h3>${t("moduleTasks")} · ${tasks.length}</h3>
-    <div class="module-task-list">
-      ${visibleTasks.map(moduleTaskRow).join("") || `<p>${t("noModuleTasks")}</p>`}
+function moduleUnclassifiedPanel(tasks) {
+  return `<section class="module-unclassified-panel">
+    <div class="section-head">
+      <div>
+        <p class="eyebrow">${t("unclassifiedWarning")}</p>
+        <h2>${t("unclassifiedModule")}</h2>
+        <p class="subtle">${t("unclassifiedSummary").replace("{count}", String(tasks.length))}</p>
+      </div>
+      <a href="#/tasks">${t("openTaskIndex")}</a>
     </div>
-    ${pagerHtml}
-  </article>`;
+    <div class="module-task-list">${tasks.slice(0, 12).map(moduleTaskRow).join("")}</div>
+  </section>`;
 }
 
 function reviewQueue() {
@@ -1150,6 +1814,10 @@ function reviewQueue() {
   const reasonOptions = reviewReasonOptions(baseTasks);
   normalizeReviewReasonFilter(reasonOptions);
   const tasks = reviewFilteredTasks(baseTasks);
+  const confirmableTasks = activeTab.id === "review" ? tasks.filter(taskCanBeHumanConfirmed) : [];
+  syncReviewBulkSelection(confirmableTasks);
+  if (activeTab.id === "lessons") syncLessonBulkSelection(lessonBulkActionableSelections());
+  else syncLessonBulkSelection([]);
   const pageCount = Math.max(1, Math.ceil(tasks.length / taskPageSize));
   const page = Math.min(Math.max(1, Number(state.reviewQueuePage) || 1), pageCount);
   const visibleTasks = tasks.slice((page - 1) * taskPageSize, page * taskPageSize);
@@ -1185,6 +1853,8 @@ function reviewQueue() {
             </select>
           </div>
         </div>
+        ${activeTab.id === "review" ? reviewBulkBar(confirmableTasks) : ""}
+        ${activeTab.id === "lessons" ? lessonBulkBar() : ""}
         <div class="review-queue-list-shell" tabindex="0" aria-label="${escapeAttr(activeTab.label)} ${escapeAttr(t("reviewQueue"))}">
           <div class="review-queue-list">
             ${visibleTasks.map((task) => reviewQueueCard(task, activeTab)).join("") || emptyState(t("noQueueTasks"))}
@@ -1251,7 +1921,7 @@ function reviewSortOptions() {
 }
 
 function reviewQueueBaseTasks(tab) {
-  return (bundle.status?.tasks || []).filter((task) => taskMatchesReviewTab(task, tab));
+  return normalCycleTasks().filter((task) => taskMatchesReviewTab(task, tab));
 }
 
 function taskMatchesReviewTab(task, tab) {
@@ -1327,17 +1997,57 @@ function reviewTruthyCount(tasks, key) {
   return tasks.filter((task) => task[key] === true).length;
 }
 
+function reviewBulkSelectedIds() {
+  return Object.entries(state.reviewBulkSelection || {})
+    .filter(([, selected]) => selected === true)
+    .map(([taskId]) => taskId);
+}
+
+function syncReviewBulkSelection(confirmableTasks) {
+  const allowed = new Set(confirmableTasks.map((task) => task.id));
+  for (const taskId of Object.keys(state.reviewBulkSelection || {})) {
+    if (!allowed.has(taskId)) delete state.reviewBulkSelection[taskId];
+  }
+}
+
+function reviewBulkBar(confirmableTasks) {
+  const selectedCount = reviewBulkSelectedIds().length;
+  const allSelected = confirmableTasks.length > 0 && confirmableTasks.every((task) => state.reviewBulkSelection?.[task.id] === true);
+  const disabled = selectedCount === 0 || !canUseWorkbenchAction("review-complete-bulk");
+  const result = state.reviewBulkResult ? `<span class="bulk-action-result ${state.reviewBulkResult.ok ? "success" : "failed"}">${escapeHtml(state.reviewBulkResult.message)}</span>` : "";
+  return `<div class="bulk-action-bar review-bulk-bar">
+    <label class="bulk-select-all">
+      <input type="checkbox" data-review-bulk-select-all ${allSelected ? "checked" : ""} ${confirmableTasks.length ? "" : "disabled"} aria-label="${escapeAttr(t("selectAllReviewTasks"))}">
+      <span>${t("selectAllReviewTasks")}</span>
+    </label>
+    <span class="bulk-selected-count">${formatMessage("reviewBulkSelected", { count: selectedCount })}</span>
+    <button type="button" data-review-bulk-confirm ${disabled ? "disabled" : ""}>${t("reviewBulkConfirm")}</button>
+    <button type="button" data-review-bulk-clear ${selectedCount ? "" : "disabled"}>${t("clearSelection")}</button>
+    ${result}
+  </div>`;
+}
+
 function reviewQueueCard(task, tab) {
   const openMaterial = (task.risks || []).filter((risk) => /^P[0-2]$/i.test(risk.severity || "") && (risk.open || risk.blocksRelease)).length;
   const reasons = task.queueReasons || [];
   const canCopyRepairPrompt = tab?.repair && String(task.repairPrompt || "").trim();
   const lessonActions = tab?.id === "lessons" ? lessonCandidatePanel(task, { context: "card", limit: 2 }) : "";
+  const closeoutAction = taskReadyForCloseout(task)
+    ? `<button data-task-complete="${escapeAttr(task.id)}" ${canUseWorkbenchAction("task-complete") ? "" : "disabled"}>${t("completeTaskCloseout")}</button><span class="inline-result" data-task-complete-result="${escapeAttr(task.id)}"></span>`
+    : "";
   const displayId = task.shortId || taskFolderName(task) || task.id;
+  const canBulkConfirm = tab?.id === "review" && taskCanBeHumanConfirmed(task);
+  const bulkSelected = state.reviewBulkSelection?.[task.id] === true;
+  const bulkControl = tab?.id === "review" ? `<label class="bulk-card-check">
+      <input type="checkbox" data-review-bulk-select="${escapeAttr(task.id)}" ${canBulkConfirm ? "" : "disabled"} ${bulkSelected ? "checked" : ""} aria-label="${escapeAttr(t("selectReviewTask"))}">
+      <span>${t("select")}</span>
+    </label>` : "";
   return `<article class="task-card review-queue-card" style="--row-accent: var(${stateToColorVar(task.state)})">
     <div class="card-header">
       <span class="card-id" title="${escapeAttr(task.id)}">${escapeHtml(displayId)}</span>
       ${tag(task.reviewStatus || "missing")}
       ${reviewTaskQueues(task).map(tag).join("")}
+      ${bulkControl}
     </div>
     <h4 class="card-title" title="${escapeAttr(task.title)}">${escapeHtml(task.title)}</h4>
     <div class="card-meta">
@@ -1348,23 +2058,39 @@ function reviewQueueCard(task, tab) {
       <span>${t("materialsReady")}: ${task.materialsReady === true ? t("yes") : t("no")}</span>
     </div>
     <p class="subtle">${escapeHtml(firstUsefulLine(task.summary || task.briefText || ""))}</p>
+    ${tombstoneSummary(task)}
     ${reasons.length ? `<div class="review-reasons">${reasons.slice(0, 4).map(reviewReason).join("")}</div>` : ""}
     ${lessonActions}
     <div class="review-queue-actions">
       <a href="#/review/${encodeURIComponent(task.id)}">${t("openReviewWorkspace")}</a>
       <a href="#/tasks/${encodeURIComponent(task.id)}">${t("fullView")}</a>
       <button data-open-drawer="${escapeAttr(task.id)}">${t("viewDetails")}</button>
+      ${closeoutAction}
       ${tab?.repair ? `<button data-copy-repair-prompt="${escapeAttr(task.id)}" data-repair-prompt="${escapeAttr(task.repairPrompt || "")}" ${canCopyRepairPrompt ? "" : "disabled"}>${t("copyRepairPrompt")}</button>` : ""}
     </div>
   </article>`;
 }
 
+function tombstoneSummary(task) {
+  const deletionState = String(task?.deletionState || "active");
+  if (deletionState === "active") return "";
+  const reason = String(task?.deleteReason || "").trim();
+  const supersededBy = String(task?.supersededBy || "").trim();
+  return `<div class="review-tombstone-summary">
+    <span>${tag(deletionState)}</span>
+    ${reason ? `<span>${t("reason")}: ${escapeHtml(reason)}</span>` : ""}
+    ${supersededBy ? `<a href="#/tasks/${encodeURIComponent(supersededBy)}">${escapeHtml(supersededBy)}</a>` : ""}
+  </div>`;
+}
+
 function lessonCandidatePanel(task, { context = "detail", limit = 0 } = {}) {
   const candidates = (task.lessonCandidateRows || []).filter((candidate) => ["ready-for-review", "needs-promotion"].includes(candidate.status));
   if (!candidates.length) return "";
   const visibleCandidates = limit > 0 ? candidates.slice(0, limit) : candidates;
   const hiddenCount = Math.max(0, candidates.length - visibleCandidates.length);
   const staticNote = canUseWorkbenchAction("lesson-sedimentation-task") ? "" : `<p class="lesson-action-note">${escapeHtml(t("lessonWorkbenchRequired"))}</p>`;
+  syncLessonBulkSelection(lessonBulkActionableSelections());
+  const bulkBar = context === "card" ? "" : lessonBulkBar();
   return `<section class="lesson-candidate-panel ${context === "card" ? "compact" : ""}">
     <div class="lesson-candidate-panel-head">
       <div>
@@ -1374,6 +2100,7 @@ function lessonCandidatePanel(task, { context = "detail", limit = 0 } = {}) {
       <span class="tag">${visibleCandidates.length}/${candidates.length}</span>
     </div>
     ${staticNote}
+    ${bulkBar}
     <div class="lesson-candidate-actions">
       ${visibleCandidates.map((candidate) => lessonCandidateAction(task, candidate)).join("")}
     </div>
@@ -1385,6 +2112,9 @@ function lessonCandidateAction(task, candidate) {
   const followUp = String(candidate.followUpTask || "").trim();
   const hasFollowUp = followUp && !/^pending$/i.test(followUp);
   const prompt = lessonSedimentationPrompt(task, candidate);
+  const selectionKey = lessonBulkSelectionKey(task.id, candidate.id);
+  const canBulkCreate = canUseWorkbenchAction("lesson-sedimentation-bulk") && !hasFollowUp;
+  const selected = state.lessonBulkSelection?.[selectionKey] === true;
   return `<div class="lesson-candidate-action">
     <div class="lesson-candidate-main">
       <strong>${escapeHtml(candidate.id)}</strong>
@@ -1393,6 +2123,10 @@ function lessonCandidateAction(task, candidate) {
     </div>
     <span class="review-result" data-lesson-result="${escapeAttr(task.id)}:${escapeAttr(candidate.id)}"></span>
     <div class="lesson-candidate-command-row">
+      <label class="bulk-card-check lesson-bulk-check">
+        <input type="checkbox" data-lesson-bulk-select="${escapeAttr(selectionKey)}" ${canBulkCreate ? "" : "disabled"} ${selected ? "checked" : ""} aria-label="${escapeAttr(t("selectLessonCandidate"))}">
+        <span>${t("select")}</span>
+      </label>
       ${hasFollowUp ? `<a href="#/tasks/${encodeURIComponent(followUp)}">${t("openFollowUpTask")}</a>` : ""}
       <button data-copy-lesson-prompt="${escapeAttr(task.id)}:${escapeAttr(candidate.id)}" data-lesson-prompt="${escapeAttr(prompt)}">${t("copyLessonPrompt")}</button>
       <button data-create-lesson-sedimentation="${escapeAttr(task.id)}" data-candidate-id="${escapeAttr(candidate.id)}" ${canUseWorkbenchAction("lesson-sedimentation-task") && !hasFollowUp ? "" : "disabled"}>${t("createLessonTask")}</button>
@@ -1400,6 +2134,62 @@ function lessonCandidateAction(task, candidate) {
   </div>`;
 }
 
+function lessonBulkSelectionKey(taskId, candidateId) {
+  return `${taskId}::${candidateId}`;
+}
+
+function parseLessonBulkSelectionKey(key) {
+  const separator = String(key || "").lastIndexOf("::");
+  if (separator < 0) return null;
+  const taskId = key.slice(0, separator);
+  const candidateId = key.slice(separator + 2);
+  if (!taskId || !candidateId) return null;
+  return { taskId, candidateId };
+}
+
+function lessonBulkSelectedSelections() {
+  return Object.entries(state.lessonBulkSelection || {})
+    .filter(([, selected]) => selected === true)
+    .map(([key]) => parseLessonBulkSelectionKey(key))
+    .filter(Boolean);
+}
+
+function lessonBulkActionableSelections() {
+  return (bundle.status?.tasks || []).flatMap((task) => (task.lessonCandidateRows || [])
+    .filter((candidate) => ["ready-for-review", "needs-promotion"].includes(candidate.status))
+    .filter((candidate) => {
+      const followUp = String(candidate.followUpTask || "").trim();
+      return !followUp || /^pending$/i.test(followUp);
+    })
+    .map((candidate) => ({ taskId: task.id, candidateId: candidate.id })));
+}
+
+function syncLessonBulkSelection(actionableSelections) {
+  const allowed = new Set(actionableSelections.map((selection) => lessonBulkSelectionKey(selection.taskId, selection.candidateId)));
+  for (const key of Object.keys(state.lessonBulkSelection || {})) {
+    if (!allowed.has(key)) delete state.lessonBulkSelection[key];
+  }
+}
+
+function lessonBulkBar() {
+  const actionableSelections = lessonBulkActionableSelections();
+  syncLessonBulkSelection(actionableSelections);
+  const selectedCount = lessonBulkSelectedSelections().length;
+  const allSelected = actionableSelections.length > 0 && actionableSelections.every((selection) => state.lessonBulkSelection?.[lessonBulkSelectionKey(selection.taskId, selection.candidateId)] === true);
+  const disabled = selectedCount === 0 || !canUseWorkbenchAction("lesson-sedimentation-bulk");
+  const result = state.lessonBulkResult ? `<span class="bulk-action-result ${state.lessonBulkResult.ok ? "success" : "failed"}">${escapeHtml(state.lessonBulkResult.message)}</span>` : "";
+  return `<div class="bulk-action-bar lesson-bulk-bar">
+    <label class="bulk-select-all">
+      <input type="checkbox" data-lesson-bulk-select-all ${allSelected ? "checked" : ""} ${actionableSelections.length ? "" : "disabled"} aria-label="${escapeAttr(t("selectAllLessonCandidates"))}">
+      <span>${t("selectAllLessonCandidates")}</span>
+    </label>
+    <span class="bulk-selected-count">${formatMessage("lessonBulkSelected", { count: selectedCount })}</span>
+    <button type="button" data-lesson-bulk-create ${disabled ? "disabled" : ""}>${t("lessonBulkCreate")}</button>
+    <button type="button" data-lesson-bulk-clear ${selectedCount ? "" : "disabled"}>${t("clearSelection")}</button>
+    ${result}
+  </div>`;
+}
+
 function lessonSedimentationPrompt(task, candidate) {
   return [
     "You are executing a lesson sedimentation follow-up task.",
@@ -2120,12 +2910,26 @@ window.setModulePage = function(moduleKey, page) {
   app();
 };
 
+function rerenderPreservingFieldFocus(field, selector) {
+  const shouldRestore = document.activeElement === field;
+  const selectionStart = typeof field.selectionStart === "number" ? field.selectionStart : null;
+  const selectionEnd = typeof field.selectionEnd === "number" ? field.selectionEnd : selectionStart;
+  app();
+  if (!shouldRestore) return;
+  const nextField = document.querySelector(selector);
+  if (!nextField || typeof nextField.focus !== "function") return;
+  nextField.focus({ preventScroll: true });
+  if (typeof nextField.setSelectionRange === "function" && selectionStart !== null) {
+    nextField.setSelectionRange(selectionStart, selectionEnd);
+  }
+}
+
 function bind() {
   document.querySelectorAll("[data-search]").forEach((input) => input.addEventListener("input", () => {
     state.query = input.value;
     state.taskPageByGroup = {};
     state.taskGroupPage = 1;
-    app();
+    rerenderPreservingFieldFocus(input, "[data-search]");
   }));
   document.querySelectorAll("[data-state-filter]").forEach((select) => select.addEventListener("change", () => {
     state.taskState = select.value;
@@ -2135,6 +2939,7 @@ function bind() {
   }));
   document.querySelectorAll("[data-group-mode]").forEach((select) => select.addEventListener("change", () => {
     state.taskGroupMode = select.value;
+    localStorage.setItem("harness.taskGroupMode", state.taskGroupMode);
     state.taskPageByGroup = {};
     state.taskGroupPage = 1;
     app();
@@ -2167,7 +2972,7 @@ function bind() {
   }));
   document.querySelectorAll("[data-preset-search]").forEach((input) => input.addEventListener("input", () => {
     state.presetQuery = input.value;
-    app();
+    rerenderPreservingFieldFocus(input, "[data-preset-search]");
   }));
   document.querySelectorAll("[data-preset-source-filter]").forEach((button) => button.addEventListener("click", () => {
     state.presetSourceFilter = button.dataset.presetSourceFilter || "all";
@@ -2230,6 +3035,9 @@ function bind() {
   document.querySelectorAll("[data-review-queue-tab]").forEach((button) => button.addEventListener("click", () => {
     state.reviewQueueTab = button.dataset.reviewQueueTab || "review";
     state.reviewQueuePage = 1;
+    state.reviewBulkSelection = {};
+    state.reviewBulkResult = null;
+    state.lessonBulkResult = null;
     app();
   }));
   document.querySelectorAll("[data-review-reason-filter]").forEach((select) => select.addEventListener("change", () => {
@@ -2242,6 +3050,51 @@ function bind() {
     state.reviewQueuePage = 1;
     app();
   }));
+  document.querySelectorAll("[data-review-bulk-select]").forEach((input) => input.addEventListener("change", () => {
+    state.reviewBulkSelection = state.reviewBulkSelection || {};
+    state.reviewBulkSelection[input.dataset.reviewBulkSelect || ""] = input.checked;
+    state.reviewBulkResult = null;
+    app();
+  }));
+  document.querySelectorAll("[data-review-bulk-select-all]").forEach((input) => input.addEventListener("change", () => {
+    const activeTab = reviewQueueTabs().find((tab) => tab.id === state.reviewQueueTab) || reviewQueueTabs()[0];
+    const tasks = activeTab.id === "review" ? reviewFilteredTasks(reviewQueueBaseTasks(activeTab)).filter(taskCanBeHumanConfirmed) : [];
+    state.reviewBulkSelection = state.reviewBulkSelection || {};
+    tasks.forEach((task) => {
+      if (input.checked) state.reviewBulkSelection[task.id] = true;
+      else delete state.reviewBulkSelection[task.id];
+    });
+    state.reviewBulkResult = null;
+    app();
+  }));
+  document.querySelectorAll("[data-review-bulk-clear]").forEach((button) => button.addEventListener("click", () => {
+    state.reviewBulkSelection = {};
+    state.reviewBulkResult = null;
+    app();
+  }));
+  document.querySelectorAll("[data-review-bulk-confirm]").forEach((button) => button.addEventListener("click", () => confirmSelectedReviewsFromDashboard(button)));
+  document.querySelectorAll("[data-lesson-bulk-select]").forEach((input) => input.addEventListener("change", () => {
+    state.lessonBulkSelection = state.lessonBulkSelection || {};
+    state.lessonBulkSelection[input.dataset.lessonBulkSelect || ""] = input.checked;
+    state.lessonBulkResult = null;
+    app();
+  }));
+  document.querySelectorAll("[data-lesson-bulk-select-all]").forEach((input) => input.addEventListener("change", () => {
+    state.lessonBulkSelection = state.lessonBulkSelection || {};
+    lessonBulkActionableSelections().forEach((selection) => {
+      const key = lessonBulkSelectionKey(selection.taskId, selection.candidateId);
+      if (input.checked) state.lessonBulkSelection[key] = true;
+      else delete state.lessonBulkSelection[key];
+    });
+    state.lessonBulkResult = null;
+    app();
+  }));
+  document.querySelectorAll("[data-lesson-bulk-clear]").forEach((button) => button.addEventListener("click", () => {
+    state.lessonBulkSelection = {};
+    state.lessonBulkResult = null;
+    app();
+  }));
+  document.querySelectorAll("[data-lesson-bulk-create]").forEach((button) => button.addEventListener("click", () => createSelectedLessonSedimentationFromDashboard(button)));
   document.querySelectorAll("[data-page-kind]").forEach((button) => button.addEventListener("click", () => {
     const page = Math.max(1, Number(button.dataset.page) || 1);
     if (button.dataset.pageKind === "warning") state.warningPage = page;
@@ -2282,6 +3135,7 @@ function bind() {
     openLessonDrawer(lessonId);
   }));
   document.querySelectorAll("[data-review-complete]").forEach((button) => button.addEventListener("click", () => completeReviewFromDashboard(button.dataset.reviewComplete)));
+  document.querySelectorAll("[data-task-complete]").forEach((button) => button.addEventListener("click", () => completeTaskFromDashboard(button.dataset.taskComplete)));
   const overlay = document.getElementById("drawer-overlay");
   if (overlay) overlay.addEventListener("click", closeDrawer);
 }
@@ -2356,6 +3210,90 @@ async function completeReviewFromDashboard(taskId) {
   }
 }
 
+async function completeTaskFromDashboard(taskId) {
+  const result = document.querySelector(`[data-task-complete-result="${CSS.escape(taskId)}"]`);
+  if (result) result.textContent = t("taskCloseoutSubmitting");
+  try {
+    const response = await fetch("/api/tasks/task-complete", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-harness-csrf": state.runtime?.csrfToken || "",
+      },
+      body: JSON.stringify({
+        taskId,
+        message: "closed from dashboard workbench",
+        evidence: "dashboard:task-complete",
+      }),
+    });
+    const payload = await response.json();
+    if (!response.ok) throw new Error(payload.error || t("taskCloseoutFailed"));
+    if (result) result.textContent = t("taskCloseoutSuccess");
+    setTimeout(() => window.location.reload(), 500);
+  } catch (error) {
+    if (result) result.textContent = `${t("taskCloseoutFailed")}: ${error.message}`;
+  }
+}
+
+function dashboardActionErrorDetail(error, fallback) {
+  const direct = error?.error || error?.message;
+  if (direct) return direct;
+  const failedResults = Array.isArray(error?.results) ? error.results.filter((result) => result?.ok === false) : [];
+  if (failedResults.length > 0) {
+    const reasons = [];
+    for (const result of failedResults) {
+      const reason = result?.error || result?.message;
+      if (reason && !reasons.includes(reason)) reasons.push(reason);
+    }
+    if (reasons.length > 0) {
+      return formatMessage("bulkActionFailedWithReason", {
+        failed: error?.failed || failedResults.length,
+        reason: reasons.slice(0, 3).join("; "),
+      });
+    }
+    return formatMessage("bulkActionFailedSummary", { failed: error?.failed || failedResults.length });
+  }
+  return String(error || fallback);
+}
+
+async function confirmSelectedReviewsFromDashboard(button) {
+  const taskIds = reviewBulkSelectedIds();
+  if (!taskIds.length) {
+    state.reviewBulkResult = { ok: false, message: t("reviewBulkNone") };
+    app();
+    return;
+  }
+  button.disabled = true;
+  state.reviewBulkResult = { ok: true, message: t("reviewBulkSubmitting") };
+  app();
+  try {
+    const response = await fetch("/api/tasks/review-complete-bulk", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-harness-csrf": state.runtime?.csrfToken || "",
+      },
+      body: JSON.stringify({
+        taskIds,
+        reviewer: "Human Reviewer",
+        message: "bulk confirmed from dashboard workbench",
+      }),
+    });
+    const payload = await response.json();
+    if (!response.ok) throw payload;
+    state.reviewBulkSelection = {};
+    state.reviewBulkResult = {
+      ok: payload.failed === 0,
+      message: payload.failed ? formatMessage("reviewBulkPartial", { confirmed: payload.confirmed || 0, failed: payload.failed || 0 }) : formatMessage("reviewBulkSuccess", { confirmed: payload.confirmed || 0 }),
+    };
+    app();
+    if ((payload.confirmed || 0) > 0) setTimeout(() => window.location.reload(), 1500);
+  } catch (error) {
+    state.reviewBulkResult = { ok: false, message: `${t("reviewCompleteFailed")}: ${dashboardActionErrorDetail(error, t("reviewCompleteFailed"))}` };
+    app();
+  }
+}
+
 async function runPresetAction(action, body) {
   state.presetActionResult = { ok: true, title: t("presetActionRunning"), message: action };
   app();
@@ -2454,6 +3392,7 @@ function openDrawer(taskId) {
   bindRepairPromptButtons(drawer);
   bindLessonSedimentationButtons(drawer);
   drawer.querySelectorAll("[data-review-complete]").forEach((button) => button.addEventListener("click", () => completeReviewFromDashboard(button.dataset.reviewComplete)));
+  drawer.querySelectorAll("[data-task-complete]").forEach((button) => button.addEventListener("click", () => completeTaskFromDashboard(button.dataset.taskComplete)));
 }
 
 function bindCopyTaskNameButtons(root) {
@@ -2572,6 +3511,40 @@ async function createLessonSedimentationFromDashboard(button) {
   }
 }
 
+async function createSelectedLessonSedimentationFromDashboard(button) {
+  const selections = lessonBulkSelectedSelections();
+  if (!selections.length) {
+    state.lessonBulkResult = { ok: false, message: t("lessonBulkNone") };
+    app();
+    return;
+  }
+  button.disabled = true;
+  state.lessonBulkResult = { ok: true, message: t("lessonBulkSubmitting") };
+  app();
+  try {
+    const response = await fetch("/api/tasks/lesson-sedimentation-bulk", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-harness-csrf": state.runtime?.csrfToken || "",
+      },
+      body: JSON.stringify({ selections }),
+    });
+    const payload = await response.json();
+    if (!response.ok) throw payload;
+    state.lessonBulkSelection = {};
+    state.lessonBulkResult = {
+      ok: payload.failed === 0,
+      message: payload.failed ? formatMessage("lessonBulkPartial", { created: payload.created || 0, failed: payload.failed || 0 }) : formatMessage("lessonBulkSuccess", { candidates: payload.candidates || selections.length }),
+    };
+    app();
+    if ((payload.created || 0) > 0) setTimeout(() => window.location.reload(), 1500);
+  } catch (error) {
+    state.lessonBulkResult = { ok: false, message: `${t("lessonTaskCreateFailed")}: ${error?.error || error?.message || String(error)}` };
+    app();
+  }
+}
+
 function lessonSedimentationSuccess(payload) {
   const followUp = payload?.followUpTask || {};
   const prompt = payload?.prompt || "";