coding-agent-harness 1.0.8 → 1.1.0

package/templates/dashboard/assets/app-src/40-modules.js

@@ -1,58 +1,274 @@
+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;
+  }
+  if (task.briefSource && task.briefSource !== "standalone") {
+    module.counts.missingDocs = (module.counts.missingDocs || 0) + 1;
   }
-  const modules = [...moduleMap.values()];
-  return `<main class="stack">
-    <section class="module-grid">
-      ${modules.map((module) => moduleCard(module)).join("") || emptyState(t("noModules"))}
+}
+
+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>`;
 }

package/templates/dashboard/assets/app-src/45-review.js

@@ -6,6 +6,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);
@@ -41,6 +45,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"))}
@@ -107,7 +113,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) {
@@ -183,17 +189,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">
@@ -204,23 +250,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>
@@ -230,6 +292,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>
@@ -241,6 +304,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>
@@ -249,6 +315,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>
@@ -256,6 +326,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.",