coding-agent-harness 1.0.2 → 1.0.5

package/templates/dashboard/assets/app-src/35-task-detail.js

@@ -0,0 +1,286 @@
+function taskDetail(route) {
+  const taskId = route.id;
+  const task = (bundle.status?.tasks || []).find((item) => item.id === taskId);
+  if (!task) return `<main>${emptyState(t("taskNotFound"))}</main>`;
+  return `<main class="task-detail">
+    <nav class="crumbs"><a href="#/tasks">${t("taskIndex")}</a><span>/</span><span>${escapeHtml(task.id)}</span></nav>
+    <section class="detail-hero">
+      <div>
+        <p class="eyebrow">${t("taskVisibility")}</p>
+        <h2>${escapeHtml(task.title)}</h2>
+        <p>${escapeHtml(task.path)}</p>
+        ${taskCopyButton(task, "detail-copy")}
+      </div>
+      <div class="detail-score">${task.completion}%</div>
+    </section>
+    ${taskStateSummary(task)}
+    ${phaseTimeline(task)}
+    <section class="detail-grid">
+      <article class="detail-main">
+        ${taskDocumentLibrary(task, route.doc)}
+      </article>
+      <aside class="detail-side">
+        ${reviewActionPanel(task, { mode: "summary" })}
+        ${lessonCandidatePanel(task, { context: "detail" })}
+        ${openFindings(task)}
+        ${evidenceList(task)}
+        ${documentTabs(task)}
+      </aside>
+    </section>
+  </main>`;
+}
+
+function taskStateSummary(task) {
+  return `<section class="task-state-summary">
+    <div>
+      <span>${t("legacyState")}</span>
+      ${tag(task.state)}
+    </div>
+    <div>
+      <span>${t("lifecycleState")}</span>
+      ${tag(task.lifecycleState || "unknown")}
+    </div>
+    <div>
+      <span>${t("reviewStatus")}</span>
+      ${tag(task.reviewStatus || "missing")}
+    </div>
+    <div>
+      <span>${t("sedimentationStatus")}</span>
+      ${tag(task.lessonCandidateStatus || "missing")}
+    </div>
+    <div>
+      <span>${t("closeoutStatus")}</span>
+      ${tag(task.closeoutStatus || "missing")}
+    </div>
+    <div>
+      <span>${t("lifecycleQueues")}</span>
+      ${(task.taskQueues || []).map(tag).join("") || tag("active")}
+    </div>
+    ${taskQueueReasonSummary(task)}
+  </section>`;
+}
+
+function taskQueueReasonSummary(task) {
+  const reasons = task.queueReasons || [];
+  if (!reasons.length) return "";
+  return `<div class="task-queue-reasons">
+    <span>${t("queueReasons")}</span>
+    <div class="review-reasons">
+      ${reasons.slice(0, 5).map(reviewReason).join("")}
+    </div>
+  </div>`;
+}
+
+function phaseTimeline(task) {
+  const knownKinds = new Set(["init", "execution", "gate"]);
+  const groups = [
+    ["init", "Init"],
+    ["execution", "Execution"],
+    ["gate", "Gate"],
+    ["other", "Other / Invalid"],
+  ];
+  const phases = task.phases || [];
+  const grouped = groups
+    .map(([kind, label]) => {
+      const items = kind === "other"
+        ? phases.filter((phase) => !knownKinds.has(phase.kind || "execution"))
+        : phases.filter((phase) => (phase.kind || "execution") === kind);
+      if (!items.length) return "";
+      return `<div class="phase-kind-group ${escapeAttr(kind)}">
+        <h3>${escapeHtml(label)}</h3>
+        ${items.map(phaseStep).join("")}
+      </div>`;
+    })
+    .join("");
+  return `<section class="phase-timeline">
+    <h2>${t("phaseTimeline")}</h2>
+    ${grouped || emptyState(t("noPhaseData"))}
+  </section>`;
+}
+
+function phaseStep(phase) {
+  const kind = phase.kind || "execution";
+  const actor = phase.actor || "agent";
+  const knownKind = ["init", "execution", "gate"].includes(kind);
+  const kindLabel = knownKind ? escapeHtml(kind) : `<span class="tag warn">${escapeHtml(kind)}</span>`;
+  const phaseKindClass = knownKind ? kind : "other";
+  return `<div class="phase-step ${escapeAttr(phase.state)} ${escapeAttr(phaseKindClass)}">
+    <div class="phase-step-head">
+      <strong>${escapeHtml(phase.id)}</strong>
+      <span>${kindLabel} · ${phase.completion}%</span>
+    </div>
+    <p>${escapeHtml(phase.output || phase.blockingRisk || phase.state)}</p>
+    ${progressBar(phase.completion)}
+    <div class="phase-meta">
+      ${phaseMetaTag(actor)}
+      ${tag(phase.evidenceStatus || "missing")}
+    </div>
+    ${phase.exitCommand ? `<code class="phase-exit-command">${escapeHtml(phase.exitCommand)}</code>` : ""}
+  </div>`;
+}
+
+function phaseMetaTag(value) {
+  return `<span class="tag">${escapeHtml(String(value || "unknown").replaceAll("_", " "))}</span>`;
+}
+
+function taskDocSection(task, fileName, title, required) {
+  const doc = taskDocument(task, fileName);
+  if (!doc && !required) return "";
+  return `<section class="doc-section">
+    <div class="section-head"><h2>${escapeHtml(title)}</h2>${doc ? `<button data-render-toggle>${state.renderMode === "rendered" ? t("source") : t("rendered")}</button>` : ""}</div>
+    <div class="markdown">${doc ? window.HarnessMarkdown.render(doc.content, state.renderMode) : generatedBrief(task)}</div>
+  </section>`;
+}
+
+function taskDocumentLibrary(task, selectedTab) {
+  const docs = orderedTaskDocuments(task);
+  if (!docs.length) return taskDocSection(task, "brief.md", t("brief"), true);
+  const selectedKey = docs.some((doc) => doc.key === selectedTab) ? selectedTab : defaultTaskDocumentKey(task, docs);
+  return `<section class="doc-library">
+    <div class="section-head">
+      <div>
+        <p class="eyebrow">${t("taskDocuments")}</p>
+        <h2>${escapeHtml(t("sourceDocuments"))}</h2>
+      </div>
+      <button data-render-toggle>${state.renderMode === "rendered" ? t("source") : t("rendered")}</button>
+    </div>
+    <div class="doc-accordion-list">
+      ${docs.map((item) => documentAccordion(item, item.key === selectedKey)).join("")}
+    </div>
+  </section>`;
+}
+
+function orderedTaskDocuments(task) {
+  const docs = taskDocTabs
+    .map(([key, file]) => {
+      const doc = taskDocument(task, file);
+      if (doc) return { key, file, title: t(key), path: doc.path, content: doc.content };
+      if (key === "brief") return { key, file, title: t(key), path: `${task.path}/brief.md`, content: generatedBrief(task), generated: true };
+      return null;
+    })
+    .filter(Boolean);
+  const priority = taskDocumentPriority(task);
+  const rank = new Map(priority.map((key, index) => [key, index]));
+  return docs.sort((a, b) => (rank.get(a.key) ?? 99) - (rank.get(b.key) ?? 99));
+}
+
+function taskDocumentPriority(task) {
+  const stateName = task?.state || "";
+  const lifecycle = task?.lifecycleState || "";
+  if (stateName === "review" || ["in_review", "review-blocked"].includes(lifecycle)) {
+    return ["walkthrough", "lessonCandidates", "review", "findings", "visualMap", "progress", "brief", "taskPlan", "strategy", "longRunningContract", "legacyRoadmap", "references", "artifacts"];
+  }
+  if (stateName === "in_progress" || lifecycle === "active" || stateName === "blocked") {
+    return ["progress", "visualMap", "brief", "taskPlan", "strategy", "findings", "review", "walkthrough", "references", "artifacts", "legacyRoadmap"];
+  }
+  if (stateName === "done" || ["closing", "closed"].includes(lifecycle)) {
+    return ["walkthrough", "progress", "review", "findings", "visualMap", "brief", "taskPlan", "strategy", "references", "artifacts", "legacyRoadmap"];
+  }
+  return ["brief", "taskPlan", "visualMap", "strategy", "progress", "findings", "review", "walkthrough", "references", "artifacts", "legacyRoadmap"];
+}
+
+function defaultTaskDocumentKey(task, docs) {
+  const priority = taskDocumentPriority(task);
+  return priority.find((key) => docs.some((doc) => doc.key === key)) || docs[0]?.key || "brief";
+}
+
+function documentAccordion(item, open) {
+  return `<details class="doc-accordion" ${open ? "open" : ""}>
+    <summary>
+      <span>${escapeHtml(item.title)}</span>
+      <small>${escapeHtml(item.generated ? t("generatedFallback") : item.path)}</small>
+    </summary>
+    <div class="markdown">${window.HarnessMarkdown.render(item.content, state.renderMode)}</div>
+  </details>`;
+}
+
+function documentTabs(task) {
+  const docs = orderedTaskDocuments(task);
+  return `<section class="side-panel">
+    <h3>${t("sourceDocuments")}</h3>
+    ${docs.map((doc) => `<a href="#/tasks/${encodeURIComponent(task.id)}/docs/${encodeURIComponent(doc.key)}" title="${escapeAttr(doc.path)}">${escapeHtml(doc.title)}</a>`).join("") || `<p>${t("noDocuments")}</p>`}
+  </section>`;
+}
+
+function selectedSourceDocument(task, tab) {
+  if (!tab) return "";
+  const match = taskDocTabs.find(([key]) => key === tab);
+  if (!match) return "";
+  const doc = taskDocument(task, match[1]);
+  if (!doc) return "";
+  return `<section class="doc-section selected-source">
+    <div class="section-head"><h2>${t("selectedSource")} · ${t(match[0])}</h2><button data-render-toggle>${state.renderMode === "rendered" ? t("source") : t("rendered")}</button></div>
+    <div class="markdown">${window.HarnessMarkdown.render(doc.content, state.renderMode)}</div>
+  </section>`;
+}
+
+function openFindings(task) {
+  const risks = task.risks || [];
+  return `<section class="side-panel">
+    <h3>${t("openFindings")}</h3>
+    ${risks.map((risk) => `<div class="finding ${risk.open || risk.blocksRelease ? "open" : ""}"><strong>${escapeHtml(risk.severity)}</strong><span>${escapeHtml(risk.summary)}</span></div>`).join("") || `<p>${t("noOpenFindings")}</p>`}
+  </section>`;
+}
+
+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 candidateBlocked = task.budget !== "simple" && !task.lessonCandidateDecisionComplete;
+  const candidateStatus = task.lessonCandidateStatus || "missing";
+  if (mode !== "workspace") {
+    return `<section class="side-panel review-actions">
+      <h3>${t("reviewActions")}</h3>
+      <p>${escapeHtml(confirmed ? t("reviewAlreadyConfirmed") : t("reviewOpenInWorkspace"))}</p>
+      <p>${escapeHtml(t("lessonCandidateStatus"))}: ${tag(candidateStatus)}</p>
+      <a href="#/review/${encodeURIComponent(task.id)}">${t("openReviewWorkspace")}</a>
+    </section>`;
+  }
+  if (!canUseWorkbenchAction("review-complete")) {
+    return `<section class="side-panel review-actions">
+      <h3>${t("reviewActions")}</h3>
+      <p>${escapeHtml(t("staticReadOnlyDetail"))}</p>
+    </section>`;
+  }
+  if (confirmed) {
+    return `<section class="side-panel review-actions">
+      <h3>${t("reviewActions")}</h3>
+      <p>${escapeHtml(t("reviewAlreadyConfirmed"))}</p>
+    </section>`;
+  }
+  const missingWalkthrough = task.budget !== "simple" && !task.walkthroughPath;
+  const queueBlocked = !taskCanBeHumanConfirmed(task);
+  const disabled = blocking || missingWalkthrough || candidateBlocked || queueBlocked;
+  const message = missingWalkthrough ? t("reviewWalkthroughRequired") : blocking ? t("reviewBlocked") : candidateBlocked ? t("reviewCandidateDecisionRequired") : queueBlocked ? t("reviewQueueRequired") : t("reviewWorkbenchReady");
+  return `<section class="side-panel review-actions">
+    <h3>${t("reviewActions")}</h3>
+    <p>${escapeHtml(message)}</p>
+    <p>${escapeHtml(t("lessonCandidateStatus"))}: ${tag(candidateStatus)}</p>
+    <label class="review-check">
+      <input type="checkbox" data-review-confirm-check="${escapeAttr(task.id)}" ${disabled ? "disabled" : ""}>
+      <span>${t("reviewConfirmChecklist")}</span>
+    </label>
+    <div class="review-confirm-copy">
+      ${taskCopyButton(task, "review-copy-task-name")}
+    </div>
+    <input data-review-confirm-text="${escapeAttr(task.id)}" value="" placeholder="${escapeAttr(task.shortId || task.id)}" ${disabled ? "disabled" : ""}>
+    <button data-review-complete="${escapeAttr(task.id)}" ${disabled ? "disabled" : ""}>${t("confirmReviewComplete")}</button>
+    <div class="review-result" data-review-result="${escapeAttr(task.id)}"></div>
+  </section>`;
+}
+
+function isTaskInReviewQueue(task) {
+  return (task?.reviewQueueState || "not-in-queue") !== "not-in-queue";
+}
+
+function taskCanBeHumanConfirmed(task) {
+  return task?.reviewQueueState === "ready-to-confirm" && Array.isArray(task?.taskQueues) && task.taskQueues.includes("review");
+}
+
+function evidenceList(task) {
+  const evidence = task.evidence || [];
+  return `<section class="side-panel">
+    <h3>${t("evidence")}</h3>
+    ${evidence.map((item) => `<p><strong>${escapeHtml(item.type || "evidence")}</strong> ${escapeHtml(item.summary || "")}</p>`).join("") || `<p>${t("noEvidence")}</p>`}
+  </section>`;
+}

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

@@ -1,8 +1,14 @@
 function reviewQueue() {
-  const tasks = reviewQueueTasks();
-  const ready = tasks.filter((task) => task.reviewStatus !== "blocked-open-findings" && task.reviewStatus !== "confirmed").length;
-  const blocked = tasks.filter((task) => task.reviewStatus === "blocked-open-findings").length;
-  const confirmed = tasks.filter((task) => task.reviewStatus === "confirmed").length;
+  ensureReviewQueueState();
+  const tabs = reviewQueueTabs();
+  const activeTab = tabs.find((tab) => tab.id === state.reviewQueueTab) || tabs[0];
+  const baseTasks = reviewQueueBaseTasks(activeTab);
+  const reasonOptions = reviewReasonOptions(baseTasks);
+  normalizeReviewReasonFilter(reasonOptions);
+  const tasks = reviewFilteredTasks(baseTasks);
+  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);
   return `<div class="dashboard-grid review-queue-page">
     <main class="dashboard-main stack">
       <section class="flow-panel">
@@ -12,10 +18,36 @@ function reviewQueue() {
             <h2>${t("reviewQueue")}</h2>
             <p class="subtle">${t("reviewQueueSubtitle")}</p>
           </div>
-          <span class="subtle">${ready}/${tasks.length} ${t("reviewReady")}</span>
+          <span class="subtle">${t("showing")} ${visibleTasks.length ? (page - 1) * taskPageSize + 1 : 0}-${Math.min(page * taskPageSize, tasks.length)} / ${tasks.length}</span>
         </div>
-        <div class="task-card-grid review-queue-grid">
-          ${tasks.map(reviewQueueCard).join("") || emptyState(t("noReviewTasks"))}
+        <div class="review-queue-tabs" role="tablist" aria-label="${escapeAttr(t("reviewQueueTabs"))}">
+          ${tabs.map((tab) => reviewQueueTab(tab)).join("")}
+        </div>
+        <div class="review-queue-toolbar">
+          <div class="input-group">
+            <input data-search value="${escapeAttr(state.query)}" placeholder="${t("searchPlaceholder")}" aria-label="${t("searchTasks")}">
+          </div>
+          <div class="select-group">
+            <label>${t("reasonFilter")}</label>
+            <select data-review-reason-filter aria-label="${t("reasonFilter")}">
+              <option value="all" ${state.reviewReasonFilter === "all" ? "selected" : ""}>${t("allReasons")}</option>
+              ${reasonOptions.map((code) => `<option value="${escapeAttr(code)}" ${state.reviewReasonFilter === code ? "selected" : ""}>${escapeHtml(code)}</option>`).join("")}
+            </select>
+          </div>
+          <div class="select-group">
+            <label>${t("sortBy")}</label>
+            <select data-review-sort aria-label="${t("sortBy")}">
+              ${reviewSortOptions().map((option) => `<option value="${option.id}" ${state.reviewSort === option.id ? "selected" : ""}>${option.label}</option>`).join("")}
+            </select>
+          </div>
+        </div>
+        <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"))}
+          </div>
+        </div>
+        <div class="review-queue-pager">
+          ${pager("review", page, pageCount)}
         </div>
       </section>
     </main>
@@ -23,52 +55,239 @@ function reviewQueue() {
       <section class="side-panel review-queue-summary">
         <h3>${t("reviewQueue")}</h3>
         <div class="review-queue-stats">
-          ${metric(t("reviewReady"), ready)}
-          ${metric(t("reviewBlockedQueue"), blocked)}
-          ${metric(t("reviewConfirmedQueue"), confirmed)}
+          ${tabs.map((tab) => metric(tab.label, reviewQueueBaseTasks(tab).length)).join("")}
         </div>
       </section>
       <section class="side-panel">
-        <h3>${t("review")}</h3>
-        <p>${escapeHtml(t("reviewQueueSubtitle"))}</p>
+        <h3>${escapeHtml(activeTab.label)}</h3>
+        <p>${escapeHtml(activeTab.description)}</p>
+        <dl class="review-queue-contract">
+          <div><dt>${t("reviewSubmitted")}</dt><dd>${reviewTruthyCount(baseTasks, "reviewSubmitted")}/${baseTasks.length}</dd></div>
+          <div><dt>${t("materialsReady")}</dt><dd>${reviewTruthyCount(baseTasks, "materialsReady")}/${baseTasks.length}</dd></div>
+        </dl>
       </section>
     </aside>
   </div>`;
 }
 
-function reviewQueueTasks() {
-  return (bundle.status?.tasks || [])
-    .filter(isTaskInReviewStage)
-    .sort((left, right) => reviewSortKey(left).localeCompare(reviewSortKey(right)));
+function ensureReviewQueueState() {
+  if (!state.reviewQueueTab) state.reviewQueueTab = "review";
+  if (!state.reviewReasonFilter) state.reviewReasonFilter = "all";
+  if (!state.reviewSort) state.reviewSort = "queue";
+  if (!state.reviewQueuePage) state.reviewQueuePage = 1;
+}
+
+function reviewQueueTabs() {
+  return [
+    { id: "review", queues: ["review"], label: t("queueReview"), description: t("queueReviewDesc") },
+    { id: "missing-materials", queues: ["missing-materials"], label: t("queueMissingMaterials"), description: t("queueMissingMaterialsDesc"), repair: true },
+    { id: "blocked", queues: ["blocked"], label: t("queueBlocked"), description: t("queueBlockedDesc"), repair: true },
+    { id: "lessons", queues: ["lessons"], label: t("queueLessons"), description: t("queueLessonsDesc") },
+    { id: "confirmed-finalized", queues: ["confirmed", "finalized", "confirmed-finalized", "confirmed-finalization-pending"], label: t("queueConfirmedFinalized"), description: t("queueConfirmedFinalizedDesc") },
+    { id: "soft-deleted-superseded", queues: ["soft-deleted-superseded"], label: t("queueSoftDeletedSuperseded"), description: t("queueSoftDeletedSupersededDesc") },
+  ];
+}
+
+function reviewQueueTab(tab) {
+  const active = tab.id === state.reviewQueueTab;
+  const count = reviewQueueBaseTasks(tab).length;
+  return `<button type="button" class="review-queue-tab ${active ? "active" : ""}" data-review-queue-tab="${escapeAttr(tab.id)}" role="tab" aria-selected="${active ? "true" : "false"}">
+    <span>${escapeHtml(tab.label)}</span>
+    <strong>${count}</strong>
+  </button>`;
+}
+
+function reviewSortOptions() {
+  return [
+    { id: "queue", label: t("sortQueuePriority") },
+    { id: "newest", label: t("sortNewest") },
+    { id: "oldest", label: t("sortOldest") },
+    { id: "id", label: t("sortTaskId") },
+  ];
+}
+
+function reviewQueueBaseTasks(tab) {
+  return (bundle.status?.tasks || []).filter((task) => taskMatchesReviewTab(task, tab));
+}
+
+function taskMatchesReviewTab(task, tab) {
+  const queues = reviewTaskQueues(task);
+  return (tab.queues || []).some((queue) => queues.includes(queue));
+}
+
+function reviewTaskQueues(task) {
+  return Array.isArray(task?.taskQueues) ? task.taskQueues : Array.isArray(task?.queues) ? task.queues : [];
+}
+
+function reviewReasonOptions(tasks) {
+  return [...new Set(tasks.flatMap((task) => (task.queueReasons || []).map((reason) => reason.code || reason.queue || "").filter(Boolean)))].sort();
+}
+
+function normalizeReviewReasonFilter(reasonOptions) {
+  const current = state.reviewReasonFilter || "all";
+  if (current === "all") return;
+  if (!reasonOptions.includes(current)) state.reviewReasonFilter = "all";
+}
+
+function reviewFilteredTasks(tasks) {
+  const query = state.query.trim().toLowerCase();
+  const reasonFilter = state.reviewReasonFilter || "all";
+  return [...tasks]
+    .filter((task) => {
+      if (reasonFilter !== "all" && !(task.queueReasons || []).some((reason) => (reason.code || reason.queue) === reasonFilter)) return false;
+      if (!query) return true;
+      return [
+        task.id,
+        task.shortId,
+        task.title,
+        task.module,
+        task.inferredModule,
+        task.state,
+        task.lifecycleState,
+        task.reviewStatus,
+        task.closeoutStatus,
+        ...(task.taskQueues || []),
+        ...(task.queueReasons || []).flatMap((reason) => [reason.code, reason.message, reason.sourcePath]),
+      ].some((value) => String(value || "").toLowerCase().includes(query));
+    })
+    .sort(reviewTaskSort);
+}
+
+function reviewTaskSort(left, right) {
+  if (state.reviewSort === "newest") return compareTasksByTimeForOrder(left, right, "desc");
+  if (state.reviewSort === "oldest") return compareTasksByTimeForOrder(left, right, "asc");
+  if (state.reviewSort === "id") return stableTaskLabel(left).localeCompare(stableTaskLabel(right));
+  return reviewPriorityRank(left) - reviewPriorityRank(right)
+    || compareTasksByTimeForOrder(left, right, "desc")
+    || stableTaskLabel(left).localeCompare(stableTaskLabel(right));
+}
+
+function compareTasksByTimeForOrder(left, right, order) {
+  const previous = state.taskSortOrder;
+  state.taskSortOrder = order;
+  const result = compareTasksByTime(left, right);
+  state.taskSortOrder = previous;
+  return result;
+}
+
+function reviewPriorityRank(task) {
+  const severityRank = { P0: 0, P1: 1, P2: 2, P3: 3 };
+  const reasonRank = Math.min(...(task.queueReasons || []).map((reason) => severityRank[String(reason.severity || "").toUpperCase()] ?? 8), 8);
+  const queueRank = { blocked: 0, "missing-materials": 1, review: 2, lessons: 3, confirmed: 4, finalized: 5, "soft-deleted-superseded": 6 };
+  const queues = reviewTaskQueues(task);
+  const taskQueueRank = Math.min(...queues.map((queue) => queueRank[queue] ?? 7), 7);
+  return Math.min(reasonRank, taskQueueRank);
 }
 
-function reviewSortKey(task) {
-  const rank = task.reviewStatus === "blocked-open-findings" ? "0" : task.reviewStatus === "confirmed" ? "2" : "1";
-  return `${rank}:${task.id}`;
+function reviewTruthyCount(tasks, key) {
+  return tasks.filter((task) => task[key] === true).length;
 }
 
-function reviewQueueCard(task) {
+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 displayId = task.shortId || taskFolderName(task) || task.id;
   return `<article class="task-card review-queue-card" style="--row-accent: var(${stateToColorVar(task.state)})">
     <div class="card-header">
-      <span class="card-id">${escapeHtml(task.id)}</span>
+      <span class="card-id" title="${escapeAttr(task.id)}">${escapeHtml(displayId)}</span>
       ${tag(task.reviewStatus || "missing")}
+      ${reviewTaskQueues(task).map(tag).join("")}
     </div>
     <h4 class="card-title" title="${escapeAttr(task.title)}">${escapeHtml(task.title)}</h4>
     <div class="card-meta">
       <span>${tag(task.lifecycleState || "unknown")}</span>
       <span>${tag(task.closeoutStatus || "missing")}</span>
       <span>${openMaterial} ${t("openFindings")}</span>
+      <span>${t("reviewSubmitted")}: ${task.reviewSubmitted === true ? t("yes") : t("no")}</span>
+      <span>${t("materialsReady")}: ${task.materialsReady === true ? t("yes") : t("no")}</span>
     </div>
     <p class="subtle">${escapeHtml(firstUsefulLine(task.summary || task.briefText || ""))}</p>
+    ${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>
+      ${tab?.repair ? `<button data-copy-repair-prompt="${escapeAttr(task.id)}" data-repair-prompt="${escapeAttr(task.repairPrompt || "")}" ${canCopyRepairPrompt ? "" : "disabled"}>${t("copyRepairPrompt")}</button>` : ""}
     </div>
   </article>`;
 }
 
+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>`;
+  return `<section class="lesson-candidate-panel ${context === "card" ? "compact" : ""}">
+    <div class="lesson-candidate-panel-head">
+      <div>
+        <p class="eyebrow">${t("lessonCandidates")}</p>
+        <h3>${t("lessonSedimentationActions")}</h3>
+      </div>
+      <span class="tag">${visibleCandidates.length}/${candidates.length}</span>
+    </div>
+    ${staticNote}
+    <div class="lesson-candidate-actions">
+      ${visibleCandidates.map((candidate) => lessonCandidateAction(task, candidate)).join("")}
+    </div>
+    ${hiddenCount ? `<a class="lesson-candidate-more" href="#/review/${encodeURIComponent(task.id)}">${escapeHtml(t("moreLessonCandidates")).replace("{count}", String(hiddenCount))}</a>` : ""}
+  </section>`;
+}
+
+function lessonCandidateAction(task, candidate) {
+  const followUp = String(candidate.followUpTask || "").trim();
+  const hasFollowUp = followUp && !/^pending$/i.test(followUp);
+  const prompt = lessonSedimentationPrompt(task, candidate);
+  return `<div class="lesson-candidate-action">
+    <div class="lesson-candidate-main">
+      <strong>${escapeHtml(candidate.id)}</strong>
+      <span>${escapeHtml(candidate.title || candidate.promotionTarget || t("lessonCandidates"))}</span>
+      <small>${escapeHtml(candidate.scope || t("none"))} · ${escapeHtml(candidate.promotionTarget || t("none"))}</small>
+    </div>
+    <span class="review-result" data-lesson-result="${escapeAttr(task.id)}:${escapeAttr(candidate.id)}"></span>
+    <div class="lesson-candidate-command-row">
+      ${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>
+    </div>
+  </div>`;
+}
+
+function lessonSedimentationPrompt(task, candidate) {
+  return [
+    "You are executing a lesson sedimentation follow-up task.",
+    "",
+    `Source task: ${task.id}`,
+    `Source candidate: ${candidate.id} - ${candidate.title || ""}`,
+    `Candidate scope: ${candidate.scope || "unspecified"}`,
+    `Candidate module key: ${candidate.moduleKey || "n/a"}`,
+    `Detail artifact: ${candidate.detailArtifact || "not provided"}`,
+    `Boundary reason: ${candidate.boundaryReason || "unspecified"}`,
+    `Why it might matter: ${candidate.whyItMightMatter || "unspecified"}`,
+    `Promotion target: ${candidate.promotionTarget || "unspecified"}`,
+    `Conflict check: ${candidate.conflictCheck || "pending"}`,
+    `Required standard update: ${candidate.requiredStandardUpdate || "pending"}`,
+    "",
+    "Instructions:",
+    "1. Read the source task, review, findings, progress, lesson_candidates.md, and the task-local detail artifact.",
+    "2. Use the detail artifact as the lesson body source; do not reconstruct the lesson from the brief row.",
+    "3. Classify whether the lesson is task-local, module-local, or global, preserving the module key and source path when present.",
+    "4. Check conflicts against existing lessons and standards.",
+    "5. Propose the smallest diff first.",
+    "6. Do not write a shared Lessons table; use task-local candidates and promoted detail docs.",
+  ].join("\n");
+}
+
+function reviewReason(reason) {
+  return `<div class="review-reason">
+    <strong>${escapeHtml(reason.code || reason.queue || t("reason"))}</strong>
+    <span>${escapeHtml(reason.message || reason.sourcePath || "")}</span>
+  </div>`;
+}
+
 function firstUsefulLine(text) {
   return String(text || "")
     .split(/\n+/)
@@ -123,6 +342,6 @@ function reviewDocPanel(key, doc, fallbackPath = "") {
       </div>
       ${doc ? `<button data-render-toggle>${state.renderMode === "rendered" ? t("source") : t("rendered")}</button>` : ""}
     </div>
-    <div class="markdown">${doc ? window.HarnessMarkdown.render(doc.content, state.renderMode) : emptyState(t("documentMissing"))}</div>
+    <div class="review-doc-scroll"><div class="markdown">${doc ? window.HarnessMarkdown.render(doc.content, state.renderMode) : emptyState(t("documentMissing"))}</div></div>
   </section>`;
 }

package/templates/dashboard/assets/app-src/50-migration.js

@@ -138,25 +138,39 @@ function pager(kind, page, pageCount, group = "") {
 }
 
 function lessonPanel() {
-  const lessons = (bundle.tables?.tables || [])
-    .filter((table) => table.kind === "lessons-ssot")
-    .flatMap((table) => table.rows);
+  const lessons = lessonDocuments();
   return `<section class="lesson-panel">
     <div class="section-head"><h2>${t("lessons")}</h2><span>${lessons.length}</span></div>
     <div class="lesson-list" style="padding-top: 10px;">
-      ${lessons.map((row) => {
-        const cells = row.cells || {};
-        const lessonId = cells.ID || cells.Lesson || cells["Lesson ID"] || cells["ID"] || "";
-        const summary = cells.Summary || cells["\u6458\u8981"] || cells.Pattern || cells.Status || "";
-        return `<div class="lesson" data-open-lesson-drawer="${escapeAttr(lessonId)}">
-          <strong>${escapeHtml(lessonId)}</strong>
-          <p>${escapeHtml(summary)}</p>
+      ${lessons.map((lesson) => {
+        return `<div class="lesson" data-open-lesson-drawer="${escapeAttr(lesson.id)}">
+          <strong>${escapeHtml(lesson.id)}</strong>
+          <p>${escapeHtml(lesson.title || lesson.path)}</p>
         </div>`;
       }).join("") || emptyState(t("noLessons"))}
     </div>
   </section>`;
 }
 
+function lessonDocuments() {
+  return (bundle.documents?.documents || [])
+    .filter((doc) => doc.type === "lesson-detail" || /\/01-GOVERNANCE\/lessons\/[^/]+\.md$/i.test(doc.path || ""))
+    .map((doc) => {
+      const id = lessonIdFromDocument(doc);
+      return { id, title: (doc.title || "").replace(new RegExp(`^${id}\\s*-\\s*`, "i"), ""), path: doc.path, doc };
+    })
+    .filter((lesson) => lesson.id)
+    .sort((left, right) => String(right.id).localeCompare(String(left.id)));
+}
+
+function lessonIdFromDocument(doc) {
+  const content = doc?.content || "";
+  const path = doc?.path || "";
+  return content.match(/#\s*(L-\d{4}(?:-\d{2}-\d{2})?-\d+)/i)?.[1]
+    || path.match(/(L-\d{4}(?:-\d{2}-\d{2})?-\d+)/i)?.[1]
+    || "";
+}
+
 function healthPanel() {
   const details = bundle.status?.checkState?.details || { failures: [], warnings: [] };
   return `<section class="health-panel">