cli-jaw 2.0.10 → 2.0.16

package/public/manager/src/dashboard-settings/DashboardSettingsSidebar.tsx

@@ -1,6 +1,6 @@
 import type { DashboardLocale } from '../types';
 
-type DashboardSettingsSection = 'display' | 'activity' | 'embedding';
+type DashboardSettingsSection = 'display' | 'activity' | 'developer' | 'embedding';
 
 type DashboardSettingsSidebarProps = {
     activeSection: DashboardSettingsSection;
@@ -16,6 +16,7 @@ const COPY = {
         sections: {
             display: { label: '사이드바 행', hint: '밀도와 행 안 컨트롤' },
             activity: { label: '미리보기와 활동', hint: '제목 출처와 기본값' },
+            developer: { label: '개발 도구', hint: 'Git diff 기본값' },
             embedding: { label: '임베딩 검색', hint: 'Provider와 벡터 인덱스' },
         },
     },
@@ -26,6 +27,7 @@ const COPY = {
         sections: {
             display: { label: 'Sidebar rows', hint: 'Density and inline controls' },
             activity: { label: 'Preview & activity', hint: 'Title source and defaults' },
+            developer: { label: 'Developer tools', hint: 'Git diff defaults' },
             embedding: { label: 'Embedding search', hint: 'Provider and vector index' },
         },
     },
@@ -36,6 +38,7 @@ const COPY = {
         sections: {
             display: { label: '侧边栏列表', hint: '密度与行内控件' },
             activity: { label: '预览与活动', hint: '标题来源与默认值' },
+            developer: { label: '开发工具', hint: 'Git diff 默认值' },
             embedding: { label: '嵌入搜索', hint: 'Provider 与向量索引' },
         },
     },
@@ -46,12 +49,13 @@ const COPY = {
         sections: {
             display: { label: 'サイドバーの行', hint: '密度と行内コントロール' },
             activity: { label: 'プレビューとアクティビティ', hint: 'タイトルの取得元と既定値' },
+            developer: { label: '開発ツール', hint: 'Git diff の既定値' },
             embedding: { label: 'エンベディング検索', hint: 'Provider とベクトルインデックス' },
         },
     },
 } as const;
 
-const SECTION_IDS: DashboardSettingsSection[] = ['display', 'activity', 'embedding'];
+const SECTION_IDS: DashboardSettingsSection[] = ['display', 'activity', 'developer', 'embedding'];
 
 export function DashboardSettingsSidebar(props: DashboardSettingsSidebarProps) {
     const copy = COPY[props.locale] || COPY.ko;

package/public/manager/src/dashboard-settings/DashboardSettingsWorkspace.tsx

@@ -1,5 +1,6 @@
 import { Suspense, lazy, useEffect, type ReactNode } from 'react';
 import { formatShortcut, MANAGER_SHORTCUT_ACTIONS } from '../manager-shortcuts';
+import { DashboardDeveloperSettingsSection } from './DashboardDeveloperSettingsSection';
 
 const LazyEmbedding = lazy(() => import('./DashboardEmbeddingSection').then(m => ({ default: m.DashboardEmbeddingSection })));
 import { HelpTopicButton } from '../help/HelpTopicButton';
@@ -8,7 +9,7 @@ import type { DashboardLocale, DashboardRegistryUi, DashboardShortcutAction } fr
 import type { DashboardActivityTitleSupport } from './activity-title-support';
 
 type DashboardSettingsWorkspaceProps = {
-    activeSection: 'display' | 'activity' | 'embedding';
+    activeSection: 'display' | 'activity' | 'developer' | 'embedding';
     ui: DashboardRegistryUi;
     titleSupport: DashboardActivityTitleSupport;
     onUiPatch: (patch: Partial<DashboardRegistryUi>) => void;
@@ -570,6 +571,8 @@ export function DashboardSettingsWorkspace(props: DashboardSettingsWorkspaceProp
                     </header>
                     <TitleSupportSummary support={props.titleSupport} locale={locale} />
                 </section>
+            ) : props.activeSection === 'developer' ? (
+                <DashboardDeveloperSettingsSection locale={locale} ui={props.ui} onUiPatch={props.onUiPatch} />
             ) : (
                 <section className="dashboard-settings-section">
                     <header>

package/public/manager/src/dashboard-settings/dashboard-settings-ui.ts

@@ -1,4 +1,5 @@
 import type { useDashboardView } from '../hooks/useDashboardView';
+import { cloneNotesGraphSettings, DEFAULT_NOTES_GRAPH_SETTINGS } from '../notes/graph/notes-graph-settings';
 import type { DashboardRegistryUi, DashboardUiTheme } from '../types';
 
 type DashboardViewState = ReturnType<typeof useDashboardView>;
@@ -22,12 +23,19 @@ export function dashboardSettingsUiFromView(
         notesViewMode: view.notesViewMode,
         notesAuthoringMode: view.notesAuthoringMode,
         notesWordWrap: view.notesWordWrap,
+        notesVimMode: view.notesVimMode,
         notesTreeWidth: view.notesTreeWidth,
+        notesGraphSettings: view.notesGraphSettings ?? cloneNotesGraphSettings(DEFAULT_NOTES_GRAPH_SETTINGS),
         showLatestActivityTitles: view.showLatestActivityTitles,
         showInlineLabelEditor: view.showInlineLabelEditor,
         showSidebarRuntimeLine: view.showSidebarRuntimeLine,
         showSelectedRowActions: view.showSelectedRowActions,
         dashboardShortcutsEnabled: view.dashboardShortcutsEnabled,
         dashboardShortcutKeymap: view.dashboardShortcutKeymap,
+        diffRootPolicy: view.diffRootPolicy,
+        diffPinnedRootByPort: view.diffPinnedRootByPort,
+        diffDefaultMode: view.diffDefaultMode,
+        diffBaseRef: view.diffBaseRef,
+        diffIncludeUntracked: view.diffIncludeUntracked,
     };
 }

package/public/manager/src/desktop-link.tsx

@@ -1,4 +1,5 @@
 import { useEffect, useState } from 'react';
+import { isElectron } from './panels/desktop-bridge';
 
 type DesktopStatus = {
     inDesktop: boolean;
@@ -18,10 +19,12 @@ function openCurrentDashboardPath(): void {
 }
 
 export function DesktopLink() {
+    const inElectron = isElectron();
     const [status, setStatus] = useState<DesktopStatus | null>(null);
     const [failed, setFailed] = useState(false);
 
     useEffect(() => {
+        if (inElectron) return;
         let cancelled = false;
         fetchDesktopStatus()
             .then((next) => {
@@ -33,7 +36,9 @@ export function DesktopLink() {
         return () => {
             cancelled = true;
         };
-    }, []);
+    }, [inElectron]);
+
+    if (inElectron) return null;
 
     if (status?.inDesktop) {
         return (

package/public/manager/src/diff-panel/DiffPanel.tsx

@@ -0,0 +1,219 @@
+import { useCallback, useEffect, useMemo, useState, type ReactNode } from 'react';
+import { getDesktop, type DiffBridgeApi, type DiffOptions, type DiffResolvedRoot } from '../panels/desktop-bridge';
+import type { DashboardDiffMode, DashboardInstance, DashboardRegistryUi } from '../types';
+import { createDashboardGitDiffClient } from './diff-client';
+import { buildDiffRootCandidates } from './diff-root-candidates';
+import './diff-panel.css';
+
+type DiffFileSummary = {
+    path: string;
+    status: string;
+    insertions: number;
+    deletions: number;
+};
+
+type DiffSettings = Pick<DashboardRegistryUi,
+    'diffRootPolicy' | 'diffPinnedRootByPort' | 'diffDefaultMode' | 'diffBaseRef' | 'diffIncludeUntracked'
+>;
+
+type DiffPanelProps = {
+    selectedInstance: DashboardInstance | null;
+    settings: DiffSettings;
+    onSettingsPatch?: (patch: Partial<DashboardRegistryUi>) => void;
+};
+
+const DIFF_MODES: DashboardDiffMode[] = ['unstaged', 'staged', 'head', 'base'];
+
+function getDiffLineClass(line: string): string {
+    if (line.startsWith('@@')) return 'diff-line-hunk';
+    if (line.startsWith('diff ') || line.startsWith('index ')) return 'diff-line-meta';
+    if (line.startsWith('--- ') || line.startsWith('+++ ')) return 'diff-line-meta';
+    if (line.startsWith('+')) return 'diff-line-add';
+    if (line.startsWith('-')) return 'diff-line-del';
+    return '';
+}
+
+function renderDiffLines(text: string): ReactNode {
+    if (!text) return null;
+    return text.split('\n').map((line, i) => {
+        const cls = getDiffLineClass(line);
+        return <span key={i} className={`diff-line${cls ? ` ${cls}` : ''}`}>{line}{'\n'}</span>;
+    });
+}
+
+function getDiffBridge(): DiffBridgeApi | null {
+    return getDesktop()?.diff ?? null;
+}
+
+function diffOptions(settings: DiffSettings): DiffOptions {
+    const options: DiffOptions = {
+        mode: settings.diffDefaultMode,
+        includeUntracked: settings.diffIncludeUntracked,
+    };
+    if (settings.diffDefaultMode === 'base') options.ref = settings.diffBaseRef.trim() || 'HEAD';
+    return options;
+}
+
+function rootTitle(root: DiffResolvedRoot): string {
+    const suffix = root.branch ?? root.head ?? 'detached';
+    return `${root.label}: ${root.root} (${suffix}${root.dirty ? ', dirty' : ''})`;
+}
+
+export function DiffPanel(props: DiffPanelProps) {
+    const desktopBridge = getDiffBridge();
+    const bridge = useMemo(
+        () => desktopBridge ?? createDashboardGitDiffClient(props.selectedInstance, props.settings),
+        [desktopBridge, props.selectedInstance, props.settings],
+    );
+    const [repoCandidates, setRepoCandidates] = useState<DiffResolvedRoot[]>([]);
+    const [repoRoot, setRepoRoot] = useState<string | null>(null);
+    const [files, setFiles] = useState<DiffFileSummary[]>([]);
+    const [selectedFile, setSelectedFile] = useState<string | null>(null);
+    const [diffContent, setDiffContent] = useState<string>('');
+    const [error, setError] = useState<string | null>(null);
+    const selectedInstanceKey = `${props.selectedInstance?.port ?? 'none'}:${props.selectedInstance?.workingDir ?? ''}:${props.selectedInstance?.projectDirs?.join('\0') ?? ''}`;
+    const options = useMemo(() => diffOptions(props.settings), [
+        props.settings.diffDefaultMode,
+        props.settings.diffBaseRef,
+        props.settings.diffIncludeUntracked,
+    ]);
+    const selectedRoot = repoCandidates.find(candidate => candidate.root === repoRoot) ?? null;
+
+    const loadRepoCandidates = useCallback(async () => {
+        if (!bridge) return;
+        const desktop = getDesktop();
+        const home = desktop?.getHomePath?.() || '/tmp';
+        const candidates = buildDiffRootCandidates(props.selectedInstance, home, {
+            diffRootPolicy: props.settings.diffRootPolicy,
+            diffPinnedRootByPort: props.settings.diffPinnedRootByPort,
+        });
+        const result = await bridge.getRepoCandidates(candidates);
+        if (!result.ok) {
+            setError(result.error ?? 'Failed to resolve git repositories');
+            return;
+        }
+        const roots = result.candidates ?? [];
+        setRepoCandidates(roots);
+        setRepoRoot(current => current && roots.some(root => root.root === current) ? current : roots[0]?.root ?? null);
+        if (roots.length === 0) setError('No git repository found from the selected instance roots.');
+        else setError(null);
+    }, [bridge, selectedInstanceKey, props.settings.diffRootPolicy, props.settings.diffPinnedRootByPort]);
+
+    const loadSummary = useCallback(async () => {
+        if (!bridge || !repoRoot) return;
+        const result = await bridge.getDiffSummary(repoRoot, options);
+        if (result.ok && result.files) {
+            setFiles(result.files);
+            setSelectedFile(current => current && result.files?.some(file => file.path === current) ? current : result.files?.[0]?.path ?? null);
+            setError(null);
+        } else {
+            setFiles([]);
+            setSelectedFile(null);
+            setError(result.error ?? 'Failed to get diff summary');
+        }
+    }, [bridge, options, repoRoot]);
+
+    useEffect(() => { void loadRepoCandidates(); }, [loadRepoCandidates]);
+    useEffect(() => { void loadSummary(); }, [loadSummary]);
+
+    useEffect(() => {
+        if (!bridge || !repoRoot || !selectedFile) {
+            setDiffContent('');
+            return;
+        }
+        void (async () => {
+            const result = await bridge.getFileDiff(repoRoot, selectedFile, options);
+            if (result.ok && result.diff !== undefined) setDiffContent(result.diff || 'No textual diff for this file.');
+            else setDiffContent(`Error: ${result.error ?? 'unknown'}`);
+        })();
+    }, [bridge, options, repoRoot, selectedFile]);
+
+    function handleRootChange(root: string): void {
+        setRepoRoot(root);
+        setSelectedFile(null);
+        const port = props.selectedInstance?.port;
+        if (port == null) return;
+        props.onSettingsPatch?.({
+            diffPinnedRootByPort: {
+                ...props.settings.diffPinnedRootByPort,
+                [String(port)]: root,
+            },
+        });
+    }
+
+    function handleModeChange(mode: DashboardDiffMode): void {
+        props.onSettingsPatch?.({ diffDefaultMode: mode });
+    }
+
+    return (
+        <div className="diff-panel">
+            <div className="diff-toolbar">
+                <select
+                    className="diff-root-select"
+                    value={repoRoot ?? ''}
+                    aria-label="Git repository root"
+                    onChange={(event) => handleRootChange(event.currentTarget.value)}
+                >
+                    {repoCandidates.map(candidate => (
+                        <option key={candidate.root} value={candidate.root}>{rootTitle(candidate)}</option>
+                    ))}
+                    {repoCandidates.length === 0 && <option value="">No repo</option>}
+                </select>
+                <span className="diff-head-chip">{selectedRoot?.branch ?? selectedRoot?.head ?? 'no repo'}</span>
+                <button type="button" className="diff-refresh" onClick={() => void loadRepoCandidates()}>Refresh</button>
+            </div>
+            <div className="diff-toolbar diff-options">
+                <div className="diff-mode-group" aria-label="Diff mode">
+                    {DIFF_MODES.map(mode => (
+                        <button
+                            key={mode}
+                            type="button"
+                            className={`diff-mode-button${props.settings.diffDefaultMode === mode ? ' is-active' : ''}`}
+                            aria-pressed={props.settings.diffDefaultMode === mode}
+                            onClick={() => handleModeChange(mode)}
+                        >
+                            {mode === 'head' ? 'HEAD' : mode === 'base' ? 'Base' : mode}
+                        </button>
+                    ))}
+                </div>
+                <input
+                    className="diff-ref-input"
+                    type="text"
+                    value={props.settings.diffBaseRef}
+                    aria-label="Base ref"
+                    disabled={props.settings.diffDefaultMode !== 'base'}
+                    onChange={(event) => props.onSettingsPatch?.({ diffBaseRef: event.currentTarget.value })}
+                />
+                <label className="diff-untracked-toggle">
+                    <input
+                        type="checkbox"
+                        checked={props.settings.diffIncludeUntracked}
+                        onChange={(event) => props.onSettingsPatch?.({ diffIncludeUntracked: event.currentTarget.checked })}
+                    />
+                    <span>untracked</span>
+                </label>
+            </div>
+            {error && <div className="diff-error">{error}</div>}
+            <div className="diff-body">
+                <div className="diff-file-list">
+                    {files.map(f => (
+                        <button key={f.path} type="button"
+                            className={`diff-file-item ${f.path === selectedFile ? 'is-selected' : ''} diff-status-${f.status}`}
+                            onClick={() => setSelectedFile(f.path)}>
+                            <span className="diff-file-name">{f.path}</span>
+                            <span className="diff-file-stats">
+                                {f.insertions > 0 && <span className="diff-ins">+{f.insertions}</span>}
+                                {f.deletions > 0 && <span className="diff-del">-{f.deletions}</span>}
+                                {f.status === 'untracked' && <span className="diff-ins">new</span>}
+                            </span>
+                        </button>
+                    ))}
+                    {files.length === 0 && !error && <div className="diff-empty">No changes</div>}
+                </div>
+                <div className="diff-content">
+                    <pre className="diff-pre">{renderDiffLines(diffContent)}</pre>
+                </div>
+            </div>
+        </div>
+    );
+}

package/public/manager/src/diff-panel/diff-client.ts

@@ -0,0 +1,46 @@
+import type { DiffBridgeApi, DiffOptions, DiffRootCandidate, DiffResolvedRoot } from '../panels/desktop-bridge';
+import type { DashboardInstance, DashboardRegistryUi } from '../types';
+
+type DiffSettings = Pick<DashboardRegistryUi, 'diffRootPolicy' | 'diffPinnedRootByPort'>;
+
+async function postJson<T>(path: string, body: unknown): Promise<T> {
+    const response = await fetch(path, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    const data = await response.json().catch(() => null) as T & { ok?: boolean; error?: string } | null;
+    if (!response.ok || !data) return { ok: false, error: data?.error ?? `request failed: ${response.status}` } as T;
+    return data as T;
+}
+
+function baseBody(instance: DashboardInstance | null, settings: DiffSettings): { selectedInstancePort: number | null; settings: DiffSettings } {
+    return {
+        selectedInstancePort: instance?.port ?? null,
+        settings: {
+            diffRootPolicy: settings.diffRootPolicy,
+            diffPinnedRootByPort: settings.diffPinnedRootByPort,
+        },
+    };
+}
+
+export function createDashboardGitDiffClient(
+    instance: DashboardInstance | null,
+    settings: DiffSettings,
+): DiffBridgeApi {
+    return {
+        getRepoRoot: async () => ({ ok: false, error: 'Repository root resolution is server-derived in web mode' }),
+        getRepoCandidates: async (_candidates: DiffRootCandidate[]) => postJson<{ ok: boolean; candidates?: DiffResolvedRoot[]; error?: string }>(
+            '/api/dashboard/git/repo-candidates',
+            baseBody(instance, settings),
+        ),
+        getDiffSummary: async (repoRoot: string, options: DiffOptions) => postJson(
+            '/api/dashboard/git/diff-summary',
+            { ...baseBody(instance, settings), repoRoot, options },
+        ),
+        getFileDiff: async (repoRoot: string, filePath: string, options: DiffOptions) => postJson(
+            '/api/dashboard/git/file-diff',
+            { ...baseBody(instance, settings), repoRoot, filePath, options },
+        ),
+    };
+}

package/public/manager/src/diff-panel/diff-panel.css

@@ -0,0 +1,163 @@
+.diff-panel {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    font-size: 12px;
+}
+.diff-unavailable {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--text-dim);
+}
+.diff-toolbar {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 6px 10px;
+    border-bottom: 1px solid var(--border-subtle);
+    flex-shrink: 0;
+}
+.diff-options {
+    gap: 6px;
+    padding-top: 5px;
+    padding-bottom: 5px;
+}
+.diff-repo-label {
+    flex: 1;
+    font-size: 11px;
+    color: var(--text-dim);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+.diff-root-select {
+    min-width: 0;
+    flex: 1;
+    height: 24px;
+    border: 1px solid var(--border-subtle);
+    border-radius: 4px;
+    background: var(--bg-panel);
+    color: var(--text-base);
+    font-size: 11px;
+}
+.diff-head-chip {
+    max-width: 90px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    color: var(--text-dim);
+    font-size: 10px;
+    font-family: 'SF Mono', 'Menlo', monospace;
+}
+.diff-refresh {
+    all: unset;
+    cursor: pointer;
+    padding: 2px 6px;
+    border-radius: 3px;
+    color: var(--text-dim);
+}
+.diff-refresh:hover { background: var(--bg-hover); color: var(--text-base); }
+.diff-mode-group {
+    display: flex;
+    min-width: 0;
+    border: 1px solid var(--border-subtle);
+    border-radius: 4px;
+    overflow: hidden;
+}
+.diff-mode-button {
+    all: unset;
+    cursor: pointer;
+    padding: 3px 6px;
+    color: var(--text-dim);
+    font-size: 10px;
+    line-height: 16px;
+}
+.diff-mode-button:hover,
+.diff-mode-button.is-active {
+    background: var(--bg-active);
+    color: var(--text-base);
+}
+.diff-ref-input {
+    width: 78px;
+    min-width: 58px;
+    height: 22px;
+    border: 1px solid var(--border-subtle);
+    border-radius: 4px;
+    background: var(--bg-panel);
+    color: var(--text-base);
+    font-size: 10px;
+}
+.diff-untracked-toggle {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    color: var(--text-dim);
+    font-size: 10px;
+    white-space: nowrap;
+}
+.diff-error {
+    padding: 8px 10px;
+    font-size: 11px;
+    color: var(--status-error);
+    background: var(--bg-error-subtle, rgba(255,0,0,0.05));
+}
+.diff-body {
+    flex: 1;
+    display: flex;
+    min-height: 0;
+    overflow: hidden;
+}
+.diff-file-list {
+    width: 200px;
+    min-width: 120px;
+    border-right: 1px solid var(--border-subtle);
+    overflow-y: auto;
+    flex-shrink: 0;
+}
+.diff-file-item {
+    all: unset;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 4px;
+    padding: 4px 8px;
+    font-size: 11px;
+    color: var(--text-base);
+    width: 100%;
+    box-sizing: border-box;
+}
+.diff-file-item:hover { background: var(--bg-hover); }
+.diff-file-item.is-selected { background: var(--bg-active); }
+.diff-file-name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; flex: 1; }
+.diff-file-stats { display: flex; gap: 4px; flex-shrink: 0; font-size: 10px; }
+.diff-ins { color: var(--status-success); }
+.diff-del { color: var(--status-error); }
+.diff-status-added .diff-file-name { color: var(--status-success); }
+.diff-status-deleted .diff-file-name { color: var(--status-error); }
+.diff-empty {
+    padding: 12px;
+    color: var(--text-dim);
+    text-align: center;
+    font-size: 11px;
+}
+.diff-content {
+    flex: 1;
+    min-width: 0;
+    overflow: auto;
+}
+.diff-pre {
+    margin: 0;
+    padding: 8px;
+    font-family: 'SF Mono', 'Menlo', monospace;
+    font-size: 12px;
+    line-height: 1.5;
+    white-space: pre-wrap;
+    word-break: break-all;
+}
+.diff-line { display: block; padding: 0 4px; }
+.diff-line-add { color: var(--status-success); background: color-mix(in srgb, var(--status-success) 10%, transparent); }
+.diff-line-del { color: var(--status-error); background: color-mix(in srgb, var(--status-error) 10%, transparent); }
+.diff-line-hunk { color: var(--accent); font-weight: 500; background: color-mix(in srgb, var(--accent) 6%, transparent); }
+.diff-line-meta { color: var(--text-dim); font-weight: 500; }

package/public/manager/src/diff-panel/diff-root-candidates.ts

@@ -0,0 +1,54 @@
+import type { DashboardDiffRootPolicy, DashboardInstance } from '../types';
+import type { DiffRootCandidate } from '../panels/desktop-bridge';
+
+type DiffRootSettings = {
+    diffRootPolicy: DashboardDiffRootPolicy;
+    diffPinnedRootByPort: Record<string, string>;
+};
+
+function pushCandidate(
+    candidates: DiffRootCandidate[],
+    seen: Set<string>,
+    candidate: DiffRootCandidate,
+): void {
+    const path = candidate.path.trim();
+    if (!path || seen.has(path)) return;
+    seen.add(path);
+    candidates.push({ ...candidate, path });
+}
+
+export function buildDiffRootCandidates(
+    instance: DashboardInstance | null,
+    homePath: string,
+    settings: DiffRootSettings,
+): DiffRootCandidate[] {
+    const candidates: DiffRootCandidate[] = [];
+    const seen = new Set<string>();
+    const port = instance?.port == null ? null : String(instance.port);
+    const pinned = port ? settings.diffPinnedRootByPort[port] : null;
+    const projectDirs = instance?.projectDirs?.filter(Boolean) ?? [];
+    const workingDir = instance?.workingDir ?? null;
+
+    if (settings.diffRootPolicy === 'manual' && pinned) {
+        pushCandidate(candidates, seen, { path: pinned, label: 'Pinned root', source: 'pinned' });
+    }
+
+    const orderedProjectDirs = projectDirs.map((path, index) => ({
+        path,
+        label: index === 0 ? 'Project root' : `Project root ${index + 1}`,
+        source: 'project' as const,
+    }));
+    const workingCandidate = workingDir
+        ? [{ path: workingDir, label: 'Working dir', source: 'working-dir' as const }]
+        : [];
+    const ordered = settings.diffRootPolicy === 'working-dir-first'
+        ? [...workingCandidate, ...orderedProjectDirs]
+        : [...orderedProjectDirs, ...workingCandidate];
+
+    for (const candidate of ordered) pushCandidate(candidates, seen, candidate);
+    if (settings.diffRootPolicy !== 'manual' && pinned) {
+        pushCandidate(candidates, seen, { path: pinned, label: 'Pinned root', source: 'pinned' });
+    }
+    if (homePath) pushCandidate(candidates, seen, { path: homePath, label: 'Home fallback', source: 'home' });
+    return candidates;
+}