canopycms 0.0.68-int.98 → 0.1.0

package/dist/editor/admin/SystemHealthPanel.js

@@ -9,10 +9,15 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * only for admins (see isAdmin(userContext?.groups)); this component does not
  * re-check that itself, same as GroupManager and PermissionManager.
  */
-import { Alert, Badge, Button, Code, Group, Loader, Modal, Paper, SegmentedControl, SimpleGrid, Spoiler, Stack, Table, Tabs, Text, ThemeIcon, Tooltip, } from '@mantine/core';
+import { Alert, Badge, Box, Button, Code, Group, Loader, Modal, Paper, SegmentedControl, SimpleGrid, Spoiler, Stack, Table, Tabs, Text, ThemeIcon, Tooltip, VisuallyHidden, } from '@mantine/core';
+import { useId } from 'react';
 import { IconAlertCircle, IconAlertTriangle } from '@tabler/icons-react';
-import { modals } from '@mantine/modals';
+import { openConfirm } from '../utils/confirm-modal.js';
+import { focusReturnProps } from '../utils/focus-return.js';
+import { formatRelativeTime } from '../relative-time.js';
 import { useSystemHealth, } from './useSystemHealth.js';
+import { escapeForLog } from '../../utils/escape-text.js';
+import { branchStatusPresentation } from '../branch-status.js';
 // ============================================================================
 // Small pure helpers
 // ============================================================================
@@ -49,21 +54,33 @@ function formatAgeMs(ms) {
  */
 function purgeGateFor(entry) {
     if (entry.isBaseBranch) {
-        return { disabled: true, tooltip: 'The base branch can never be purged' };
+        return { disabled: true, tooltip: 'The base branch can never be purged.' };
     }
     const lockFresh = !!entry.provisioningLock && entry.provisioningLock.ageMs < PROVISIONING_LOCK_FRESH_MS;
     if (entry.kind === 'orphan') {
         const tooYoung = (entry.ageMs ?? 0) < ORPHAN_YOUTH_THRESHOLD_MS;
         const disabled = lockFresh || tooYoung;
-        return { disabled, tooltip: disabled ? 'May be a clone in progress' : undefined };
+        return {
+            disabled,
+            tooltip: disabled
+                ? 'This may be a clone in progress. Try again in a few minutes.'
+                : undefined,
+        };
     }
     return {
         disabled: lockFresh,
         tooltip: lockFresh
-            ? 'Provisioning, or the worker syncing this branch, may be in progress'
+            ? 'Provisioning, or the worker syncing this branch, may be in progress. Try again in a few minutes.'
             : undefined,
     };
 }
+/** Purge stays focusable while gated (`aria-disabled`), so its reason opens on focus and touch. */
+function PurgeButton({ entry, gate, onPurge, }) {
+    return (_jsx(Tooltip, { label: gate.tooltip, disabled: !gate.disabled, children: _jsx(Button, { variant: "light", color: "red", "data-disabled": gate.disabled ? true : undefined, "aria-disabled": gate.disabled ? true : undefined, "data-testid": `purge-dir-${entry.dirName}`, onClick: () => {
+                if (!gate.disabled)
+                    onPurge(entry.dirName);
+            }, children: "Purge" }) }));
+}
 function workerLivenessBadge(worker, mode) {
     if (mode === 'dev') {
         return { color: 'gray', label: `Worker: ${worker.state}` };
@@ -86,6 +103,25 @@ const BASE_REFRESH_LABELS = {
     'skipped-not-provisioned': 'not yet provisioned',
     failed: 'refresh failed',
 };
+/**
+ * The worker holding the base branch for an editor deploy, or the cycle it stopped waiting.
+ * The rule and its bound live in worker/schema-gate.ts.
+ */
+function BaseHoldAlert({ hold }) {
+    const names = hold.missingSchemas.map((name, i) => (_jsxs("span", { children: [i > 0 && ', ', _jsx(Code, { children: name })] }, name)));
+    const editor = hold.editorBuild.sourceRevision ? (_jsxs(_Fragment, { children: ["the running editor (built from ", _jsx(Code, { children: hold.editorBuild.sourceRevision.slice(0, 12) }), ")"] })) : ('the running editor');
+    return (_jsxs(Alert, { color: hold.expired ? 'orange' : 'blue', icon: _jsx(IconAlertTriangle, { size: 16 }), title: hold.expired ? 'Stopped waiting for the editor deploy' : 'Waiting for editor deploy', "data-testid": "base-hold-alert", children: [_jsxs(Text, { size: "sm", children: ["Newly merged content names ", names, ", which ", editor, " does not define.", ' ', hold.expired
+                        ? 'The worker updated the base branch anyway; content types using them are unavailable until an editor image defining them is deployed.'
+                        : 'The worker keeps the base branch at its current version until an editor image defining them handles a request.'] }), _jsxs(Text, { size: "xs", c: "dimmed", mt: 4, children: ["Held since ", hold.since, " \u00B7 ", hold.files.join(', '), hold.fileCount > hold.files.length && ` and ${hold.fileCount - hold.files.length} more`] })] }));
+}
+/**
+ * Branches the worker left diverged from GitHub because this deployment's copy holds editor work
+ * (worker/git-sync.ts's `reconcileTrackedBranches`). A copy holding none is moved to GitHub's tip
+ * and never listed. Names come from GitHub and are attacker-chosen, so each is shown escaped.
+ */
+function DivergedBranchesAlert({ names }) {
+    return (_jsx(Alert, { color: "orange", icon: _jsx(IconAlertTriangle, { size: 16 }), title: `${plural(names.length, 'branch')} diverged from GitHub`, "data-testid": "diverged-branches-alert", children: _jsxs(Stack, { gap: 4, children: [_jsx(Text, { size: "sm", children: "This deployment's copy of each branch below holds editor work that conflicts with the branch on GitHub, usually because the GitHub branch was rebased or force-pushed, or because another CanopyCMS deployment sharing this repository uses the same branch name. Neither copy has been changed, and publishing the branch fails until they agree." }), _jsx(Text, { size: "sm", children: "A developer decides which version to keep. To keep GitHub's, first push it to a new branch name on GitHub, because \"Delete branch\" in the editor also deletes a published branch on GitHub; then delete this branch in the editor (withdraw it from review first if it is in review). The editor's changes cannot be copied to another branch: to keep them, leave this branch as it is, or re-enter them by hand in a new branch. For the base branch or a settings branch, ask a developer to check what changed on GitHub." }), _jsx(Group, { gap: 4, children: names.map((name) => (_jsx(Code, { children: escapeForLog(name) }, name))) })] }) }));
+}
 /**
  * Why the base branch needs an operator, or null when its last refresh needs
  * nothing. Shared by the overview and the base row's warning tooltip.
@@ -105,13 +141,6 @@ function baseRefreshWarning(report) {
     }
     return lines.length > 0 ? lines.join('\n') : null;
 }
-// Mirrors BranchManager.tsx's statusColorMap -- kept local (not exported
-// there) rather than shared, same tiny lookup either way.
-const branchStatusColorMap = {
-    editing: 'brand',
-    submitted: 'green',
-    approved: 'teal',
-};
 const TASK_STATUS_OPTIONS = [
     { label: 'Pending', value: 'pending' },
     { label: 'Processing', value: 'processing' },
@@ -134,10 +163,63 @@ function deleteConfirmText(status) {
 }
 const MARK_MERGED_CONFIRM_TEXT = 'In production the server cannot verify the PR actually merged (no GitHub access from the API) — confirm the PR is merged on GitHub first.';
 const REPAIR_CONFIRM_TEXT = "Recreates metadata with defaults: status becomes 'editing', you become the creator, branch ACLs are reset. The corrupt file is archived alongside for forensics.";
+const DUPLICATE_REPAIR_CONFIRM_TEXT = 'These files share a content ID, so the editor uses only the one marked Keep. Archiving renames each other file to a hidden name in the same folder. Nothing is deleted.';
+const DUPLICATE_REPAIR_EDITOR_NOTE = 'This changes files on the branch, and adds you as one of its editors.';
+/**
+ * Why a healthy row's duplicate-ID state is unknown. `null` is a row the last
+ * scan did not include.
+ */
+function duplicateUncheckedReason(scan) {
+    if (scan?.state === 'unknown' && scan.reason === 'failed') {
+        return 'The duplicate ID check failed on this branch.';
+    }
+    if (scan?.state === 'unknown') {
+        return 'The duplicate ID check ran out of time before reaching this branch.';
+    }
+    return 'This branch was added after the last duplicate ID check.';
+}
+function plural(n, word) {
+    return `${n} ${word}${n === 1 ? '' : word.endsWith('h') ? 'es' : 's'}`;
+}
+/**
+ * One line for the whole Branches tab, so a scan that did not finish never
+ * reads as a clean one: rows without a badge are clean only when this says so.
+ */
+function duplicateScanSummary(health, healthyDirNames) {
+    const { duplicateIdScan: scan, duplicateIdScanLoading, duplicateIdScanError } = health;
+    if (duplicateIdScanLoading && !scan) {
+        return { text: 'Checking for duplicate content IDs…', color: 'dimmed' };
+    }
+    if (duplicateIdScanError) {
+        return {
+            text: `Could not check for duplicate content IDs: ${duplicateIdScanError}`,
+            color: 'orange',
+        };
+    }
+    if (!scan)
+        return { text: 'Duplicate content IDs not checked yet.', color: 'orange' };
+    let found = 0;
+    let unchecked = 0;
+    for (const dirName of healthyDirNames) {
+        const state = scan.byDir[dirName]?.state;
+        if (state === 'found')
+            found++;
+        else if (state !== 'none')
+            unchecked++;
+    }
+    const parts = [];
+    if (found > 0)
+        parts.push(`Duplicate content IDs found on ${plural(found, 'branch')}.`);
+    if (unchecked > 0)
+        parts.push(`Could not check ${plural(unchecked, 'branch')}.`);
+    if (parts.length === 0)
+        return { text: 'No duplicate content IDs found.', color: 'dimmed' };
+    return { text: parts.join(' '), color: 'orange' };
+}
 const PURGE_CONFIRM_TEXT = 'The directory is moved to a hidden trash name and kept for 30 days, then deleted. Any git work inside was never pushed and will be lost when the trash is swept.';
-export function SystemHealthPanel({ opened, onClose }) {
+export function SystemHealthPanel({ opened, onClose, returnFocusTo }) {
     const health = useSystemHealth({ isOpen: opened });
-    return (_jsx(Modal, { opened: opened, onClose: onClose, title: "System health", size: "xl", children: _jsxs(Tabs, { defaultValue: "overview", children: [_jsxs(Tabs.List, { children: [_jsx(Tabs.Tab, { value: "overview", children: "Overview" }), _jsx(Tabs.Tab, { value: "tasks", children: "Tasks" }), _jsx(Tabs.Tab, { value: "branches", children: "Branches" })] }), _jsx(Tabs.Panel, { value: "overview", pt: "md", children: _jsx(OverviewTab, { health: health }) }), _jsx(Tabs.Panel, { value: "tasks", pt: "md", children: _jsx(TasksTab, { health: health }) }), _jsx(Tabs.Panel, { value: "branches", pt: "md", children: _jsx(BranchesTab, { health: health }) })] }) }));
+    return (_jsx(Modal, { opened: opened, onClose: onClose, title: "System health", size: "xl", ...focusReturnProps(returnFocusTo), children: _jsxs(Tabs, { defaultValue: "overview", children: [_jsxs(Tabs.List, { children: [_jsx(Tabs.Tab, { value: "overview", children: "Overview" }), _jsx(Tabs.Tab, { value: "tasks", children: "Tasks" }), _jsx(Tabs.Tab, { value: "branches", children: "Branches" })] }), _jsx(Tabs.Panel, { value: "overview", pt: "md", children: _jsx(OverviewTab, { health: health }) }), _jsx(Tabs.Panel, { value: "tasks", pt: "md", children: _jsx(TasksTab, { health: health }) }), _jsx(Tabs.Panel, { value: "branches", pt: "md", children: _jsx(BranchesTab, { health: health }) })] }) }));
 }
 function OverviewTab({ health }) {
     const { status, statusLoading, isRecentFatalError, error, refresh } = health;
@@ -145,7 +227,7 @@ function OverviewTab({ health }) {
         return (_jsxs(Group, { justify: "center", py: "xl", children: [_jsx(Loader, { size: "md" }), _jsx(Text, { size: "sm", c: "dimmed", children: "Loading status..." })] }));
     }
     if (!status) {
-        return (_jsxs(Stack, { align: "center", py: "xl", gap: "sm", children: [_jsx(Text, { size: "sm", c: "dimmed", children: "No status available." }), _jsx(Button, { size: "xs", variant: "light", onClick: () => refresh(), children: "Refresh" })] }));
+        return (_jsxs(Stack, { align: "center", py: "xl", gap: "sm", children: [_jsx(Text, { size: "sm", c: "dimmed", children: "No status available." }), _jsx(Button, { variant: "light", onClick: () => refresh(), children: "Refresh" })] }));
     }
     const liveness = workerLivenessBadge(status.worker, status.mode);
     const lastFatalError = status.workerStatus?.lastFatalError;
@@ -155,12 +237,22 @@ function OverviewTab({ health }) {
     // Absent for a worker that predates the field, which is not evidence of skew;
     // nor is a stale or absent worker's leftover status file, which names no running build.
     const workerVersion = status.workerStatus?.workerVersion || undefined;
+    const lastShutdown = status.workerStatus?.lastShutdown;
     const versionSkew = status.worker.state === 'alive' &&
         workerVersion !== undefined &&
         workerVersion !== build.canopycmsVersion;
-    return (_jsxs(Stack, { gap: "md", children: [error && (_jsx(Alert, { color: "red", icon: _jsx(IconAlertCircle, { size: 16 }), variant: "light", children: error })), _jsxs(Group, { gap: "sm", children: [_jsx(Badge, { color: liveness.color, variant: "light", size: "lg", children: liveness.label }), status.mode === 'dev' && (_jsx(Text, { size: "xs", c: "dimmed", children: "No worker runs in dev mode" }))] }), isRecentFatalError && lastFatalError && (_jsxs(Alert, { color: "red", icon: _jsx(IconAlertCircle, { size: 16 }), title: "Worker crash detected", children: [_jsx(Text, { size: "sm", children: lastFatalError.message }), _jsxs(Text, { size: "xs", c: "dimmed", mt: 4, children: ["at ", lastFatalError.at, " (", lastFatalError.phase, ")"] })] })), status.settingsWorkspaceError && (_jsx(Alert, { color: "red", icon: _jsx(IconAlertCircle, { size: 16 }), title: "Settings workspace unavailable: groups and path rules are not loading", children: _jsx(Text, { size: "sm", children: status.settingsWorkspaceError }) })), status.statusReadError && (_jsxs(Text, { size: "xs", c: "orange", children: ["Warning: could not read worker status (", status.statusReadError, ")"] })), status.workerStatus?.lastGitSyncError && (_jsxs(Alert, { color: "orange", icon: _jsx(IconAlertCircle, { size: 16 }), title: "Last git sync failed", children: [_jsx(Text, { size: "sm", children: status.workerStatus.lastGitSyncError.message }), _jsxs(Text, { size: "xs", c: "dimmed", mt: 4, children: ["at ", status.workerStatus.lastGitSyncError.at] })] })), versionSkew && (_jsx(Alert, { color: "orange", icon: _jsx(IconAlertCircle, { size: 16 }), title: "API and worker versions differ", "data-testid": "version-skew-warning", children: _jsxs(Text, { size: "sm", children: ["The API runs canopycms ", build.canopycmsVersion, " but the worker runs canopycms", ' ', workerVersion, ". They were deployed from different builds."] }) })), _jsxs(Paper, { withBorder: true, p: "sm", radius: "md", children: [_jsx(Text, { size: "sm", fw: 600, children: "Build" }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-api-version", children: ["API: canopycms ", build.canopycmsVersion] }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-source-revision", children: ["Source revision:", ' ', build.sourceRevision ? (_jsx(Tooltip, { label: build.sourceRevision, children: _jsx(Code, { children: build.sourceRevision.slice(0, 12) }) })) : ('not set (pass the CANOPY_SOURCE_SHA build arg to the image build)')] }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-worker-version", children: ["Worker version: ", workerVersion ? `canopycms ${workerVersion}` : 'unknown'] }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-media", children: ["Media storage:", ' ', status.assetStore.configured ? 'configured' : 'not configured — uploads are disabled'] })] }), lastGitSync && (_jsxs(Paper, { withBorder: true, p: "sm", radius: "md", children: [_jsx(Text, { size: "sm", fw: 600, children: "Last git sync" }), _jsxs(Text, { size: "xs", c: "dimmed", children: [status.workerStatus?.lastGitSyncAt ?? 'unknown time', " \u00B7 ", lastGitSync.durationMs, "ms \u00B7", ' ', lastGitSync.rebased.length, " rebased \u00B7 ", lastGitSync.skippedDirty.length, " skipped (dirty)", lastGitSync.skippedLocked && lastGitSync.skippedLocked.length > 0
+    return (_jsxs(Stack, { gap: "md", children: [error && (_jsx(Alert, { color: "red", icon: _jsx(IconAlertCircle, { size: 16 }), variant: "light", children: error })), _jsxs(Group, { gap: "sm", children: [_jsx(Badge, { color: liveness.color, variant: "light", size: "lg", children: liveness.label }), status.mode === 'dev' && (_jsx(Text, { size: "xs", c: "dimmed", children: "No worker runs in dev mode" }))] }), isRecentFatalError && lastFatalError && (_jsxs(Alert, { color: "red", icon: _jsx(IconAlertCircle, { size: 16 }), title: lastFatalError.phase === 'startup'
+                    ? 'The worker failed to start'
+                    : 'The worker stopped while running', children: [_jsx(Text, { size: "sm", children: lastFatalError.message }), _jsxs(Text, { size: "xs", c: "dimmed", mt: 4, children: ["at ", lastFatalError.at] })] })), status.settingsWorkspaceError && (_jsx(Alert, { color: "red", icon: _jsx(IconAlertCircle, { size: 16 }), title: "Settings workspace unavailable: groups and path rules are not loading", children: _jsx(Text, { size: "sm", children: status.settingsWorkspaceError }) })), status.schemaIssues && status.schemaIssues.length > 0 && (_jsx(Alert, { color: "yellow", icon: _jsx(IconAlertTriangle, { size: 16 }), title: "Content types this editor version doesn't know", "data-testid": "schema-issues-alert", children: _jsx(Stack, { gap: 4, children: status.schemaIssues.map((issue) => (_jsx(Text, { size: "sm", children: issue.kind === 'unknown-schema' ? (_jsxs(_Fragment, { children: [_jsx(Code, { children: issue.metaFile }), " names ", _jsx(Code, { children: issue.schemaRef }), ", so entry type ", _jsx(Code, { children: issue.entryType }), " is unavailable"] })) : (issue.message) }, `${issue.kind}:${issue.message}`))) }) })), status.workerStatus?.baseHold && _jsx(BaseHoldAlert, { hold: status.workerStatus.baseHold }), status.statusReadError && (_jsxs(Text, { size: "xs", c: "orange", children: ["Warning: could not read worker status (", status.statusReadError, ")"] })), lastGitSync?.tracked && lastGitSync.tracked.diverged.length > 0 && (_jsx(DivergedBranchesAlert, { names: lastGitSync.tracked.diverged })), status.workerStatus?.lastGitSyncError && (_jsxs(Alert, { color: "orange", icon: _jsx(IconAlertCircle, { size: 16 }), title: "Last git sync failed", children: [_jsx(Text, { size: "sm", children: status.workerStatus.lastGitSyncError.message }), _jsxs(Text, { size: "xs", c: "dimmed", mt: 4, children: ["at ", status.workerStatus.lastGitSyncError.at] })] })), versionSkew && (_jsx(Alert, { color: "orange", icon: _jsx(IconAlertCircle, { size: 16 }), title: "API and worker versions differ", "data-testid": "version-skew-warning", children: _jsxs(Text, { size: "sm", children: ["The API runs canopycms ", build.canopycmsVersion, " but the worker runs canopycms", ' ', workerVersion, ". They were deployed from different builds."] }) })), _jsxs(Paper, { withBorder: true, p: "sm", children: [_jsx(Text, { size: "sm", fw: 600, children: "Build" }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-api-version", children: ["API: canopycms ", build.canopycmsVersion] }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-source-revision", children: ["Source revision:", ' ', build.sourceRevision ? (_jsx(Tooltip, { label: build.sourceRevision, children: _jsx(Code, { children: build.sourceRevision.slice(0, 12) }) })) : ('not set (pass the CANOPY_SOURCE_SHA build arg to the image build)')] }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-worker-version", children: ["Worker version: ", workerVersion ? `canopycms ${workerVersion}` : 'unknown'] }), lastShutdown && (_jsxs(Text, { size: "xs", c: lastShutdown.outcome === 'drained' ? 'dimmed' : 'orange', "data-testid": "build-last-shutdown", children: ["Last worker shutdown: ", lastShutdown.reason, " at ", lastShutdown.at, lastShutdown.outcome === 'deadline' &&
+                                ` · drain deadline hit, aborted ${lastShutdown.abandoned?.join(', ') ?? 'in-flight work'}`, lastShutdown.outcome === 'drained' &&
+                                lastShutdown.drainMs !== undefined &&
+                                ` · drained in ${(lastShutdown.drainMs / 1000).toFixed(1)}s`, lastShutdown.outcome === 'not-drained' && ' (a crash or a forced stop)'] })), lastFatalError?.phase === 'startup' && (_jsxs(Text, { size: "xs", c: "orange", "data-testid": "build-failed-start", children: ["Last start failed at ", lastFatalError.at] })), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-media", children: ["Media storage:", ' ', status.assetStore.configured ? 'configured' : 'not configured — uploads are disabled'] }), _jsxs(Text, { size: "xs", c: status.imageProcessing.available ? 'dimmed' : 'orange', "data-testid": "build-image-processing", children: ["Image processing:", ' ', status.imageProcessing.available
+                                ? 'available'
+                                : `unavailable — new editor image sizes and crops fail, and uploads skip decode validation${status.imageProcessing.error ? ` (${status.imageProcessing.error})` : ''}`] })] }), lastGitSync && (_jsxs(Paper, { withBorder: true, p: "sm", children: [_jsx(Text, { size: "sm", fw: 600, children: "Last git sync" }), _jsxs(Text, { size: "xs", c: "dimmed", children: [status.workerStatus?.lastGitSyncAt ?? 'unknown time', " \u00B7 ", lastGitSync.durationMs, "ms \u00B7", ' ', lastGitSync.rebased.length, " rebased \u00B7 ", lastGitSync.skippedDirty.length, " skipped (dirty)", lastGitSync.skippedLocked && lastGitSync.skippedLocked.length > 0
                                 ? ` · ${lastGitSync.skippedLocked.length} skipped (busy: a content write, provisioning or purge)`
-                                : ''] }), lastGitSync.baseRefresh && (_jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "base-refresh-outcome", children: ["Base branch: ", BASE_REFRESH_LABELS[lastGitSync.baseRefresh.outcome]] })), baseWarning && (_jsx(Text, { size: "xs", c: "orange", style: { whiteSpace: 'pre-line' }, "data-testid": "base-refresh-warning", children: baseWarning })), lastGitSync.failed.length > 0 && (_jsx(Spoiler, { maxHeight: 0, showLabel: `${lastGitSync.failed.length} failed — show details`, hideLabel: "Hide", children: _jsx(Stack, { gap: 4, mt: 4, children: lastGitSync.failed.map((f) => (_jsxs(Text, { size: "xs", c: "red", children: [f.branch, ": ", f.error] }, f.branch))) }) }))] })), _jsx(SimpleGrid, { cols: 5, spacing: "xs", children: ['pending', 'processing', 'completed', 'failed', 'corrupt'].map((key) => (_jsxs(Paper, { withBorder: true, p: "xs", radius: "md", ta: "center", children: [_jsx(Text, { size: "xs", c: "dimmed", tt: "capitalize", children: key }), _jsx(Text, { size: "lg", fw: 700, c: (key === 'failed' || key === 'corrupt') && status.queue[key] > 0 ? 'red' : undefined, children: status.queue[key] })] }, key))) }), status.queue.oldestPendingAgeMs !== undefined && (_jsxs(Text, { size: "xs", c: "dimmed", children: ["Oldest pending task: ", formatAgeMs(status.queue.oldestPendingAgeMs), " old"] })), _jsxs(Group, { justify: "space-between", align: "center", children: [_jsxs(Text, { size: "xs", c: "dimmed", children: ["Generated at ", status.generatedAt] }), _jsx(Button, { size: "xs", variant: "light", onClick: () => refresh(), loading: statusLoading, children: "Refresh" })] }), _jsx(Text, { size: "xs", c: "dimmed", children: "Data may lag up to ~60s (shared-filesystem caching)" })] }));
+                                : ''] }), lastGitSync.baseRefresh && (_jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "base-refresh-outcome", children: ["Base branch: ", BASE_REFRESH_LABELS[lastGitSync.baseRefresh.outcome]] })), baseWarning && (_jsx(Text, { size: "xs", c: "orange", style: { whiteSpace: 'pre-line' }, "data-testid": "base-refresh-warning", children: baseWarning })), lastGitSync.failed.length > 0 && (_jsx(Spoiler, { maxHeight: 0, showLabel: `${lastGitSync.failed.length} failed — show details`, hideLabel: "Hide", children: _jsx(Stack, { gap: 4, mt: 4, children: lastGitSync.failed.map((f) => (_jsxs(Text, { size: "xs", c: "var(--canopy-danger-text)", children: [f.branch, ": ", f.error] }, f.branch))) }) }))] })), _jsx(SimpleGrid, { cols: 5, spacing: "xs", children: ['pending', 'processing', 'completed', 'failed', 'corrupt'].map((key) => (_jsxs(Paper, { withBorder: true, p: "xs", ta: "center", children: [_jsx(Text, { size: "xs", c: "dimmed", tt: "capitalize", children: key }), _jsx(Text, { size: "lg", fw: 700, c: (key === 'failed' || key === 'corrupt') && status.queue[key] > 0
+                                ? 'var(--canopy-danger-text)'
+                                : undefined, children: status.queue[key] })] }, key))) }), status.queue.oldestPendingAgeMs !== undefined && (_jsxs(Text, { size: "xs", c: "dimmed", children: ["Oldest pending task: ", formatAgeMs(status.queue.oldestPendingAgeMs), " old"] })), _jsxs(Group, { justify: "space-between", align: "center", children: [_jsxs(Text, { size: "xs", c: "dimmed", children: ["Generated at ", status.generatedAt] }), _jsx(Button, { variant: "light", onClick: () => refresh(), loading: statusLoading, children: "Refresh" })] }), _jsx(Text, { size: "xs", c: "dimmed", children: "Data may lag up to ~60s (shared-filesystem caching)" })] }));
 }
 function TasksTab({ health }) {
     const { taskStatus, setTaskStatus, tasks, tasksLoading } = health;
@@ -170,7 +262,7 @@ function TasksTab({ health }) {
     const isEmpty = isCorrupt ? corruptRows.length === 0 : taskRows.length === 0;
     const canDelete = taskStatus === 'pending' || taskStatus === 'failed' || taskStatus === 'corrupt';
     const handleRetryClick = (task) => {
-        modals.openConfirmModal({
+        openConfirm({
             title: 'Retry task',
             children: _jsx(Text, { size: "sm", children: RETRY_CONFIRM_TEXT }),
             labels: { confirm: 'Retry', cancel: 'Cancel' },
@@ -179,7 +271,7 @@ function TasksTab({ health }) {
         });
     };
     const handleDeleteClick = (status, fileName) => {
-        modals.openConfirmModal({
+        openConfirm({
             title: 'Delete task file',
             children: _jsx(Text, { size: "sm", children: deleteConfirmText(status) }),
             labels: { confirm: 'Delete', cancel: 'Cancel' },
@@ -191,15 +283,15 @@ function TasksTab({ health }) {
                     if (isAdminTaskStatus(value))
                         setTaskStatus(value);
                 } }), tasksLoading && taskRows.length === 0 && corruptRows.length === 0 ? (_jsxs(Group, { justify: "center", py: "xl", children: [_jsx(Loader, { size: "sm" }), _jsx(Text, { size: "sm", c: "dimmed", children: "Loading tasks..." })] })) : isEmpty ? (_jsxs(Text, { size: "sm", c: "dimmed", py: "md", children: ["No ", taskStatus, " tasks."] })) : (_jsx(Table.ScrollContainer, { minWidth: 600, children: _jsxs(Table, { children: [_jsx(Table.Thead, { children: _jsx(Table.Tr, { children: isCorrupt ? (_jsxs(_Fragment, { children: [_jsx(Table.Th, { children: "File" }), _jsx(Table.Th, { children: "Size" }), _jsx(Table.Th, { children: "Modified" }), _jsx(Table.Th, { children: "Raw snippet" }), _jsx(Table.Th, { children: "Actions" })] })) : (_jsxs(_Fragment, { children: [_jsx(Table.Th, { children: "ID" }), _jsx(Table.Th, { children: "Action" }), _jsx(Table.Th, { children: "Created" }), _jsx(Table.Th, { children: "Retries" }), _jsx(Table.Th, { children: "Error" }), _jsx(Table.Th, { children: "Actions" })] })) }) }), _jsx(Table.Tbody, { children: isCorrupt
-                                ? corruptRows.map((file) => (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsx("span", { title: file.fileName, children: truncate(file.fileName, 30) }) }), _jsxs(Table.Td, { children: [file.size, " bytes"] }), _jsx(Table.Td, { children: file.mtime }), _jsx(Table.Td, { children: _jsx(Code, { block: true, style: { maxWidth: 320, whiteSpace: 'pre-wrap' }, children: file.rawSnippet }) }), _jsx(Table.Td, { children: _jsx(Button, { size: "xs", variant: "light", color: "red", "data-testid": `delete-task-${file.fileName}`, onClick: () => handleDeleteClick('corrupt', file.fileName), children: "Delete" }) })] }, file.fileName)))
-                                : taskRows.map((task) => (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsx("span", { title: task.id, children: truncate(task.id, 12) }) }), _jsx(Table.Td, { children: task.action }), _jsx(Table.Td, { children: task.createdAt }), _jsx(Table.Td, { children: task.retryCount ?? 0 }), _jsx(Table.Td, { children: task.error ? (_jsx(Tooltip, { label: task.error, multiline: true, maw: 400, children: _jsx(Text, { size: "xs", style: { cursor: 'help' }, children: truncate(task.error, 50) }) })) : (_jsx(Text, { size: "xs", c: "dimmed", children: "\u2014" })) }), _jsx(Table.Td, { children: _jsxs(Group, { gap: "xs", children: [taskStatus === 'failed' && (_jsx(Button, { size: "xs", variant: "light", "data-testid": `retry-task-${task.id}`, onClick: () => handleRetryClick(task), children: "Retry" })), canDelete && (_jsx(Button, { size: "xs", variant: "light", color: "red", "data-testid": `delete-task-${task.id}`, onClick: () => handleDeleteClick(taskStatus, `${task.id}.json`), children: "Delete" }))] }) })] }, task.id))) })] }) }))] }));
+                                ? corruptRows.map((file) => (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsx("span", { title: file.fileName, children: truncate(file.fileName, 30) }) }), _jsxs(Table.Td, { children: [file.size, " bytes"] }), _jsx(Table.Td, { children: file.mtime }), _jsx(Table.Td, { children: _jsx(Code, { block: true, style: { maxWidth: 320, whiteSpace: 'pre-wrap' }, children: file.rawSnippet }) }), _jsx(Table.Td, { children: _jsx(Button, { variant: "light", color: "red", "data-testid": `delete-task-${file.fileName}`, onClick: () => handleDeleteClick('corrupt', file.fileName), children: "Delete" }) })] }, file.fileName)))
+                                : taskRows.map((task) => (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsx("span", { title: task.id, children: truncate(task.id, 12) }) }), _jsx(Table.Td, { children: task.action }), _jsx(Table.Td, { children: task.createdAt }), _jsx(Table.Td, { children: task.retryCount ?? 0 }), _jsx(Table.Td, { children: task.error ? (_jsx(Tooltip, { label: task.error, multiline: true, maw: 400, children: _jsx(Text, { size: "xs", style: { cursor: 'help' }, children: truncate(task.error, 50) }) })) : (_jsx(Text, { size: "xs", c: "dimmed", children: "\u2014" })) }), _jsx(Table.Td, { children: _jsxs(Group, { gap: "xs", children: [taskStatus === 'failed' && (_jsx(Button, { variant: "light", "data-testid": `retry-task-${task.id}`, onClick: () => handleRetryClick(task), children: "Retry" })), canDelete && (_jsx(Button, { variant: "light", color: "red", "data-testid": `delete-task-${task.id}`, onClick: () => handleDeleteClick(taskStatus, `${task.id}.json`), children: "Delete" }))] }) })] }, task.id))) })] }) }))] }));
 }
 function BranchesTab({ health }) {
     const { branchHealth, branchHealthLoading } = health;
     const entries = branchHealth?.entries ?? [];
     const baseWarning = baseRefreshWarning(health.status?.workerStatus?.lastGitSync?.baseRefresh);
     const handleMarkMergedClick = (branchName) => {
-        modals.openConfirmModal({
+        openConfirm({
             title: 'Mark branch as merged',
             children: _jsx(Text, { size: "sm", children: MARK_MERGED_CONFIRM_TEXT }),
             labels: { confirm: 'Mark merged', cancel: 'Cancel' },
@@ -208,7 +300,7 @@ function BranchesTab({ health }) {
         });
     };
     const handleRepairClick = (dirName) => {
-        modals.openConfirmModal({
+        openConfirm({
             title: 'Repair metadata',
             children: _jsx(Text, { size: "sm", children: REPAIR_CONFIRM_TEXT }),
             labels: { confirm: 'Repair', cancel: 'Cancel' },
@@ -217,7 +309,7 @@ function BranchesTab({ health }) {
         });
     };
     const handlePurgeClick = (dirName) => {
-        modals.openConfirmModal({
+        openConfirm({
             title: 'Purge directory',
             children: _jsx(Text, { size: "sm", children: PURGE_CONFIRM_TEXT }),
             labels: { confirm: 'Purge', cancel: 'Cancel' },
@@ -225,15 +317,53 @@ function BranchesTab({ health }) {
             onConfirm: () => health.purgeDir(dirName),
         });
     };
+    // Its own dialog, reachable only from the duplicate badge, whose confirm
+    // calls only the duplicate repair: Purge sits on neighbouring rows and
+    // trashes a whole branch directory.
+    const handleDuplicateIdsClick = (dirName, duplicates) => {
+        openConfirm({
+            title: 'Fix duplicate content IDs',
+            children: _jsx(DuplicateRepairDetails, { dirName: dirName, duplicates: duplicates }),
+            labels: { confirm: 'Archive duplicates', cancel: 'Cancel' },
+            confirmProps: { color: 'orange' },
+            onConfirm: () => health.repairDuplicateIds(dirName),
+        });
+    };
+    const healthyDirNames = entries.filter((e) => e.kind === 'healthy').map((e) => e.dirName);
+    const duplicateSummary = duplicateScanSummary(health, healthyDirNames);
     if (branchHealthLoading && entries.length === 0) {
         return (_jsxs(Group, { justify: "center", py: "xl", children: [_jsx(Loader, { size: "sm" }), _jsx(Text, { size: "sm", c: "dimmed", children: "Loading branch health..." })] }));
     }
     if (entries.length === 0) {
         return (_jsx(Text, { size: "sm", c: "dimmed", py: "md", children: "No branch directories found." }));
     }
-    return (_jsx(Table.ScrollContainer, { minWidth: 700, children: _jsxs(Table, { children: [_jsx(Table.Thead, { children: _jsxs(Table.Tr, { children: [_jsx(Table.Th, { children: "Name" }), _jsx(Table.Th, { children: "Status" }), _jsx(Table.Th, { children: "PR" }), _jsx(Table.Th, { children: "Sync" }), _jsx(Table.Th, { children: "Warnings" }), _jsx(Table.Th, { children: "Updated" }), _jsx(Table.Th, { children: "Actions" })] }) }), _jsx(Table.Tbody, { children: entries.map((entry) => (_jsx(BranchHealthRow, { entry: entry, baseWarning: entry.isBaseBranch ? baseWarning : null, onMarkMerged: handleMarkMergedClick, onRepair: handleRepairClick, onPurge: handlePurgeClick }, entry.dirName))) })] }) }));
+    return (_jsxs(Stack, { gap: "xs", children: [_jsxs(Group, { justify: "space-between", align: "center", wrap: "nowrap", children: [_jsx(Text, { size: "xs", c: duplicateSummary.color, "data-testid": "duplicate-id-summary", children: duplicateSummary.text }), _jsx(Button, { size: "compact-xs", variant: "subtle", loading: health.duplicateIdScanLoading, onClick: () => health.checkDuplicateIds(), children: "Check again" })] }), _jsx(Table.ScrollContainer, { minWidth: 700, children: _jsxs(Table, { children: [_jsx(Table.Thead, { children: _jsxs(Table.Tr, { children: [_jsx(Table.Th, { children: "Name" }), _jsx(Table.Th, { children: "Status" }), _jsx(Table.Th, { children: "PR" }), _jsx(Table.Th, { children: "Sync" }), _jsx(Table.Th, { children: "Warnings" }), _jsx(Table.Th, { children: "Updated" }), _jsx(Table.Th, { children: "Actions" })] }) }), _jsx(Table.Tbody, { children: entries.map((entry) => (_jsx(BranchHealthRow, { entry: entry, baseWarning: entry.isBaseBranch ? baseWarning : null, duplicateIdScan: health.duplicateIdScan
+                                    ? (health.duplicateIdScan.byDir[entry.dirName] ?? null)
+                                    : undefined, onMarkMerged: handleMarkMergedClick, onRepair: handleRepairClick, onPurge: handlePurgeClick, onDuplicateIds: handleDuplicateIdsClick }, entry.dirName))) })] }) })] }));
+}
+function DuplicateRepairDetails({ dirName, duplicates, }) {
+    return (_jsxs(Stack, { gap: "sm", children: [_jsxs(Text, { size: "sm", children: ["Branch ", _jsx(Code, { children: dirName })] }), _jsx(Text, { size: "sm", children: DUPLICATE_REPAIR_CONFIRM_TEXT }), duplicates.map((d) => (_jsxs(Paper, { withBorder: true, p: "xs", radius: "sm", "data-testid": `duplicate-id-${d.id}`, children: [_jsxs(Text, { size: "xs", fw: 600, children: ["Content ID ", _jsx(Code, { children: d.id })] }), _jsxs(Text, { size: "xs", children: ["Keep: ", _jsx(Code, { children: d.keptPath })] }), d.droppedPaths.map((p) => (_jsxs(Text, { size: "xs", children: ["Archive: ", _jsx(Code, { children: p })] }, p)))] }, d.id))), _jsx(Text, { size: "xs", c: "dimmed", children: DUPLICATE_REPAIR_EDITOR_NOTE })] }));
+}
+/** "2d ago, 1/1/2026, 9:00:00 AM": inside a tooltip, so the absolute date sits beside it. */
+const firstFailed = (iso) => {
+    const date = new Date(iso);
+    return Number.isNaN(date.getTime()) ? iso : `${formatRelativeTime(iso)}, ${date.toLocaleString()}`;
+};
+/**
+ * A detail that only a Tooltip would show: hidden text for assistive tech, plus a Tooltip that
+ * opens on hover, focus and touch. The trigger is a focusable span, not a button: it does nothing
+ * when pressed, so it must not be announced as one. A trigger with no text of its own, such as an
+ * icon, takes its name from `name`.
+ */
+function TooltipDetail({ detail, name, maw = 320, preLine = false, children, }) {
+    const detailId = useId();
+    return (_jsxs(_Fragment, { children: [_jsx(Tooltip
+            // A sighted user sees only the icon, so the tooltip names it too.
+            , { 
+                // A sighted user sees only the icon, so the tooltip names it too.
+                label: name ? `${name}: ${detail}` : detail, multiline: true, maw: maw, style: preLine ? { whiteSpace: 'pre-line' } : undefined, events: { hover: true, focus: true, touch: true }, children: _jsx(Box, { component: "span", tabIndex: 0, role: name ? 'img' : undefined, "aria-label": name, "aria-describedby": detailId, className: "mantine-focus-auto", children: children }) }), _jsx(VisuallyHidden, { id: detailId, children: detail })] }));
 }
-function BranchHealthRow({ entry, baseWarning, onMarkMerged, onRepair, onPurge, }) {
+function BranchHealthRow({ entry, baseWarning, duplicateIdScan, onMarkMerged, onRepair, onPurge, onDuplicateIds, }) {
     if (entry.kind === 'healthy' && entry.branch) {
         const b = entry.branch;
         // Mirrors the rebase loop's skip logic (worker/rebase.ts): the worker
@@ -243,17 +373,17 @@ function BranchHealthRow({ entry, baseWarning, onMarkMerged, onRepair, onPurge,
         // default instead of silently hiding them.
         const showRebaseFailure = !['submitted', 'approved', 'archived'].includes(b.status) && !!b.rebaseFailure;
         const canMarkMerged = (b.status === 'submitted' || b.status === 'approved') && !!b.pullRequestNumber;
-        return (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsxs(Group, { gap: 4, wrap: "nowrap", children: [_jsx(Text, { size: "sm", children: entry.dirName }), entry.isBaseBranch && (_jsx(Badge, { size: "xs", color: "gray", variant: "outline", children: "base" }))] }) }), _jsx(Table.Td, { children: _jsx(Badge, { color: branchStatusColorMap[b.status] ?? 'neutral', variant: "light", children: b.status }) }), _jsx(Table.Td, { children: b.pullRequestNumber ? (_jsxs(Text, { size: "xs", c: "blue", component: "a", href: b.pullRequestUrl, target: "_blank", rel: "noopener noreferrer", style: { textDecoration: 'underline' }, children: ["PR #", b.pullRequestNumber, b.pullRequestState ? ` (${b.pullRequestState})` : ''] })) : (_jsx(Text, { size: "xs", c: "dimmed", children: "\u2014" })) }), _jsx(Table.Td, { children: b.syncStatus === 'sync-failed' ? (_jsx(Tooltip, { label: b.syncFailureReason
-                            ? `${b.syncFailureReason} — retry from the Tasks tab`
-                            : 'GitHub sync failed — retry from the Tasks tab', multiline: true, maw: 320, children: _jsx(Badge, { color: "red", variant: "light", children: "sync-failed" }) })) : b.syncStatus === 'pending-sync' ? (_jsx(Badge, { color: "gray", variant: "light", children: "pending-sync" })) : null }), _jsx(Table.Td, { children: _jsxs(Group, { gap: 6, wrap: "nowrap", children: [!!b.conflictFiles?.length && (_jsxs(Badge, { color: "orange", variant: "light", children: [b.conflictFiles.length, " conflict", b.conflictFiles.length === 1 ? '' : 's'] })), showRebaseFailure && b.rebaseFailure && (_jsx(Tooltip, { label: `${b.rebaseFailure.message} (failing since ${b.rebaseFailure.firstAt})`, multiline: true, maw: 320, children: _jsx(ThemeIcon, { color: "yellow", variant: "light", size: "sm", radius: "xl", "data-testid": `rebase-failure-${entry.dirName}`, children: _jsx(IconAlertTriangle, { size: 12 }) }) })), baseWarning && (_jsx(Tooltip, { label: baseWarning, multiline: true, maw: 420, style: { whiteSpace: 'pre-line' }, children: _jsx(ThemeIcon, { color: "yellow", variant: "light", size: "sm", radius: "xl", "data-testid": `base-refresh-warning-${entry.dirName}`, children: _jsx(IconAlertTriangle, { size: 12 }) }) })), !!entry.duplicateContentIds?.length && (_jsx(Tooltip, { label: entry.duplicateContentIds
-                                    .map((d) => `${d.id}: kept ${d.keptPath}; also on ${d.droppedPaths.join(', ')}`)
-                                    .join('\n'), multiline: true, maw: 420, style: { whiteSpace: 'pre-line' }, children: _jsxs(Badge, { color: "orange", variant: "light", "data-testid": `duplicate-content-ids-${entry.dirName}`, children: [entry.duplicateContentIds.length, " duplicate ID", entry.duplicateContentIds.length === 1 ? '' : 's'] }) }))] }) }), _jsx(Table.Td, { children: _jsx(Text, { size: "xs", c: "dimmed", children: b.updatedAt }) }), _jsx(Table.Td, { children: canMarkMerged && (_jsx(Button, { size: "xs", variant: "light", "data-testid": `mark-merged-${b.name}`, onClick: () => onMarkMerged(b.name), children: "Mark merged" })) })] }));
+        return (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsxs(Group, { gap: 4, wrap: "nowrap", children: [_jsx(Text, { size: "sm", children: entry.dirName }), entry.isBaseBranch && (_jsx(Badge, { size: "xs", color: "gray", variant: "outline", children: "Base" }))] }) }), _jsx(Table.Td, { children: _jsx(Badge, { color: branchStatusPresentation(b.status)?.color ?? 'neutral', variant: "light", children: branchStatusPresentation(b.status)?.label }) }), _jsx(Table.Td, { children: b.pullRequestNumber ? (_jsxs(Text, { size: "xs", c: "blue", component: "a", href: b.pullRequestUrl, target: "_blank", rel: "noopener noreferrer", style: { textDecoration: 'underline' }, children: ["PR #", b.pullRequestNumber, b.pullRequestState ? ` (${b.pullRequestState})` : ''] })) : (_jsx(Text, { size: "xs", c: "dimmed", children: "\u2014" })) }), _jsx(Table.Td, { children: b.syncStatus === 'sync-failed' ? (_jsx(TooltipDetail, { detail: b.syncFailureReason
+                            ? `${b.syncFailureReason} — retry from the "Tasks" tab`
+                            : 'GitHub sync failed — retry from the "Tasks" tab', children: _jsx(Badge, { color: "red", variant: "light", children: "Sync failed" }) })) : b.syncStatus === 'pending-sync' ? (_jsx(Badge, { color: "gray", variant: "light", children: "Pending sync" })) : null }), _jsx(Table.Td, { children: _jsxs(Group, { gap: 6, wrap: "nowrap", children: [!!b.conflictFiles?.length && (_jsxs(Badge, { color: "orange", variant: "light", children: [b.conflictFiles.length, " conflict", b.conflictFiles.length === 1 ? '' : 's'] })), showRebaseFailure && b.rebaseFailure && (_jsx(TooltipDetail, { name: "Rebase failing", detail: `${b.rebaseFailure.message} (first failed ${firstFailed(b.rebaseFailure.firstAt)})`, children: _jsx(ThemeIcon, { color: "yellow", variant: "light", size: "sm", radius: "xl", "data-testid": `rebase-failure-${entry.dirName}`, children: _jsx(IconAlertTriangle, { size: 12 }) }) })), baseWarning && (_jsx(TooltipDetail, { name: "Base branch refresh failing", detail: baseWarning, maw: 420, preLine: true, children: _jsx(ThemeIcon, { color: "yellow", variant: "light", size: "sm", radius: "xl", "data-testid": `base-refresh-warning-${entry.dirName}`, children: _jsx(IconAlertTriangle, { size: 12 }) }) })), duplicateIdScan?.state === 'found' && (_jsx(Tooltip, { label: "Review and fix", children: _jsx(Badge, { component: "button", type: "button", color: "orange", variant: "light", style: { cursor: 'pointer' }, "data-testid": `duplicate-content-ids-${entry.dirName}`, onClick: () => onDuplicateIds(entry.dirName, duplicateIdScan.duplicates), children: plural(duplicateIdScan.duplicates.length, 'duplicate ID') }) })), duplicateIdScan !== undefined &&
+                                duplicateIdScan?.state !== 'found' &&
+                                duplicateIdScan?.state !== 'none' && (_jsx(Tooltip, { label: duplicateUncheckedReason(duplicateIdScan), multiline: true, maw: 320, children: _jsx(Badge, { color: "gray", variant: "outline", "data-testid": `duplicate-ids-unchecked-${entry.dirName}`, children: "IDs not checked" }) }))] }) }), _jsx(Table.Td, { children: _jsx(Text, { size: "xs", c: "dimmed", children: b.updatedAt }) }), _jsx(Table.Td, { children: canMarkMerged && (_jsx(Button, { variant: "light", "data-testid": `mark-merged-${b.name}`, onClick: () => onMarkMerged(b.name), children: "Mark merged" })) })] }));
     }
     if (entry.kind === 'corrupt-metadata') {
         const purgeGate = purgeGateFor(entry);
-        return (_jsxs(Table.Tr, { style: { backgroundColor: 'var(--mantine-color-red-light)' }, children: [_jsx(Table.Td, { children: entry.dirName }), _jsx(Table.Td, { children: _jsx(Badge, { color: "red", variant: "light", children: "corrupt metadata" }) }), _jsx(Table.Td, { colSpan: 3, children: _jsx(Tooltip, { label: entry.parseError, multiline: true, maw: 400, children: _jsx(Text, { size: "xs", c: "red", children: truncate(entry.parseError ?? 'Unknown parse error', 60) }) }) }), _jsx(Table.Td, { children: _jsx(Text, { size: "xs", c: "dimmed", children: entry.metaMtime ?? '—' }) }), _jsx(Table.Td, { children: _jsxs(Group, { gap: "xs", wrap: "nowrap", children: [_jsx(Button, { size: "xs", variant: "light", "data-testid": `repair-dir-${entry.dirName}`, onClick: () => onRepair(entry.dirName), children: "Repair" }), _jsx(Tooltip, { label: purgeGate.tooltip, disabled: !purgeGate.disabled, children: _jsx("span", { children: _jsx(Button, { size: "xs", variant: "light", color: "red", disabled: purgeGate.disabled, "data-testid": `purge-dir-${entry.dirName}`, onClick: () => onPurge(entry.dirName), children: "Purge" }) }) })] }) })] }));
+        return (_jsxs(Table.Tr, { style: { backgroundColor: 'var(--mantine-color-red-light)' }, children: [_jsx(Table.Td, { children: entry.dirName }), _jsx(Table.Td, { children: _jsx(Badge, { color: "red", variant: "light", children: "Corrupt metadata" }) }), _jsx(Table.Td, { colSpan: 3, children: _jsx(Tooltip, { label: entry.parseError, multiline: true, maw: 400, children: _jsx(Text, { size: "xs", c: "var(--canopy-danger-text)", children: truncate(entry.parseError ?? 'Unknown parse error', 60) }) }) }), _jsx(Table.Td, { children: _jsx(Text, { size: "xs", c: "dimmed", children: entry.metaMtime ?? '—' }) }), _jsx(Table.Td, { children: _jsxs(Group, { gap: "xs", wrap: "nowrap", children: [_jsx(Button, { variant: "light", "data-testid": `repair-dir-${entry.dirName}`, onClick: () => onRepair(entry.dirName), children: "Repair" }), _jsx(PurgeButton, { entry: entry, gate: purgeGate, onPurge: onPurge })] }) })] }));
     }
     // orphan
     const purgeGate = purgeGateFor(entry);
-    return (_jsxs(Table.Tr, { style: { opacity: 0.65 }, children: [_jsx(Table.Td, { children: entry.dirName }), _jsx(Table.Td, { children: _jsx(Badge, { color: "gray", variant: "outline", children: "orphan" }) }), _jsx(Table.Td, { colSpan: 3, children: _jsxs(Text, { size: "xs", c: "dimmed", children: [entry.ageMs !== undefined ? `${formatAgeMs(entry.ageMs)} old` : 'unknown age', " \u00B7", ' ', entry.hasGitDir ? 'has .git' : 'no .git'] }) }), _jsx(Table.Td, { children: _jsx(Text, { size: "xs", c: "dimmed", children: entry.dirMtime ?? '—' }) }), _jsx(Table.Td, { children: _jsx(Tooltip, { label: purgeGate.tooltip, disabled: !purgeGate.disabled, children: _jsx("span", { children: _jsx(Button, { size: "xs", variant: "light", color: "red", disabled: purgeGate.disabled, "data-testid": `purge-dir-${entry.dirName}`, onClick: () => onPurge(entry.dirName), children: "Purge" }) }) }) })] }));
+    return (_jsxs(Table.Tr, { style: { opacity: 0.65 }, children: [_jsx(Table.Td, { children: entry.dirName }), _jsx(Table.Td, { children: _jsx(Badge, { color: "gray", variant: "outline", children: "Orphan" }) }), _jsx(Table.Td, { colSpan: 3, children: _jsxs(Text, { size: "xs", c: "dimmed", children: [entry.ageMs !== undefined ? `${formatAgeMs(entry.ageMs)} old` : 'unknown age', " \u00B7", ' ', entry.hasGitDir ? 'has .git' : 'no .git'] }) }), _jsx(Table.Td, { children: _jsx(Text, { size: "xs", c: "dimmed", children: entry.dirMtime ?? '—' }) }), _jsx(Table.Td, { children: _jsx(PurgeButton, { entry: entry, gate: purgeGate, onPurge: onPurge }) })] }));
 }

package/dist/editor/admin/useSystemHealth.d.ts

@@ -1,7 +1,16 @@
 import type { AdminStatusData, AdminTasksData, ListAdminTasksParams, DeleteTaskParams } from '../../api/admin.js';
 import type { BranchHealthData } from '../../api/admin-branch-health.js';
+import type { DuplicateIdScan } from '../../branch-health.js';
 export type AdminTaskStatus = ListAdminTasksParams['status'];
 export type DeletableTaskStatus = DeleteTaskParams['status'];
+/** The last completed duplicate-ID scan (`GET /admin/branch-health?duplicates=1`). */
+interface DuplicateIdScanResult {
+    /** Healthy branches only, by dirName. A healthy row missing here was not scanned. */
+    byDir: Record<string, DuplicateIdScan>;
+    /** The server's time budget ran out before every healthy branch was scanned. */
+    truncated: boolean;
+    generatedAt: string;
+}
 export interface UseSystemHealthOptions {
     /**
      * Whether the System Health panel is currently open. Data loads (and
@@ -25,6 +34,14 @@ export interface UseSystemHealthReturn {
     setTaskStatus: (status: AdminTaskStatus) => void;
     branchHealth: BranchHealthData | null;
     branchHealthLoading: boolean;
+    /** Null until a scan completes, and after a scan request fails. */
+    duplicateIdScan: DuplicateIdScanResult | null;
+    duplicateIdScanLoading: boolean;
+    duplicateIdScanError: string | null;
+    /** Runs the duplicate-ID scan. */
+    checkDuplicateIds: () => Promise<void>;
+    /** Archives the branch's duplicate files, then re-runs the scan. */
+    repairDuplicateIds: (dirName: string) => Promise<void>;
     /** Last fetch error across status/tasks/branchHealth, if any. */
     error: string | null;
     /** Refetches status, tasks (at the current taskStatus), and branchHealth. */
@@ -36,3 +53,4 @@ export interface UseSystemHealthReturn {
     markMerged: (branchName: string) => Promise<void>;
 }
 export declare function useSystemHealth(options: UseSystemHealthOptions): UseSystemHealthReturn;
+export {};

package/dist/editor/admin/useSystemHealth.js

@@ -6,6 +6,10 @@
  * then refresh()), but also polls every 30s while open (cleared on
  * close/unmount) since queue depth and worker liveness go stale quickly and
  * the panel has no other way to catch a worker recovering or a task finishing.
+ *
+ * The duplicate-ID scan is the exception: it reads every healthy branch's whole
+ * content tree, so it runs on open, on request, and after a duplicate repair,
+ * never on the poll.
  */
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { notifications } from '@mantine/notifications';
@@ -28,6 +32,9 @@ export function useSystemHealth(options) {
     const [taskStatus, setTaskStatusState] = useState('failed');
     const [branchHealth, setBranchHealth] = useState(null);
     const [branchHealthLoading, setBranchHealthLoading] = useState(false);
+    const [duplicateIdScan, setDuplicateIdScan] = useState(null);
+    const [duplicateIdScanLoading, setDuplicateIdScanLoading] = useState(false);
+    const [duplicateIdScanError, setDuplicateIdScanError] = useState(null);
     const [error, setError] = useState(null);
     // refresh() has no status argument, so it needs the CURRENT taskStatus
     // without depending on it (that would tear down/rebuild the poll interval
@@ -74,7 +81,7 @@ export function useSystemHealth(options) {
     const fetchBranchHealth = useCallback(async () => {
         setBranchHealthLoading(true);
         try {
-            const result = await apiClient.admin.branchHealth();
+            const result = await apiClient.admin.branchHealth({});
             if (!result.ok)
                 throw new Error(result.error || 'Failed to load branch health');
             setBranchHealth(result.data ?? null);
@@ -87,6 +94,43 @@ export function useSystemHealth(options) {
             setBranchHealthLoading(false);
         }
     }, [apiClient]);
+    // Only the latest scan request may write state: a repair's re-scan can
+    // overlap the on-open scan, and the older response would bring back
+    // duplicates the repair just archived.
+    const duplicateScanSeq = useRef(0);
+    const checkDuplicateIds = useCallback(async () => {
+        const seq = ++duplicateScanSeq.current;
+        setDuplicateIdScanLoading(true);
+        try {
+            const result = await apiClient.admin.branchHealth({ duplicates: '1' });
+            if (seq !== duplicateScanSeq.current)
+                return;
+            if (!result.ok || !result.data?.duplicateIdScan) {
+                throw new Error(result.error || 'Failed to check for duplicate content IDs');
+            }
+            const byDir = {};
+            for (const entry of result.data.entries) {
+                if (entry.duplicateIdScan)
+                    byDir[entry.dirName] = entry.duplicateIdScan;
+            }
+            setDuplicateIdScan({
+                byDir,
+                truncated: result.data.duplicateIdScan.truncated,
+                generatedAt: result.data.generatedAt,
+            });
+            setDuplicateIdScanError(null);
+        }
+        catch (err) {
+            if (seq !== duplicateScanSeq.current)
+                return;
+            setDuplicateIdScan(null);
+            setDuplicateIdScanError(err instanceof Error ? err.message : 'Failed to check for duplicate content IDs');
+        }
+        finally {
+            if (seq === duplicateScanSeq.current)
+                setDuplicateIdScanLoading(false);
+        }
+    }, [apiClient]);
     const refresh = useCallback(async () => {
         await Promise.all([fetchStatus(), fetchTasks(taskStatusRef.current), fetchBranchHealth()]);
     }, [fetchStatus, fetchTasks, fetchBranchHealth]);
@@ -101,6 +145,7 @@ export function useSystemHealth(options) {
         if (!options.isOpen)
             return;
         refresh();
+        void checkDuplicateIds();
         const interval = setInterval(() => {
             refresh();
         }, POLL_INTERVAL_MS);
@@ -168,6 +213,25 @@ export function useSystemHealth(options) {
             notifications.show({ message, color: 'red' });
         }
     }, [apiClient, refresh]);
+    const repairDuplicateIds = useCallback(async (dirName) => {
+        try {
+            const result = await apiClient.admin.repairContentDuplicates({ dirName });
+            if (!result.ok)
+                throw new Error(result.error || 'Failed to archive duplicate files');
+            const archived = (result.data?.resolved ?? []).reduce((n, r) => n + r.archivedAs.length, 0);
+            notifications.show({
+                message: `Archived ${archived} duplicate file${archived === 1 ? '' : 's'}`,
+                color: 'green',
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to archive duplicate files';
+            notifications.show({ message, color: 'red' });
+        }
+        // Re-scan on failure too: a 409 or a partial repair leaves the branch in
+        // a state the last scan no longer describes.
+        await checkDuplicateIds();
+    }, [apiClient, checkDuplicateIds]);
     const markMerged = useCallback(async (branchName) => {
         try {
             const result = await apiClient.workflow.markMerged({ branch: branchName });
@@ -191,6 +255,11 @@ export function useSystemHealth(options) {
         setTaskStatus,
         branchHealth,
         branchHealthLoading,
+        duplicateIdScan,
+        duplicateIdScanLoading,
+        duplicateIdScanError,
+        checkDuplicateIds,
+        repairDuplicateIds,
         error,
         refresh,
         retryTask,

package/dist/editor/branch-status.d.ts

@@ -0,0 +1,17 @@
+import type { BranchStatus } from '../types.js';
+export interface BranchStatusPresentation {
+    label: string;
+    color: string;
+    variant: 'light' | 'outline';
+}
+/** @internal Exported for tests. */
+export declare const PROTECTED_BRANCH_PRESENTATION: BranchStatusPresentation;
+/** @internal Exported for tests. */
+export declare const BRANCH_STATUS_PRESENTATION: Record<BranchStatus, BranchStatusPresentation>;
+/**
+ * The badge for a branch: the protected base branch reads "Protected" whatever its workflow
+ * status, so a base branch never advertises a state it cannot act on. `status` is a string
+ * because server data is untyped at runtime; an unrecognised one shows as itself, neutrally.
+ * Returns undefined when there is nothing to show.
+ */
+export declare function branchStatusPresentation(status: string | undefined, isProtected?: boolean): BranchStatusPresentation | undefined;

package/dist/editor/branch-status.js

@@ -0,0 +1,29 @@
+/** @internal Exported for tests. */
+export const PROTECTED_BRANCH_PRESENTATION = {
+    label: 'Protected',
+    color: 'neutral',
+    variant: 'outline',
+};
+/** @internal Exported for tests. */
+export const BRANCH_STATUS_PRESENTATION = {
+    editing: { label: 'Editing', color: 'brand', variant: 'light' },
+    submitted: { label: 'In review', color: 'green', variant: 'light' },
+    approved: { label: 'Approved', color: 'teal', variant: 'light' },
+    archived: { label: 'Archived', color: 'gray', variant: 'light' },
+};
+const isKnownStatus = (status) => Object.prototype.hasOwnProperty.call(BRANCH_STATUS_PRESENTATION, status);
+/**
+ * The badge for a branch: the protected base branch reads "Protected" whatever its workflow
+ * status, so a base branch never advertises a state it cannot act on. `status` is a string
+ * because server data is untyped at runtime; an unrecognised one shows as itself, neutrally.
+ * Returns undefined when there is nothing to show.
+ */
+export function branchStatusPresentation(status, isProtected = false) {
+    if (isProtected)
+        return PROTECTED_BRANCH_PRESENTATION;
+    if (!status)
+        return undefined;
+    if (isKnownStatus(status))
+        return BRANCH_STATUS_PRESENTATION[status];
+    return { label: status, color: 'gray', variant: 'light' };
+}

package/dist/editor/canopy-path.d.ts

@@ -1,16 +1,19 @@
+/**
+ * The one spelling of a field path, `blocks[0].title`, for the form's fields, the preview's
+ * marks and comment threads. A digits-only segment is always a list index (`[0]` or `.0`):
+ * schemas refuse field names `isPathFieldName` rejects, since no path could spell them.
+ */
 export type CanopyPathSegment = string | number;
+export declare const isPathFieldName: (name: string) => boolean;
 /**
  * Convert a list of path segments into the canonical CanopyCMS path string.
  * Arrays are rendered with bracket notation (e.g., blocks[0].title).
  */
-export declare const formatCanopyPath: (segments: CanopyPathSegment[]) => string;
+export declare const formatCanopyPath: (segments: readonly CanopyPathSegment[]) => string;
 /**
  * Parse a CanopyCMS path string into segments. Supports bracketed array
  * indices and dotted segments (e.g., blocks.0.title or blocks[0].title).
  */
 export declare const parseCanopyPath: (path: string) => CanopyPathSegment[];
-/**
- * Normalize any supported path input (string or segments) into the
- * canonical bracketed representation.
- */
-export declare const normalizeCanopyPath: (input: string | CanopyPathSegment[]) => string;
+/** The canonical string for a path; segments are re-parsed, so `['a', '0']` is `a[0]`. */
+export declare const normalizeCanopyPath: (input: string | readonly CanopyPathSegment[]) => string;