coding-agent-harness 1.0.1 → 1.0.4

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

@@ -0,0 +1,246 @@
+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) {
+  return `<section class="phase-timeline">
+    <h2>${t("phaseTimeline")}</h2>
+    ${(task.phases || []).map((phase) => `<div class="phase-step ${phase.state}">
+      <strong>${escapeHtml(phase.id)}</strong>
+      <span>${phase.completion}%</span>
+      <p>${escapeHtml(phase.output || phase.blockingRisk || phase.state)}</p>
+      ${progressBar(phase.completion)}
+    </div>`).join("") || emptyState(t("noPhaseData"))}
+  </section>`;
+}
+
+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/40-modules.js

@@ -0,0 +1,58 @@
+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 key = taskModuleKey(task);
+    if (!moduleMap.has(key)) moduleMap.set(key, { id: `module:${key}`, type: "module", label: key, state: task.classificationSource || "inferred" });
+  }
+  const modules = [...moduleMap.values()];
+  return `<main class="stack">
+    <section class="module-grid">
+      ${modules.map((module) => moduleCard(module)).join("") || emptyState(t("noModules"))}
+    </section>
+  </main>`;
+}
+
+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";
+  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>
+    </div>
+    <span class="module-task-pct">${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(`TARGET:docs/09-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>`}
+    </div>
+    ${pagerHtml}
+  </article>`;
+}

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

@@ -0,0 +1,347 @@
+function reviewQueue() {
+  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">
+        <div class="section-head">
+          <div>
+            <p class="eyebrow">${t("review")}</p>
+            <h2>${t("reviewQueue")}</h2>
+            <p class="subtle">${t("reviewQueueSubtitle")}</p>
+          </div>
+          <span class="subtle">${t("showing")} ${visibleTasks.length ? (page - 1) * taskPageSize + 1 : 0}-${Math.min(page * taskPageSize, tasks.length)} / ${tasks.length}</span>
+        </div>
+        <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>
+    <aside class="dashboard-sidebar stack">
+      <section class="side-panel review-queue-summary">
+        <h3>${t("reviewQueue")}</h3>
+        <div class="review-queue-stats">
+          ${tabs.map((tab) => metric(tab.label, reviewQueueBaseTasks(tab).length)).join("")}
+        </div>
+      </section>
+      <section class="side-panel">
+        <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 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 reviewTruthyCount(tasks, key) {
+  return tasks.filter((task) => task[key] === true).length;
+}
+
+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" 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+/)
+    .map((line) => line.trim())
+    .filter(Boolean)[0] || "";
+}
+
+function reviewWorkspace(route) {
+  const task = (bundle.status?.tasks || []).find((item) => item.id === route.id);
+  if (!task) return `<main>${emptyState(t("taskNotFound"))}</main>`;
+  const walkthroughDoc = taskDocument(task, "__walkthrough__");
+  const candidateDoc = taskDocument(task, "lesson_candidates.md");
+  const reviewDoc = taskDocument(task, "review.md");
+  const findingsDoc = taskDocument(task, "findings.md");
+  return `<main class="review-workspace">
+    <nav class="crumbs"><a href="#/review">${t("reviewQueue")}</a><span>/</span><span>${escapeHtml(task.id)}</span></nav>
+    <section class="detail-hero review-hero">
+      <div>
+        <p class="eyebrow">${t("reviewWorkspace")}</p>
+        <h2>${escapeHtml(task.title)}</h2>
+        <p>${escapeHtml(task.path)}</p>
+      </div>
+      <div class="review-hero-tags">
+        ${tag(task.lifecycleState || "unknown")}
+        ${tag(task.reviewStatus || "missing")}
+        ${tag(task.lessonCandidateStatus || "missing")}
+      </div>
+    </section>
+    <section class="review-workspace-grid">
+      <article class="review-workspace-main stack">
+        ${reviewDocPanel("walkthrough", walkthroughDoc, task.walkthroughPath)}
+        ${reviewDocPanel("lessonCandidates", candidateDoc, task.lessonCandidatePath)}
+        ${reviewDocPanel("review", reviewDoc, task.reviewPath)}
+        ${reviewDocPanel("findings", findingsDoc, task.findingsPath)}
+      </article>
+      <aside class="review-workspace-side stack">
+        ${reviewActionPanel(task, { mode: "workspace" })}
+        ${taskStateSummary(task)}
+        ${openFindings(task)}
+        ${evidenceList(task)}
+      </aside>
+    </section>
+  </main>`;
+}
+
+function reviewDocPanel(key, doc, fallbackPath = "") {
+  return `<section class="doc-section review-doc-panel">
+    <div class="section-head">
+      <div>
+        <p class="eyebrow">${escapeHtml(fallbackPath || "")}</p>
+        <h2>${t(key)}</h2>
+      </div>
+      ${doc ? `<button data-render-toggle>${state.renderMode === "rendered" ? t("source") : t("rendered")}</button>` : ""}
+    </div>
+    <div class="review-doc-scroll"><div class="markdown">${doc ? window.HarnessMarkdown.render(doc.content, state.renderMode) : emptyState(t("documentMissing"))}</div></div>
+  </section>`;
+}