diff --git a/OrchestratorIDE.Avalonia.HeadlessTests/Cf5TestHarness.cs b/OrchestratorIDE.Avalonia.HeadlessTests/Cf5TestHarness.cs
new file mode 100644
index 00000000..cc301e05
--- /dev/null
+++ b/OrchestratorIDE.Avalonia.HeadlessTests/Cf5TestHarness.cs
@@ -0,0 +1,145 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+using System.Runtime.CompilerServices;
+using OrchestratorIDE.Core.Runtime;
+using OrchestratorIDE.Models;
+using OrchestratorIDE.Services.ContextFabric;
+using OrchestratorIDE.Services.Data;
+using OrchestratorIDE.UI.ViewModels;
+
+namespace OrchestratorIDE.Avalonia.HeadlessTests;
+
+/// <summary>
+/// Shared CF-5 wiring for headless ChatPanel tests — builds a real in-memory corpus/document
+/// plus the full FabricAskService/FabricIndexingOrchestrator/LibraryViewModel stack against a
+/// scripted IRoleRuntime, mirroring OrchestratorIDE.UnitTests' ContextFabricAskServiceTests
+/// harness shape (kept local here since HeadlessTests can't reference UnitTests' internal
+/// fakes).
+/// </summary>
+internal sealed class Cf5TestHarness : IDisposable
+{
+    public SqliteStore Store { get; }
+    public FabricLibraryRepository Library { get; }
+    public DocumentGraphRepository Graph { get; }
+    public FabricCorpusEntry Corpus { get; }
+    public FabricDocumentEntry Document { get; }
+    public string WorkspaceRoot { get; }
+
+    private Cf5TestHarness(
+        SqliteStore store, FabricLibraryRepository library, DocumentGraphRepository graph,
+        FabricCorpusEntry corpus, FabricDocumentEntry document, string workspaceRoot)
+    {
+        Store = store;
+        Library = library;
+        Graph = graph;
+        Corpus = corpus;
+        Document = document;
+        WorkspaceRoot = workspaceRoot;
+    }
+
+    public static Cf5TestHarness Create(string quote = "LANTERN is the assigned call sign.")
+    {
+        var store = new SqliteStore(":memory:");
+        store.Initialize();
+        var library = new FabricLibraryRepository(store);
+        var graph = new DocumentGraphRepository(store);
+        var corpus = library.CreateCorpus("cf5-headless-corpus", "CF-5 headless lane");
+        var now = DateTimeOffset.UtcNow;
+        var document = new FabricDocumentEntry(
+            "cf5-headless-doc",
+            corpus.CorpusId,
+            "source-digest",
+            "normalized-digest",
+            "CF-5 Headless Notes",
+            "text/plain",
+            FabricIngestionVersions.TextMarkdownParser,
+            FabricIngestionVersions.TextMarkdownParser,
+            "ready",
+            [],
+            now,
+            now);
+
+        var texts = new[] { quote, "Emergency frequency is 17.4 MHz." };
+        var start = 0;
+        library.ReplaceDocument(document, texts.Select((text, index) =>
+        {
+            var draft = new FabricSegmentDraft(
+                $"seg-{index}",
+                index,
+                $"Section {index}",
+                start,
+                start + text.Length,
+                Math.Max(6, text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length),
+                FabricHashing.Sha256(text),
+                text,
+                index > 0 ? $"seg-{index - 1}" : null,
+                index < texts.Length - 1 ? $"seg-{index + 1}" : null,
+                FabricIngestionVersions.Segmenter);
+            start += text.Length + 1;
+            return draft;
+        }).ToArray());
+
+        var workspaceRoot = Path.Combine(Path.GetTempPath(), "orc-cf5-headless-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(workspaceRoot);
+
+        return new Cf5TestHarness(store, library, graph, corpus, document, workspaceRoot);
+    }
+
+    public FabricAskService NewAskService(IRoleRuntime runtime)
+    {
+        var search = new FabricSearchService(Library, Graph);
+        var planner = new FabricQueryPlanner(search, Graph);
+        var packBuilder = new EvidencePackBuilder(Library, Graph);
+        var verifier = new FabricCitationVerifier(Library);
+        return new FabricAskService(planner, packBuilder, verifier, Library, runtime);
+    }
+
+    public FabricIndexingOrchestrator NewOrchestrator(IRoleRuntime runtime)
+    {
+        var reader = new FabricNativeReaderService(Library, Graph, runtime);
+        var reducer = new FabricReducer(Library, Graph);
+        return new FabricIndexingOrchestrator(reader, reducer, Library);
+    }
+
+    public LibraryViewModel NewLibraryViewModel()
+    {
+        var artifacts = new Services.Hive.ContentAddressedStore(Path.Combine(WorkspaceRoot, "objects"));
+        var libraryService = new FabricLibraryService(Library, artifacts);
+        return new LibraryViewModel(libraryService, Library, Path.Combine(WorkspaceRoot, "fabric"));
+    }
+
+    public void Dispose()
+    {
+        Store.Dispose();
+        try { Directory.Delete(WorkspaceRoot, recursive: true); } catch { /* best-effort cleanup */ }
+    }
+}
+
+/// <summary>Minimal IRoleRuntime stand-in — returns one canned JSON answer regardless of
+/// prompt content, for tests that only assert on the ChatPanel UI wiring, not retrieval.</summary>
+internal sealed class FakeFabricRuntime(string answerJson) : IRoleRuntime
+{
+    public string RuntimeName => "fake-fabric-runtime";
+
+    public async IAsyncEnumerable<string> StreamRoleCompletionAsync(
+        RuntimeRole role,
+        IEnumerable<AgentMessage> history,
+        IReadOnlyList<object>? tools = null,
+        double temperature = 0.1,
+        int maxTokens = 4096,
+        Action<ToolCall>? onToolCall = null,
+        Action<int, int>? onUsage = null,
+        [EnumeratorCancellation] CancellationToken ct = default)
+    {
+        await Task.Yield();
+        yield return answerJson;
+    }
+
+    public RuntimeHealth GetHealth(RuntimeRole? role = null) => new(true, RuntimeName, "fake.gguf");
+    public RuntimeStats GetStats(RuntimeRole? role = null) => new(RuntimeName, "fake.gguf");
+
+    public static string BuildAnswerJson(string quote, string segmentId) =>
+        $$"""
+        {"schemaVersion":"cf0-answer-1.0","answer":"{{quote}}","abstained":false,"claims":[{"text":"{{quote}}","citations":[{"segmentId":"{{segmentId}}","charStart":0,"charEnd":{{quote.Length}},"quote":"{{quote}}","quoteDigest":"{{FabricHashing.Sha256(quote)}}"}]}]}
+        """;
+}
diff --git a/OrchestratorIDE.Avalonia.HeadlessTests/OrcChatCitationNavigationTests.cs b/OrchestratorIDE.Avalonia.HeadlessTests/OrcChatCitationNavigationTests.cs
new file mode 100644
index 00000000..a8163a1b
--- /dev/null
+++ b/OrchestratorIDE.Avalonia.HeadlessTests/OrcChatCitationNavigationTests.cs
@@ -0,0 +1,85 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+using System.Reflection;
+using Avalonia.Controls;
+using Avalonia.Headless.NUnit;
+using Avalonia.Interactivity;
+using NUnit.Framework;
+using OrchestratorIDE.UI.Controls;
+using OrchestratorIDE.UI.Panels;
+using OrchestratorIDE.UI.ViewModels;
+
+namespace OrchestratorIDE.Avalonia.HeadlessTests;
+
+/// <summary>
+/// CF-5: clicking a citation footnote opens the source-preview rail with the right segment
+/// text and verification badge; closing it hides the rail again. OpenSourcePreview/the
+/// footnote click handler are private, so this invokes them via reflection — same convention
+/// ChatPanelModeToggleTests uses for SendAsync/OnToolStart.
+/// </summary>
+[TestFixture]
+public class OrcChatCitationNavigationTests
+{
+    private static T Required<T>(Control root, string name) where T : Control
+        => root.FindControl<T>(name)
+           ?? throw new AssertionException($"Expected to find control named '{name}'.");
+
+    [AvaloniaTest]
+    public void OpenSourcePreview_ShowsPanelWithCitationDetails()
+    {
+        using var harness = Cf5TestHarness.Create();
+        var panel = new ChatPanel();
+        var libraryVm = harness.NewLibraryViewModel();
+        panel.SetFabricServices(
+            harness.NewAskService(new FakeFabricRuntime("{}")),
+            harness.NewOrchestrator(new FakeFabricRuntime("{}")),
+            libraryVm,
+            webImporter: null,
+            harness.WorkspaceRoot);
+
+        var citation = new CitationViewModel(
+            1, "seg-0", harness.Document.DocumentId, "Section 0",
+            0, "LANTERN is the assigned call sign.".Length,
+            "LANTERN is the assigned call sign.", "Supported");
+
+        InvokeOpenSourcePreview(panel, citation);
+
+        var preview = Required<SourcePreviewPanel>(panel, "SourcePreviewPanel");
+        var splitter = Required<GridSplitter>(panel, "SourcePreviewSplitter");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(preview.IsVisible, Is.True);
+            Assert.That(splitter.IsVisible, Is.True);
+        });
+    }
+
+    [AvaloniaTest]
+    public void ClosingSourcePreview_HidesSplitter()
+    {
+        using var harness = Cf5TestHarness.Create();
+        var panel = new ChatPanel();
+        panel.SetFabricServices(
+            harness.NewAskService(new FakeFabricRuntime("{}")),
+            harness.NewOrchestrator(new FakeFabricRuntime("{}")),
+            harness.NewLibraryViewModel(),
+            webImporter: null,
+            harness.WorkspaceRoot);
+
+        var citation = new CitationViewModel(1, "seg-0", harness.Document.DocumentId, "Section 0", 0, 5, "LANTERN", "Supported");
+        InvokeOpenSourcePreview(panel, citation);
+
+        var closeMethod = typeof(ChatPanel).GetMethod("OnSourcePreviewClosed", BindingFlags.NonPublic | BindingFlags.Instance)
+            ?? throw new InvalidOperationException("OnSourcePreviewClosed not found via reflection.");
+        closeMethod.Invoke(panel, null);
+
+        Assert.That(Required<GridSplitter>(panel, "SourcePreviewSplitter").IsVisible, Is.False);
+    }
+
+    private static void InvokeOpenSourcePreview(ChatPanel panel, CitationViewModel citation)
+    {
+        var method = typeof(ChatPanel).GetMethod("OpenSourcePreview", BindingFlags.NonPublic | BindingFlags.Instance)
+            ?? throw new InvalidOperationException("OpenSourcePreview not found via reflection.");
+        method.Invoke(panel, [citation]);
+    }
+}
diff --git a/OrchestratorIDE.Avalonia.HeadlessTests/OrcChatContextFabricQueryTests.cs b/OrchestratorIDE.Avalonia.HeadlessTests/OrcChatContextFabricQueryTests.cs
new file mode 100644
index 00000000..d58da4ac
--- /dev/null
+++ b/OrchestratorIDE.Avalonia.HeadlessTests/OrcChatContextFabricQueryTests.cs
@@ -0,0 +1,91 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+using Avalonia.Controls;
+using Avalonia.Headless.NUnit;
+using Avalonia.Interactivity;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using NUnit.Framework;
+using OrchestratorIDE.UI.Panels;
+
+namespace OrchestratorIDE.Avalonia.HeadlessTests;
+
+/// <summary>
+/// CF-5: sending a question while a corpus is attached must route through FabricAskService
+/// (not the plain ChatEngine/Ollama path) and render a cited answer bubble with the coverage
+/// line. Uses reflection to invoke SendAsync directly, matching ChatPanelModeToggleTests'
+/// ClearDuringInFlightSend_doesNotThrow convention (BtnSend_Click is fire-and-forget, so
+/// exceptions inside it would otherwise become unobserved task exceptions).
+/// </summary>
+[TestFixture]
+public class OrcChatContextFabricQueryTests
+{
+    private static T Required<T>(Control root, string name) where T : Control
+        => root.FindControl<T>(name)
+           ?? throw new AssertionException($"Expected to find control named '{name}'.");
+
+    [AvaloniaTest]
+    public async Task SendingWithAttachedCorpus_RoutesThroughFabricAskService_AndRendersCoverageLine()
+    {
+        const string quote = "LANTERN is the assigned call sign.";
+        using var harness = Cf5TestHarness.Create(quote);
+        var panel = new ChatPanel();
+        panel.SetFabricServices(
+            harness.NewAskService(new FakeFabricRuntime(FakeFabricRuntime.BuildAnswerJson(quote, "seg-0"))),
+            harness.NewOrchestrator(new FakeFabricRuntime("{}")),
+            harness.NewLibraryViewModel(),
+            webImporter: null,
+            harness.WorkspaceRoot);
+
+        OrcChatLibraryTests.InvokeAttach(panel, harness.Corpus.CorpusId);
+        Dispatcher.UIThread.RunJobs();
+
+        Required<TextBox>(panel, "TbInput").Text = "What is the call sign?";
+
+        var sendMethod = typeof(ChatPanel).GetMethod("SendAsync",
+            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
+            ?? throw new InvalidOperationException("SendAsync method not found via reflection.");
+        var sendTask = (Task)sendMethod.Invoke(panel, null)!;
+
+        for (var i = 0; i < 200 && !sendTask.IsCompleted; i++)
+        {
+            Dispatcher.UIThread.RunJobs();
+            await Task.Delay(5);
+        }
+
+        Assert.That(sendTask.IsCompleted, Is.True, "SendAsync (fabric path) never completed.");
+        Assert.That(sendTask.IsFaulted, Is.False, $"SendAsync threw: {sendTask.Exception?.InnerException}");
+
+        var chatStack = Required<StackPanel>(panel, "ChatStack");
+        var bubbleText = ExtractAllText(chatStack);
+        // The answer bubble's Tag carries the raw answer text (same "Copy as Markdown" seam
+        // OnTurnComplete uses for the plain-chat path) -- a reliable check independent of how
+        // MarkdownView happens to materialize the prose into its own control tree.
+        var assistantBubble = chatStack.Children.OfType<Border>().Last();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(bubbleText, Does.Contain("Quick mode"));
+            Assert.That(bubbleText, Does.Contain("citations verified"));
+            Assert.That(assistantBubble.Tag, Is.EqualTo(quote));
+        });
+    }
+
+    /// <summary>Walks the visual tree collecting every TextBlock's Text — the cited-answer
+    /// bubble is built from plain Avalonia controls (no single string property to read back),
+    /// same constraint ChatPanel's own MarkdownView-based bubbles have.</summary>
+    private static string ExtractAllText(Control root)
+    {
+        var sb = new System.Text.StringBuilder();
+        Walk(root);
+        return sb.ToString();
+
+        void Walk(Control control)
+        {
+            if (control is TextBlock tb && tb.Text is not null)
+                sb.Append(tb.Text).Append(' ');
+            foreach (var child in control.GetVisualChildren())
+                if (child is Control c) Walk(c);
+        }
+    }
+}
diff --git a/OrchestratorIDE.Avalonia.HeadlessTests/OrcChatLibraryTests.cs b/OrchestratorIDE.Avalonia.HeadlessTests/OrcChatLibraryTests.cs
new file mode 100644
index 00000000..08f5d0c7
--- /dev/null
+++ b/OrchestratorIDE.Avalonia.HeadlessTests/OrcChatLibraryTests.cs
@@ -0,0 +1,144 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+using System.Reflection;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Headless.NUnit;
+using Avalonia.Interactivity;
+using Avalonia.Threading;
+using NUnit.Framework;
+using OrchestratorIDE.UI.Controls;
+using OrchestratorIDE.UI.Panels;
+
+namespace OrchestratorIDE.Avalonia.HeadlessTests;
+
+/// <summary>
+/// CF-5: covers the library drawer toggle and corpus attach/detach state in ChatPanel's
+/// corpus bar. Mirrors ChatPanelModeToggleTests' Required&lt;T&gt;/reflection conventions.
+/// </summary>
+[TestFixture]
+public class OrcChatLibraryTests
+{
+    private static T Required<T>(Control root, string name) where T : Control
+        => root.FindControl<T>(name)
+           ?? throw new AssertionException($"Expected to find control named '{name}'.");
+
+    private static void Click(Button button) =>
+        button.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+
+    [AvaloniaTest]
+    public void LibraryDrawer_And_SourcePreview_AreHidden_ByDefault()
+    {
+        var panel = new ChatPanel();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Required<LibraryDrawerControl>(panel, "LibraryDrawer").IsVisible, Is.False);
+            Assert.That(Required<SourcePreviewPanel>(panel, "SourcePreviewPanel").IsVisible, Is.False);
+            Assert.That(Required<Border>(panel, "BdrCorpusBadge").IsVisible, Is.False);
+        });
+    }
+
+    [AvaloniaTest]
+    public void ToggleLibraryButton_ShowsAndHidesDrawer()
+    {
+        var panel = new ChatPanel();
+        var toggle = Required<ToggleButton>(panel, "BtnToggleLibrary");
+
+        Click(toggle);
+        Dispatcher.UIThread.RunJobs();
+        Assert.That(Required<LibraryDrawerControl>(panel, "LibraryDrawer").IsVisible, Is.True);
+
+        Click(toggle);
+        Dispatcher.UIThread.RunJobs();
+        Assert.That(Required<LibraryDrawerControl>(panel, "LibraryDrawer").IsVisible, Is.False);
+    }
+
+    [AvaloniaTest]
+    public void AttachingCorpus_ShowsBadgeAndModeToggle()
+    {
+        using var harness = Cf5TestHarness.Create();
+        var panel = new ChatPanel();
+        panel.SetFabricServices(
+            harness.NewAskService(new FakeFabricRuntime("{}")),
+            harness.NewOrchestrator(new FakeFabricRuntime("{}")),
+            harness.NewLibraryViewModel(),
+            webImporter: null,
+            harness.WorkspaceRoot);
+
+        InvokeAttach(panel, harness.Corpus.CorpusId);
+        Dispatcher.UIThread.RunJobs();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Required<Border>(panel, "BdrCorpusBadge").IsVisible, Is.True);
+            Assert.That(Required<TextBlock>(panel, "TxtCorpusName").Text, Is.EqualTo(harness.Corpus.Name));
+            Assert.That(Required<StackPanel>(panel, "StackModeToggle").IsVisible, Is.True);
+        });
+    }
+
+    [AvaloniaTest]
+    public void DetachingCorpus_HidesBadgeAndSourcePreview()
+    {
+        using var harness = Cf5TestHarness.Create();
+        var panel = new ChatPanel();
+        panel.SetFabricServices(
+            harness.NewAskService(new FakeFabricRuntime("{}")),
+            harness.NewOrchestrator(new FakeFabricRuntime("{}")),
+            harness.NewLibraryViewModel(),
+            webImporter: null,
+            harness.WorkspaceRoot);
+
+        InvokeAttach(panel, harness.Corpus.CorpusId);
+        Dispatcher.UIThread.RunJobs();
+        Required<SourcePreviewPanel>(panel, "SourcePreviewPanel").IsVisible = true;
+
+        InvokeDetach(panel);
+        Dispatcher.UIThread.RunJobs();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(Required<Border>(panel, "BdrCorpusBadge").IsVisible, Is.False);
+            Assert.That(Required<StackPanel>(panel, "StackModeToggle").IsVisible, Is.False);
+            Assert.That(Required<SourcePreviewPanel>(panel, "SourcePreviewPanel").IsVisible, Is.False);
+        });
+    }
+
+    [AvaloniaTest]
+    public void ModeToggle_SwitchesHintText()
+    {
+        using var harness = Cf5TestHarness.Create();
+        var panel = new ChatPanel();
+        panel.SetFabricServices(
+            harness.NewAskService(new FakeFabricRuntime("{}")),
+            harness.NewOrchestrator(new FakeFabricRuntime("{}")),
+            harness.NewLibraryViewModel(),
+            webImporter: null,
+            harness.WorkspaceRoot);
+
+        InvokeAttach(panel, harness.Corpus.CorpusId);
+        Dispatcher.UIThread.RunJobs();
+
+        Click(Required<Button>(panel, "BtnModeStudy"));
+        Dispatcher.UIThread.RunJobs();
+        Assert.That(Required<TextBlock>(panel, "TxtModeHint").Text, Does.Contain("iterative retrieval"));
+
+        Click(Required<Button>(panel, "BtnModeQuick"));
+        Dispatcher.UIThread.RunJobs();
+        Assert.That(Required<TextBlock>(panel, "TxtModeHint").Text, Does.Contain("hybrid retrieval"));
+    }
+
+    internal static void InvokeAttach(ChatPanel panel, string corpusId)
+    {
+        var method = typeof(ChatPanel).GetMethod("OnCorpusAttachRequested", BindingFlags.NonPublic | BindingFlags.Instance)
+            ?? throw new InvalidOperationException("OnCorpusAttachRequested not found via reflection.");
+        method.Invoke(panel, [corpusId]);
+    }
+
+    internal static void InvokeDetach(ChatPanel panel)
+    {
+        var method = typeof(ChatPanel).GetMethod("OnCorpusDetachRequested", BindingFlags.NonPublic | BindingFlags.Instance)
+            ?? throw new InvalidOperationException("OnCorpusDetachRequested not found via reflection.");
+        method.Invoke(panel, null);
+    }
+}
diff --git a/OrchestratorIDE.Avalonia/MainWindow.axaml.cs b/OrchestratorIDE.Avalonia/MainWindow.axaml.cs
index 8801ace0..1245dbc0 100644
--- a/OrchestratorIDE.Avalonia/MainWindow.axaml.cs
+++ b/OrchestratorIDE.Avalonia/MainWindow.axaml.cs
@@ -704,6 +704,8 @@ private void InitDataLayer(string workspaceRoot)
             foreach (var stale in _runRepo.ActiveRuns())
                 _runRepo.UpdateStatus(stale.RunId, "stale");
 
+            InitContextFabricLibrary(workspaceRoot, _sqlStore);
+
             var planRepo = _planRepo;
             Task.Run(() =>
             {
@@ -732,6 +734,56 @@ private void InitDataLayer(string workspaceRoot)
         }
     }
 
+    // ── CF-5 Context Fabric Library wiring ──────────────────────────────────
+
+    /// <summary>
+    /// Wires the CF-5 OrcChat Library services into _chatPanel. Requires a native
+    /// IRoleRuntime (the same experimental opt-in BuildExperimentalNativeMainChatRuntime
+    /// uses for the agent loop — see that method's VRAM double-booking caveat if both are
+    /// enabled at once) since FabricAskService/FabricNativeReaderService both generate via
+    /// IRoleRuntime, not the Ollama-backed ChatEngine path. When the toggle is off or no base
+    /// GGUF is found, the library drawer/source-preview rails simply stay hidden and chat
+    /// behaves exactly as it did before CF-5 — same graceful-no-op shape as every other
+    /// experimental-native call site in this file.
+    /// </summary>
+    private void InitContextFabricLibrary(string workspaceRoot, Services.Data.SqliteStore? sqlStore)
+    {
+        if (sqlStore is null) return;
+
+        try
+        {
+            var nativeRuntime = BuildExperimentalNativeMainChatRuntime();
+            if (nativeRuntime is null) return;
+
+            var fabricRepo      = new Services.ContextFabric.FabricLibraryRepository(sqlStore);
+            var graphRepo       = new Services.ContextFabric.DocumentGraphRepository(sqlStore);
+            var fabricArtifacts = new Services.Hive.ContentAddressedStore(
+                Path.Combine(workspaceRoot, ".orc", "fabric", "objects"));
+            var libraryService  = new Services.ContextFabric.FabricLibraryService(fabricRepo, fabricArtifacts);
+            var searchService   = new Services.ContextFabric.FabricSearchService(fabricRepo, graphRepo);
+            var planner         = new Services.ContextFabric.FabricQueryPlanner(searchService, graphRepo);
+            var packBuilder     = new Services.ContextFabric.EvidencePackBuilder(fabricRepo, graphRepo);
+            var verifier        = new Services.ContextFabric.FabricCitationVerifier(fabricRepo);
+            var nativeReader    = new Services.ContextFabric.FabricNativeReaderService(fabricRepo, graphRepo, nativeRuntime);
+            var reducer         = new Services.ContextFabric.FabricReducer(fabricRepo, graphRepo);
+            var askService      = new Services.ContextFabric.FabricAskService(planner, packBuilder, verifier, fabricRepo, nativeRuntime);
+            var orchestrator    = new Services.ContextFabric.FabricIndexingOrchestrator(nativeReader, reducer, fabricRepo);
+            var libraryVm       = new UI.ViewModels.LibraryViewModel(
+                libraryService, fabricRepo, Path.Combine(workspaceRoot, ".orc", "fabric"));
+            var webImporter     = new Services.ContextFabric.FabricWebImporter(libraryService, new HttpClient());
+
+            _chatPanel.SetFabricServices(askService, orchestrator, libraryVm, webImporter, workspaceRoot);
+
+            AddActivity(new ActivityEvent(ActivityKind.Info, "Context Fabric",
+                "OrcChat Library enabled (native runtime available).", DateTime.Now));
+        }
+        catch (Exception ex)
+        {
+            AddActivity(new ActivityEvent(ActivityKind.Info, "Context Fabric",
+                $"OrcChat Library init failed (non-fatal): {ex.Message}", DateTime.Now));
+        }
+    }
+
     // ── FlaUI IPC ─────────────────────────────────────────────────────────
 
     private System.IO.FileSystemWatcher? _flaUIWatcher;
diff --git a/OrchestratorIDE.Avalonia/OrchestratorIDE.Avalonia.csproj b/OrchestratorIDE.Avalonia/OrchestratorIDE.Avalonia.csproj
index d9f12bb8..c440bbb5 100644
--- a/OrchestratorIDE.Avalonia/OrchestratorIDE.Avalonia.csproj
+++ b/OrchestratorIDE.Avalonia/OrchestratorIDE.Avalonia.csproj
@@ -185,6 +185,12 @@
     <Compile Include="..\OrchestratorIDE\Services\ContextFabric\EvidencePackBuilder.cs" />
     <Compile Include="..\OrchestratorIDE\Services\ContextFabric\FabricCitationVerifier.cs" />
     <Compile Include="..\OrchestratorIDE\Services\ContextFabric\FabricSearchService.cs" />
+
+    <!-- Context Fabric CF-5 OrcChat Library -->
+    <Compile Include="..\OrchestratorIDE\Services\ContextFabric\FabricAskService.cs" />
+    <Compile Include="..\OrchestratorIDE\Services\ContextFabric\FabricIndexingOrchestrator.cs" />
+    <Compile Include="..\OrchestratorIDE\Services\ContextFabric\FabricWebImporter.cs" />
+    <Compile Include="..\OrchestratorIDE\Services\ConversationNotebookStore.cs" />
     <!-- CodeGraph v1 (step 1+) — shared with WPF via explicit include (Avalonia_Migration.md discipline) -->
     <Compile Include="..\OrchestratorIDE\Services\CodeGraph\GraphModels.cs" />
     <Compile Include="..\OrchestratorIDE\Services\CodeGraph\ComplexityAnalyzer.cs" />
diff --git a/OrchestratorIDE.Avalonia/UI/Controls/LibraryDrawerControl.axaml b/OrchestratorIDE.Avalonia/UI/Controls/LibraryDrawerControl.axaml
new file mode 100644
index 00000000..aa84db4a
--- /dev/null
+++ b/OrchestratorIDE.Avalonia/UI/Controls/LibraryDrawerControl.axaml
@@ -0,0 +1,25 @@
+<!-- Copyright (C) 2025-present hardcoreerik / TheOrc contributors | SPDX-License-Identifier: AGPL-3.0-or-later -->
+<UserControl x:Class="OrchestratorIDE.UI.Controls.LibraryDrawerControl"
+             xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             Width="312"
+             Background="#0A0D0A">
+
+    <!--
+    ═══════════════════════════════════════════════════════════════════
+    CF-5 Library drawer — left rail inside ChatPanel. All dynamic content
+    (corpus cards, search results, notebook entries) is built in
+    code-behind, matching the rest of the Avalonia UI's no-MVVM,
+    code-behind-only convention (see ChatPanel.axaml.cs).
+    ═══════════════════════════════════════════════════════════════════
+    -->
+    <DockPanel x:Name="RootDock">
+        <Border x:Name="StorageFooter" DockPanel.Dock="Bottom" />
+        <Border DockPanel.Dock="Top">
+            <StackPanel x:Name="HeaderStack" />
+        </Border>
+        <ScrollViewer>
+            <StackPanel x:Name="BodyStack" Spacing="8" Margin="10,6,10,10" />
+        </ScrollViewer>
+    </DockPanel>
+</UserControl>
diff --git a/OrchestratorIDE.Avalonia/UI/Controls/LibraryDrawerControl.axaml.cs b/OrchestratorIDE.Avalonia/UI/Controls/LibraryDrawerControl.axaml.cs
new file mode 100644
index 00000000..803fef39
--- /dev/null
+++ b/OrchestratorIDE.Avalonia/UI/Controls/LibraryDrawerControl.axaml.cs
@@ -0,0 +1,623 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Platform.Storage;
+using Avalonia.Threading;
+using OrchestratorIDE.Services;
+using OrchestratorIDE.Services.ContextFabric;
+using OrchestratorIDE.UI.ViewModels;
+
+namespace OrchestratorIDE.UI.Controls;
+
+/// <summary>
+/// CF-5 Library drawer — code-behind-only (no MVVM framework), matching the rest of the
+/// Avalonia UI's pattern of building dynamic content in C# (see ChatPanel.axaml.cs bubble
+/// builders) rather than data-binding against a view model.
+/// </summary>
+public partial class LibraryDrawerControl : UserControl
+{
+    public event Action<string>? CorpusAttachRequested;
+    public event Action? CorpusDetachRequested;
+    public event Action<string>? StorageChangeRequested;
+
+    private LibraryViewModel? _vm;
+    private FabricIndexingOrchestrator? _orchestrator;
+    private FabricWebImporter? _webImporter;
+    private string? _attachedCorpusId;
+    private bool _webFindMode;
+    private IReadOnlyList<WebImportCandidate> _webResults = [];
+    private readonly Dictionary<string, IndexProgressViewModel> _progressByDocument = [];
+    private IReadOnlyList<ConversationNotebookEntry> _notebookEntries = [];
+    private string? _lastError;
+
+    public LibraryDrawerControl()
+    {
+        InitializeComponent();
+        BuildHeader();
+        BuildStorageFooter();
+        Render();
+    }
+
+    public void Attach(LibraryViewModel vm, FabricIndexingOrchestrator orchestrator, FabricWebImporter? webImporter)
+    {
+        _vm = vm;
+        _orchestrator = orchestrator;
+        _webImporter = webImporter;
+        _vm.PropertyChanged += (_, _) => Dispatcher.UIThread.Post(Render);
+        _vm.Corpora.CollectionChanged += (_, _) => Dispatcher.UIThread.Post(Render);
+        _vm.SearchResults.CollectionChanged += (_, _) => Dispatcher.UIThread.Post(Render);
+        Render();
+    }
+
+    public void SetAttachedCorpus(string? corpusId)
+    {
+        _attachedCorpusId = corpusId;
+        Render();
+    }
+
+    public void UpdateNotebook(IReadOnlyList<ConversationNotebookEntry> entries)
+    {
+        _notebookEntries = entries;
+        Render();
+    }
+
+    // ── Header: title + add-source dropdown + search box ───────────────────
+
+    private void BuildHeader()
+    {
+        HeaderStack.Children.Clear();
+        HeaderStack.Margin = new Thickness(12, 10, 12, 8);
+        HeaderStack.Spacing = 8;
+
+        var titleRow = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
+        var title = new TextBlock
+        {
+            Text = "📚 Library",
+            FontSize = 13,
+            FontWeight = FontWeight.SemiBold,
+            Foreground = Brush(0xC8, 0xD4, 0xC8),
+            VerticalAlignment = VerticalAlignment.Center,
+        };
+
+        var addBtn = new Button
+        {
+            Content = "+ Add source ▾",
+            Background = Brush(0x16, 0x26, 0x16),
+            BorderBrush = Brush(0x2A, 0x4A, 0x2A),
+            Foreground = Brush(0xC4, 0xE8, 0x9A),
+            FontSize = 11.5,
+            FontWeight = FontWeight.SemiBold,
+            CornerRadius = new CornerRadius(6),
+            Padding = new Thickness(9, 5),
+            BorderThickness = new Thickness(1),
+        };
+        var fromFile = new MenuItem { Header = "From file…" };
+        fromFile.Click += async (_, _) =>
+        {
+            try { await AddFromFileAsync(); }
+            catch (Exception ex) { ShowError("Adding source from file", ex); }
+        };
+        var fromFolder = new MenuItem { Header = "From folder…" };
+        fromFolder.Click += async (_, _) =>
+        {
+            try { await AddFromFolderAsync(); }
+            catch (Exception ex) { ShowError("Adding sources from folder", ex); }
+        };
+        var findWeb = new MenuItem { Header = "Find on the web…" };
+        findWeb.Click += (_, _) => { _webFindMode = true; Render(); };
+        addBtn.ContextMenu = new ContextMenu { ItemsSource = new[] { fromFile, fromFolder, findWeb } };
+        addBtn.Click += (_, _) => addBtn.ContextMenu?.Open(addBtn);
+
+        Grid.SetColumn(title, 0);
+        Grid.SetColumn(addBtn, 1);
+        titleRow.Children.Add(title);
+        titleRow.Children.Add(addBtn);
+        HeaderStack.Children.Add(titleRow);
+
+        var searchBox = new TextBox
+        {
+            PlaceholderText = "Search the library…",
+            Background = Brush(0x0B, 0x0F, 0x0B),
+            BorderBrush = Brush(0x1E, 0x2E, 0x1E),
+            Foreground = Brush(0xD4, 0xD4, 0xD4),
+            CornerRadius = new CornerRadius(7),
+            FontSize = 11.5,
+            Padding = new Thickness(10, 6),
+        };
+        searchBox.TextChanged += (_, _) =>
+        {
+            if (_vm is not null) _vm.SearchQuery = searchBox.Text ?? "";
+        };
+        HeaderStack.Children.Add(searchBox);
+    }
+
+    private async Task AddFromFileAsync()
+    {
+        if (_vm is null) return;
+        var topLevel = TopLevel.GetTopLevel(this);
+        if (topLevel?.StorageProvider is null) return;
+
+        var files = await topLevel.StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
+        {
+            Title = "Add source to library",
+            AllowMultiple = false,
+            FileTypeFilter = new[]
+            {
+                new FilePickerFileType("Supported sources") { Patterns = ["*.pdf", "*.txt", "*.md"] },
+            },
+        });
+        var file = files.Count > 0 ? files[0] : null;
+        if (file is null) return;
+
+        var corpusId = _attachedCorpusId ?? EnsureDefaultCorpus();
+        await ImportAndIndexAsync(corpusId, file.Path.LocalPath);
+    }
+
+    private async Task AddFromFolderAsync()
+    {
+        if (_vm is null) return;
+        var topLevel = TopLevel.GetTopLevel(this);
+        if (topLevel?.StorageProvider is null) return;
+
+        var folders = await topLevel.StorageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions
+        {
+            Title = "Add folder of sources to library",
+            AllowMultiple = false,
+        });
+        var folder = folders.Count > 0 ? folders[0] : null;
+        if (folder is null) return;
+
+        var corpusId = _attachedCorpusId ?? EnsureDefaultCorpus();
+        var dir = folder.Path.LocalPath;
+        if (!Directory.Exists(dir)) return;
+
+        foreach (var path in Directory.EnumerateFiles(dir, "*.*", SearchOption.TopDirectoryOnly)
+                     .Where(p => p.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase) ||
+                                 p.EndsWith(".txt", StringComparison.OrdinalIgnoreCase) ||
+                                 p.EndsWith(".md", StringComparison.OrdinalIgnoreCase)))
+        {
+            await ImportAndIndexAsync(corpusId, path);
+        }
+    }
+
+    private string EnsureDefaultCorpus()
+    {
+        var existing = _vm!.Corpora.FirstOrDefault();
+        if (existing is not null) return existing.CorpusId;
+        return _vm.CreateCorpus("Library").CorpusId;
+    }
+
+    private async Task ImportAndIndexAsync(string corpusId, string path)
+    {
+        if (_vm is null) return;
+        try
+        {
+            var import = await _vm.ImportFileAsync(corpusId, path);
+            BeginIndexing(import.Document.DocumentId);
+        }
+        catch
+        {
+            // Import failures surface via the document's own status on next Refresh().
+        }
+    }
+
+    private void BeginIndexing(string documentId)
+    {
+        if (_orchestrator is null) return;
+        // Re-entrancy guard -- without this, a double-click on "Re-index corpus" or a second
+        // import landing on the same document while the first is still running fires two
+        // concurrent IndexDocumentAsync calls racing the same SQLite rows (claims replace +
+        // reduce), and the second BeginIndexing's progress VM orphans the first one's.
+        if (_progressByDocument.TryGetValue(documentId, out var existing) &&
+            existing.Stage is not IndexStageKind.Complete and not IndexStageKind.Failed)
+        {
+            return;
+        }
+
+        var progress = new IndexProgressViewModel(documentId);
+        _progressByDocument[documentId] = progress;
+        progress.PropertyChanged += (_, _) => Dispatcher.UIThread.Post(Render);
+
+        var reporter = new Progress<IndexStageEvent>(progress.Apply);
+        _ = _orchestrator.IndexDocumentAsync(documentId, readOnly: false, reporter)
+            .ContinueWith(_ => Dispatcher.UIThread.Post(() => { _vm?.Refresh(); Render(); }));
+    }
+
+    /// <summary>
+    /// Scoped retry for a document's previously-failed segments -- the "Repair" affordance,
+    /// using FabricIndexingOrchestrator.RetryFailedAsync instead of re-reading every segment
+    /// the way "Re-index corpus" (BeginIndexing) does.
+    /// </summary>
+    private void BeginRetry(string documentId, IReadOnlyList<string> failedSegmentIds)
+    {
+        if (_orchestrator is null) return;
+        if (_progressByDocument.TryGetValue(documentId, out var existing) &&
+            existing.Stage is not IndexStageKind.Complete and not IndexStageKind.Failed)
+        {
+            return;
+        }
+
+        var progress = new IndexProgressViewModel(documentId);
+        _progressByDocument[documentId] = progress;
+        progress.PropertyChanged += (_, _) => Dispatcher.UIThread.Post(Render);
+
+        var reporter = new Progress<IndexStageEvent>(progress.Apply);
+        _ = _orchestrator.RetryFailedAsync(documentId, failedSegmentIds, readOnly: false, reporter)
+            .ContinueWith(_ => Dispatcher.UIThread.Post(() => { _vm?.Refresh(); Render(); }));
+    }
+
+    // ── Storage footer ───────────────────────────────────────────────────────
+
+    private void BuildStorageFooter()
+    {
+        StorageFooter.BorderBrush = Brush(0x16, 0x20, 0x16);
+        StorageFooter.Background = Brush(0x0A, 0x0D, 0x0A);
+        StorageFooter.BorderThickness = new Thickness(0, 1, 0, 0);
+        StorageFooter.Padding = new Thickness(13, 10);
+
+        var row = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto") };
+        var icon = new TextBlock { Text = "🗄", VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(0, 0, 6, 0) };
+        var pathText = new TextBlock
+        {
+            Text = _vm?.StoragePath ?? "",
+            FontFamily = new FontFamily("JetBrains Mono, Consolas, monospace"),
+            FontSize = 10,
+            Foreground = Brush(0x8A, 0x9A, 0x84),
+            TextTrimming = TextTrimming.CharacterEllipsis,
+            VerticalAlignment = VerticalAlignment.Center,
+        };
+        var changeBtn = new Button
+        {
+            Content = "Change…",
+            FontSize = 10.5,
+            Padding = new Thickness(8, 3),
+            Background = Brush(0x0E, 0x16, 0x0E),
+            BorderBrush = Brush(0x1E, 0x2E, 0x1E),
+            Foreground = Brush(0x9F, 0xB8, 0x90),
+        };
+        changeBtn.Click += async (_, _) => await ChangeStorageAsync(pathText);
+
+        Grid.SetColumn(icon, 0);
+        Grid.SetColumn(pathText, 1);
+        Grid.SetColumn(changeBtn, 2);
+        row.Children.Add(icon);
+        row.Children.Add(pathText);
+        row.Children.Add(changeBtn);
+        StorageFooter.Child = row;
+    }
+
+    private async Task ChangeStorageAsync(TextBlock pathText)
+    {
+        var topLevel = TopLevel.GetTopLevel(this);
+        if (topLevel?.StorageProvider is null) return;
+
+        var folders = await topLevel.StorageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions
+        {
+            Title = "Choose library storage folder",
+            AllowMultiple = false,
+        });
+        var folder = folders.Count > 0 ? folders[0] : null;
+        if (folder is null) return;
+
+        var newPath = folder.Path.LocalPath;
+        pathText.Text = newPath;
+        if (_vm is not null) _vm.StoragePath = newPath;
+        StorageChangeRequested?.Invoke(newPath);
+    }
+
+    // ── Body: corpus cards / search results / notebook / web-find ──────────
+
+    private void Render()
+    {
+        BodyStack.Children.Clear();
+
+        if (_lastError is not null)
+            BodyStack.Children.Add(BuildErrorBanner(_lastError));
+
+        if (_webFindMode)
+        {
+            BodyStack.Children.Add(BuildWebFindPanel());
+            return;
+        }
+
+        if (_vm is not null && _vm.SearchResults.Count > 0)
+            BodyStack.Children.Add(BuildSearchResultsSection());
+
+        foreach (var corpus in _vm?.Corpora ?? [])
+            BodyStack.Children.Add(BuildCorpusCard(corpus));
+
+        BodyStack.Children.Add(BuildNotebookSection());
+    }
+
+    /// <summary>
+    /// Surfaces a failure from one of the async-void Click handlers below instead of letting
+    /// it become an unhandled exception on the UI thread (the exact BLOCKER-class bug this
+    /// codebase's own ChatPanel.CopyBubbleTextAsync comment documents fixing once already).
+    /// </summary>
+    private void ShowError(string action, Exception ex)
+    {
+        _lastError = $"{action} failed: {ex.Message}";
+        Dispatcher.UIThread.Post(Render);
+    }
+
+    private Control BuildErrorBanner(string message)
+    {
+        var dismiss = new Button { Content = "✕", FontSize = 10, Padding = new Thickness(4), Background = Brushes.Transparent, BorderThickness = new Thickness(0), Foreground = Brush(0xC0, 0x61, 0x4F) };
+        dismiss.Click += (_, _) => { _lastError = null; Render(); };
+        var row = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
+        var text = new TextBlock { Text = message, FontSize = 10.5, Foreground = Brush(0xC0, 0x61, 0x4F), TextWrapping = TextWrapping.Wrap, VerticalAlignment = VerticalAlignment.Center };
+        Grid.SetColumn(text, 0);
+        Grid.SetColumn(dismiss, 1);
+        row.Children.Add(text);
+        row.Children.Add(dismiss);
+        return new Border
+        {
+            Background = Brush(0x1E, 0x11, 0x0E), BorderBrush = Brush(0x3A, 0x1E, 0x18), BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(6), Padding = new Thickness(8, 6), Margin = new Thickness(0, 0, 0, 6), Child = row,
+        };
+    }
+
+    private Control BuildSearchResultsSection()
+    {
+        var stack = new StackPanel { Spacing = 4 };
+        stack.Children.Add(new TextBlock
+        {
+            Text = "SEARCH RESULTS",
+            FontSize = 10, FontWeight = FontWeight.SemiBold, Foreground = Brush(0x5A, 0x6B, 0x5A),
+            LetterSpacing = 1.2,
+        });
+        foreach (var hit in _vm!.SearchResults)
+        {
+            var row = new Border
+            {
+                Background = Brush(0x0E, 0x14, 0x0E),
+                BorderBrush = Brush(0x1A, 0x24, 0x1A),
+                BorderThickness = new Thickness(1),
+                CornerRadius = new CornerRadius(6),
+                Padding = new Thickness(8),
+                Child = new TextBlock
+                {
+                    Text = $"{hit.DisplayName} · {Snippet(hit.Text)}",
+                    FontSize = 10.5, Foreground = Brush(0x8A, 0x9A, 0x84), TextWrapping = TextWrapping.Wrap,
+                },
+            };
+            stack.Children.Add(row);
+        }
+        return stack;
+    }
+
+    private static string Snippet(string text) => text.Length <= 80 ? text : text[..80] + "…";
+
+    private Control BuildCorpusCard(CorpusCardViewModel corpus)
+    {
+        var (bg, border) = corpus.Status switch
+        {
+            "indexing" => (Brush(0x12, 0x10, 0x0A), Brush(0x4A, 0x3C, 0x18)),
+            "stale" => (Brush(0x0E, 0x12, 0x0E), Brush(0x44, 0x37, 0x14)),
+            _ => (Brush(0x10, 0x1A, 0x10), Brush(0x2A, 0x4A, 0x2A)),
+        };
+
+        var stack = new StackPanel { Spacing = 6 };
+
+        var headerRow = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
+        var name = new TextBlock
+        {
+            Text = corpus.Name, FontSize = 12.5, FontWeight = FontWeight.SemiBold, Foreground = Brush(0xD8, 0xE4, 0xD0),
+        };
+        Grid.SetColumn(name, 0);
+        headerRow.Children.Add(name);
+
+        var statusPill = BuildStatusPill(corpus);
+        Grid.SetColumn(statusPill, 1);
+        headerRow.Children.Add(statusPill);
+        stack.Children.Add(headerRow);
+
+        stack.Children.Add(new TextBlock
+        {
+            Text = $"{corpus.TotalSegments} segments",
+            FontFamily = new FontFamily("JetBrains Mono, Consolas, monospace"),
+            FontSize = 10, Foreground = Brush(0x6E, 0x80, 0x68),
+        });
+
+        var actionsRow = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6 };
+        if (corpus.Status == "ready")
+        {
+            var isAttached = string.Equals(corpus.CorpusId, _attachedCorpusId, StringComparison.Ordinal);
+            var attachBtn = new Button
+            {
+                Content = isAttached ? "✕ Detach" : "Attach",
+                FontSize = 10.5, Padding = new Thickness(8, 3),
+                Background = isAttached ? Brush(0x1E, 0x11, 0x0E) : Brush(0x13, 0x25, 0x13),
+                BorderBrush = isAttached ? Brush(0x3A, 0x1E, 0x18) : Brush(0x2F, 0x4F, 0x2F),
+                Foreground = isAttached ? Brush(0xC0, 0x61, 0x4F) : Brush(0x9F, 0xD3, 0x7F),
+            };
+            attachBtn.Click += (_, _) =>
+            {
+                if (isAttached) CorpusDetachRequested?.Invoke();
+                else CorpusAttachRequested?.Invoke(corpus.CorpusId);
+            };
+            actionsRow.Children.Add(attachBtn);
+        }
+        else if (corpus.Status == "stale")
+        {
+            var reindexBtn = new Button
+            {
+                Content = "↻ Re-index corpus",
+                FontSize = 10.5, Padding = new Thickness(8, 3),
+                Background = Brush(0x1A, 0x14, 0x0B), BorderBrush = Brush(0x44, 0x37, 0x14), Foreground = Brush(0xC9, 0x8A, 0x4B),
+            };
+            reindexBtn.Click += (_, _) =>
+            {
+                foreach (var doc in corpus.Documents)
+                    ReindexDocumentAsync(doc.DocumentId);
+            };
+            actionsRow.Children.Add(reindexBtn);
+        }
+        if (actionsRow.Children.Count > 0)
+            stack.Children.Add(actionsRow);
+
+        var activeProgress = _progressByDocument.Values.FirstOrDefault(p =>
+            corpus.Documents.Any(d => d.DocumentId == p.DocumentId) &&
+            p.Stage is not IndexStageKind.Complete and not IndexStageKind.Failed);
+        if (activeProgress is not null)
+        {
+            stack.Children.Add(new TextBlock
+            {
+                Text = activeProgress.StageLabel,
+                FontFamily = new FontFamily("JetBrains Mono, Consolas, monospace"),
+                FontSize = 10, Foreground = Brush(0x8A, 0x7E, 0x60),
+            });
+        }
+
+        // A completed run can still have left some segments failed -- offer the scoped
+        // retry (FabricIndexingOrchestrator.RetryFailedAsync) instead of forcing a full
+        // re-read of every segment via "Re-index corpus".
+        var failedProgress = _progressByDocument.Values.FirstOrDefault(p =>
+            corpus.Documents.Any(d => d.DocumentId == p.DocumentId) &&
+            p.Stage == IndexStageKind.Complete && p.FailedSegmentIds.Count > 0);
+        if (failedProgress is not null)
+        {
+            var repairRow = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), Margin = new Thickness(0, 4, 0, 0) };
+            var failedLabel = new TextBlock
+            {
+                Text = $"{failedProgress.FailedSegmentIds.Count} failed segments",
+                FontFamily = new FontFamily("JetBrains Mono, Consolas, monospace"),
+                FontSize = 10, Foreground = Brush(0xD6, 0xA8, 0x5A), VerticalAlignment = VerticalAlignment.Center,
+            };
+            var repairBtn = new Button
+            {
+                Content = "Repair", FontSize = 10.5, Padding = new Thickness(8, 3),
+                Background = Brush(0x1A, 0x14, 0x0B), BorderBrush = Brush(0x44, 0x37, 0x14), Foreground = Brush(0xC9, 0x8A, 0x4B),
+            };
+            var documentId = failedProgress.DocumentId;
+            var failedIds = failedProgress.FailedSegmentIds.ToArray();
+            repairBtn.Click += (_, _) => BeginRetry(documentId, failedIds);
+            Grid.SetColumn(failedLabel, 0);
+            Grid.SetColumn(repairBtn, 1);
+            repairRow.Children.Add(failedLabel);
+            repairRow.Children.Add(repairBtn);
+            stack.Children.Add(repairRow);
+        }
+
+        return new Border
+        {
+            Background = bg, BorderBrush = border, BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(9), Padding = new Thickness(11, 12), Child = stack,
+        };
+    }
+
+    private void ReindexDocumentAsync(string documentId) => BeginIndexing(documentId);
+
+    private static Border BuildStatusPill(CorpusCardViewModel corpus)
+    {
+        var (text, fg, bg, border) = corpus.Status switch
+        {
+            "indexing" => ("● Indexing", Brush(0xD6, 0xA8, 0x5A), Brush(0x22, 0x1B, 0x0C), Brush(0x4A, 0x3C, 0x18)),
+            "stale" => ("↻ Stale", Brush(0xC9, 0x8A, 0x4B), Brush(0x1A, 0x14, 0x0B), Brush(0x44, 0x37, 0x14)),
+            "failed" => ("⚠ Failed", Brush(0xC0, 0x61, 0x4F), Brush(0x1E, 0x11, 0x0E), Brush(0x3A, 0x1E, 0x18)),
+            _ => ("● Ready", Brush(0x9F, 0xD3, 0x7F), Brush(0x13, 0x25, 0x13), Brush(0x2F, 0x4F, 0x2F)),
+        };
+        return new Border
+        {
+            Background = bg, BorderBrush = border, BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(999), Padding = new Thickness(7, 2),
+            VerticalAlignment = VerticalAlignment.Center,
+            Child = new TextBlock
+            {
+                Text = text, FontFamily = new FontFamily("JetBrains Mono, Consolas, monospace"),
+                FontSize = 10, FontWeight = FontWeight.SemiBold, Foreground = fg,
+            },
+        };
+    }
+
+    private Control BuildNotebookSection()
+    {
+        var stack = new StackPanel { Spacing = 4, Margin = new Thickness(0, 8, 0, 0) };
+        stack.Children.Add(new TextBlock
+        {
+            Text = "NOTEBOOK · THIS CHAT",
+            FontSize = 10, FontWeight = FontWeight.SemiBold, Foreground = Brush(0x5A, 0x6B, 0x5A), LetterSpacing = 1.2,
+        });
+        foreach (var entry in _notebookEntries.TakeLast(5))
+        {
+            stack.Children.Add(new Border
+            {
+                BorderBrush = Brush(0x24, 0x34, 0x24), BorderThickness = new Thickness(2, 0, 0, 0),
+                Padding = new Thickness(8, 0, 0, 0),
+                Child = new TextBlock
+                {
+                    Text = entry.ClaimText, FontSize = 10.5, Foreground = Brush(0x8A, 0x9A, 0x84), TextWrapping = TextWrapping.Wrap,
+                },
+            });
+        }
+        return stack;
+    }
+
+    // ── Web-find sub-view ─────────────────────────────────────────────────
+
+    private Control BuildWebFindPanel()
+    {
+        var stack = new StackPanel { Spacing = 8 };
+
+        var backBtn = new Button { Content = "← Back to library", FontSize = 10.5, Background = Avalonia.Media.Brushes.Transparent };
+        backBtn.Click += (_, _) => { _webFindMode = false; _webResults = []; Render(); };
+        stack.Children.Add(backBtn);
+
+        var input = new TextBox { PlaceholderText = "Book title, author, or URL…", FontSize = 11.5 };
+        var searchBtn = new Button { Content = "Search", FontSize = 11 };
+        searchBtn.Click += async (_, _) =>
+        {
+            if (_webImporter is null || string.IsNullOrWhiteSpace(input.Text)) return;
+            try
+            {
+                _webResults = await _webImporter.SearchAsync(input.Text!).ConfigureAwait(true);
+                Render();
+            }
+            catch (Exception ex) { ShowError("Web search", ex); }
+        };
+        stack.Children.Add(input);
+        stack.Children.Add(searchBtn);
+
+        foreach (var candidate in _webResults)
+        {
+            var row = new StackPanel { Spacing = 2 };
+            row.Children.Add(new TextBlock { Text = candidate.Title, FontSize = 11.5, Foreground = Brush(0xD8, 0xE4, 0xD0), TextWrapping = TextWrapping.Wrap });
+            row.Children.Add(new TextBlock { Text = $"{candidate.Format.ToUpperInvariant()} · {candidate.Attribution}", FontSize = 10, Foreground = Brush(0x6E, 0x80, 0x68) });
+            var addBtn = new Button { Content = "Add to library", FontSize = 10.5 };
+            addBtn.Click += async (_, _) =>
+            {
+                if (_vm is null) return;
+                try
+                {
+                    var corpusId = _attachedCorpusId ?? EnsureDefaultCorpus();
+                    var result = await _webImporter!.DownloadAndImportAsync(corpusId, candidate).ConfigureAwait(true);
+                    _vm.Refresh();
+                    BeginIndexing(result.ImportResult.Document.DocumentId);
+                    _webFindMode = false;
+                    _webResults = [];
+                    Render();
+                }
+                catch (Exception ex) { ShowError($"Downloading '{candidate.Title}'", ex); }
+            };
+            row.Children.Add(addBtn);
+            stack.Children.Add(new Border
+            {
+                Background = Brush(0x0E, 0x14, 0x0E), BorderBrush = Brush(0x1A, 0x24, 0x1A), BorderThickness = new Thickness(1),
+                CornerRadius = new CornerRadius(7), Padding = new Thickness(8), Child = row,
+            });
+        }
+
+        stack.Children.Add(new TextBlock
+        {
+            Text = "Only add content you are licensed to use. OrcChat does not redistribute corpus content outside this machine.",
+            FontSize = 9.5, Foreground = Brush(0x5E, 0x6E, 0x5A), TextWrapping = TextWrapping.Wrap,
+        });
+
+        return stack;
+    }
+
+    private static SolidColorBrush Brush(byte r, byte g, byte b) => new(Color.FromRgb(r, g, b));
+}
diff --git a/OrchestratorIDE.Avalonia/UI/Controls/SourcePreviewPanel.axaml b/OrchestratorIDE.Avalonia/UI/Controls/SourcePreviewPanel.axaml
new file mode 100644
index 00000000..3b2e5b93
--- /dev/null
+++ b/OrchestratorIDE.Avalonia/UI/Controls/SourcePreviewPanel.axaml
@@ -0,0 +1,20 @@
+<!-- Copyright (C) 2025-present hardcoreerik / TheOrc contributors | SPDX-License-Identifier: AGPL-3.0-or-later -->
+<UserControl x:Class="OrchestratorIDE.UI.Controls.SourcePreviewPanel"
+             xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             Width="372"
+             IsVisible="False"
+             Background="#0A0D0A">
+
+    <!--
+    CF-5 source-preview right rail. Opens on citation click, closes on ✕ or corpus
+    detach. Dynamic content built in code-behind (see ChatPanel.axaml.cs convention).
+    -->
+    <DockPanel x:Name="RootDock">
+        <Border x:Name="HeaderBorder" DockPanel.Dock="Top" />
+        <Border x:Name="FooterBorder" DockPanel.Dock="Bottom" />
+        <ScrollViewer>
+            <StackPanel x:Name="BodyStack" Spacing="10" Margin="14,10,14,14" />
+        </ScrollViewer>
+    </DockPanel>
+</UserControl>
diff --git a/OrchestratorIDE.Avalonia/UI/Controls/SourcePreviewPanel.axaml.cs b/OrchestratorIDE.Avalonia/UI/Controls/SourcePreviewPanel.axaml.cs
new file mode 100644
index 00000000..bc11dd18
--- /dev/null
+++ b/OrchestratorIDE.Avalonia/UI/Controls/SourcePreviewPanel.axaml.cs
@@ -0,0 +1,166 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Documents;
+using Avalonia.Layout;
+using Avalonia.Media;
+using OrchestratorIDE.UI.ViewModels;
+
+namespace OrchestratorIDE.UI.Controls;
+
+/// <summary>
+/// CF-5 source-preview right rail — code-behind-only, mirrors LibraryDrawerControl's
+/// dynamic-content convention.
+/// </summary>
+public partial class SourcePreviewPanel : UserControl
+{
+    public event Action? CloseRequested;
+    public event Action<CitationViewModel>? SaveToNotebookRequested;
+
+    private CitationViewModel? _citation;
+
+    public SourcePreviewPanel()
+    {
+        InitializeComponent();
+        BuildHeader();
+        BuildFooter();
+    }
+
+    public void LoadCitation(CitationViewModel citation, LibraryViewModel libraryVm)
+    {
+        _citation = citation;
+        IsVisible = true;
+
+        var document = libraryVm.Repository.GetDocument(citation.DocumentId);
+        var segment = libraryVm.Repository.GetSegment(citation.SegmentId);
+
+        BodyStack.Children.Clear();
+
+        var meta = new StackPanel { Spacing = 4 };
+        meta.Children.Add(new TextBlock
+        {
+            Text = document?.DisplayName ?? citation.DocumentId,
+            FontSize = 12.5, FontWeight = FontWeight.SemiBold, Foreground = Brush(0xD8, 0xE4, 0xD0),
+        });
+        meta.Children.Add(new TextBlock
+        {
+            Text = $"{(string.IsNullOrWhiteSpace(citation.HeadingPath) ? segment?.HeadingPath ?? "" : citation.HeadingPath)} · seg-{Short(citation.SegmentId)} · {citation.CharStart}-{citation.CharEnd}",
+            FontFamily = new FontFamily("JetBrains Mono, Consolas, monospace"),
+            FontSize = 10, Foreground = Brush(0x6E, 0x80, 0x68), LineHeight = 16,
+        });
+        meta.Children.Add(BuildVerificationBadge(citation));
+
+        BodyStack.Children.Add(new Border
+        {
+            Background = Brush(0x0E, 0x14, 0x0E), BorderBrush = Brush(0x1A, 0x24, 0x1A),
+            BorderThickness = new Thickness(1), CornerRadius = new CornerRadius(8),
+            Padding = new Thickness(10), Child = meta,
+        });
+
+        BodyStack.Children.Add(BuildSourceText(segment?.Text ?? citation.Quote, citation));
+
+        _headerLabel.Text = $"📄 Source · seg-{Short(citation.SegmentId)}";
+    }
+
+    private TextBlock _headerLabel = new();
+
+    private void BuildHeader()
+    {
+        HeaderBorder.BorderBrush = Brush(0x1E, 0x2E, 0x1E);
+        HeaderBorder.BorderThickness = new Thickness(0, 0, 0, 1);
+        HeaderBorder.Padding = new Thickness(14, 10);
+
+        var row = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
+        _headerLabel = new TextBlock
+        {
+            Text = "📄 Source",
+            FontFamily = new FontFamily("JetBrains Mono, Consolas, monospace"),
+            FontSize = 11, Foreground = Brush(0x6E, 0x80, 0x68), VerticalAlignment = VerticalAlignment.Center,
+        };
+        var closeBtn = new Button
+        {
+            Content = "✕", Background = Brushes.Transparent, BorderThickness = new Thickness(0),
+            Foreground = Brush(0x5A, 0x6B, 0x5A), Padding = new Thickness(4),
+        };
+        closeBtn.Click += (_, _) => { IsVisible = false; CloseRequested?.Invoke(); };
+
+        Grid.SetColumn(_headerLabel, 0);
+        Grid.SetColumn(closeBtn, 1);
+        row.Children.Add(_headerLabel);
+        row.Children.Add(closeBtn);
+        HeaderBorder.Child = row;
+    }
+
+    private void BuildFooter()
+    {
+        FooterBorder.BorderBrush = Brush(0x1E, 0x2E, 0x1E);
+        FooterBorder.BorderThickness = new Thickness(0, 1, 0, 0);
+        FooterBorder.Padding = new Thickness(14, 10);
+
+        var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8 };
+        var openBtn = new Button
+        {
+            Content = "Open full segment", FontSize = 10.5, Padding = new Thickness(8, 4),
+            Background = Brush(0x0E, 0x16, 0x0E), BorderBrush = Brush(0x1E, 0x2E, 0x1E), Foreground = Brush(0x9F, 0xB8, 0x90),
+        };
+        var saveBtn = new Button
+        {
+            Content = "Save to notebook", FontSize = 10.5, Padding = new Thickness(8, 4),
+            Background = Brush(0x0E, 0x16, 0x0E), BorderBrush = Brush(0x1E, 0x2E, 0x1E), Foreground = Brush(0x9F, 0xB8, 0x90),
+        };
+        saveBtn.Click += (_, _) =>
+        {
+            if (_citation is not null) SaveToNotebookRequested?.Invoke(_citation);
+        };
+        row.Children.Add(openBtn);
+        row.Children.Add(saveBtn);
+        FooterBorder.Child = row;
+    }
+
+    private static Control BuildVerificationBadge(CitationViewModel citation)
+    {
+        var (text, fg, bg) = citation.IsVerified
+            ? ("✓ supported — exact source match", Brush(0x7F, 0xB0, 0x69), Brush(0x13, 0x25, 0x13))
+            : citation.IsInterpretive
+                ? ("✎ interpretive", Brush(0x7F, 0x94, 0xA8), Brush(0x10, 0x16, 0x1C))
+                : ("⚠ unverified", Brush(0xC0, 0x61, 0x4F), Brush(0x1E, 0x11, 0x0E));
+        return new Border
+        {
+            Background = bg, CornerRadius = new CornerRadius(999), Padding = new Thickness(7, 2),
+            HorizontalAlignment = HorizontalAlignment.Left,
+            Child = new TextBlock { Text = text, FontSize = 10, FontWeight = FontWeight.SemiBold, Foreground = fg },
+        };
+    }
+
+    private static Control BuildSourceText(string sourceText, CitationViewModel citation)
+    {
+        var panel = new TextBlock
+        {
+            FontFamily = new FontFamily("JetBrains Mono, Consolas, monospace"),
+            FontSize = 12.5, LineHeight = 21, TextWrapping = TextWrapping.Wrap,
+            Foreground = Brush(0x8A, 0x9A, 0x84),
+        };
+
+        if (citation.CharStart >= 0 && citation.CharEnd > citation.CharStart && citation.CharEnd <= sourceText.Length)
+        {
+            var before = sourceText[..citation.CharStart];
+            var quote = sourceText[citation.CharStart..citation.CharEnd];
+            var after = sourceText[citation.CharEnd..];
+            var highlightFg = citation.IsVerified ? Color.FromRgb(0xD8, 0xE4, 0xD0) : Color.FromRgb(0xD4, 0xE0, 0xE8);
+            panel.Inlines!.Add(new Run(before));
+            panel.Inlines!.Add(new Run(quote) { Foreground = new SolidColorBrush(highlightFg) });
+            panel.Inlines!.Add(new Run(after));
+        }
+        else
+        {
+            panel.Text = sourceText;
+        }
+
+        return panel;
+    }
+
+    private static string Short(string id) => id.Length <= 8 ? id : id[..8];
+
+    private static SolidColorBrush Brush(byte r, byte g, byte b) => new(Color.FromRgb(r, g, b));
+}
diff --git a/OrchestratorIDE.Avalonia/UI/Panels/ChatPanel.axaml b/OrchestratorIDE.Avalonia/UI/Panels/ChatPanel.axaml
index 5e7bba47..b7d7139a 100644
--- a/OrchestratorIDE.Avalonia/UI/Panels/ChatPanel.axaml
+++ b/OrchestratorIDE.Avalonia/UI/Panels/ChatPanel.axaml
@@ -2,6 +2,7 @@
 <UserControl x:Class="OrchestratorIDE.UI.Panels.ChatPanel"
              xmlns="https://github.com/avaloniaui"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:controls="using:OrchestratorIDE.UI.Controls"
              Background="{StaticResource Br.Bg.App}">
 
     <!--
@@ -106,6 +107,48 @@
             </DockPanel>
         </Border>
 
+        <!-- ── CF-5: corpus bar (library toggle, attached-corpus badge, Quick/Study) ── -->
+        <Border x:Name="BdrCorpusBar"
+                DockPanel.Dock="Top"
+                Background="#0D120D"
+                BorderBrush="{StaticResource Br.Border}"
+                BorderThickness="0,0,0,1"
+                Padding="12,6">
+            <StackPanel Orientation="Horizontal" Spacing="10" VerticalAlignment="Center">
+                <ToggleButton x:Name="BtnToggleLibrary"
+                              Content="📚 Library"
+                              FontSize="11" Padding="8,4"
+                              Background="Transparent" BorderBrush="#2A3A2A"
+                              Foreground="#9FB890"
+                              Click="BtnToggleLibrary_Click"/>
+
+                <Border x:Name="BdrCorpusBadge"
+                        Background="#101A10" BorderBrush="#2A4A2A" BorderThickness="1"
+                        CornerRadius="8" Padding="6,4" IsVisible="False">
+                    <StackPanel Orientation="Horizontal" Spacing="6">
+                        <TextBlock Text="📖" FontSize="11" VerticalAlignment="Center"/>
+                        <TextBlock x:Name="TxtCorpusName" FontSize="12" FontWeight="SemiBold" Foreground="#D8E4D0" VerticalAlignment="Center"/>
+                        <TextBlock x:Name="TxtCorpusStatus" FontSize="9.5" Foreground="#7FB069" VerticalAlignment="Center"/>
+                        <Button x:Name="BtnDetachCorpus" Content="✕" FontSize="10" Padding="3"
+                                Background="Transparent" BorderThickness="0" Foreground="#5A6B5A"
+                                Click="BtnDetachCorpus_Click"/>
+                    </StackPanel>
+                </Border>
+
+                <StackPanel x:Name="StackModeToggle" Orientation="Horizontal" Spacing="3" IsVisible="False"
+                            Background="#0E140E">
+                    <Button x:Name="BtnModeQuick" Content="Quick" FontSize="11.5" Padding="10,5"
+                            Background="#1A2A1A" Foreground="#C4E89A" BorderBrush="#3A5A3A"
+                            Click="BtnModeQuick_Click"/>
+                    <Button x:Name="BtnModeStudy" Content="Study" FontSize="11.5" Padding="10,5"
+                            Background="Transparent" Foreground="#7E8C7E" BorderThickness="0"
+                            Click="BtnModeStudy_Click"/>
+                </StackPanel>
+                <TextBlock x:Name="TxtModeHint" FontSize="10" Foreground="#6E8068" MaxWidth="170"
+                           TextWrapping="Wrap" VerticalAlignment="Center"/>
+            </StackPanel>
+        </Border>
+
         <!-- ── System prompt / sampling controls ───────────── -->
         <Border x:Name="BdrOpenControls"
                 DockPanel.Dock="Top"
@@ -245,49 +288,70 @@
             </StackPanel>
         </Border>
 
-        <!-- ── Chat area ───────────────────────────────────────────── -->
-        <ScrollViewer x:Name="ChatScroll"
-                      VerticalScrollBarVisibility="Auto"
-                      HorizontalScrollBarVisibility="Disabled"
-                      Padding="16,8">
-            <StackPanel x:Name="ChatStack"
-                        Orientation="Vertical"
-                        Margin="0,8,0,16">
+        <!-- ── Chat area + CF-5 library drawer / source preview rails ─ -->
+        <Grid x:Name="LibraryLayoutGrid"
+              ColumnDefinitions="Auto,Auto,*,Auto,Auto">
 
-                <!-- Welcome card (removed from ChatStack on first send) -->
-                <Border x:Name="BdrWelcome"
-                        Background="#111611"
-                        BorderBrush="#1E2E1E" BorderThickness="1"
-                        CornerRadius="8,8,8,2"
-                        Padding="14,10" Margin="0,4,60,4"
-                        HorizontalAlignment="Left" MaxWidth="780">
-                    <StackPanel>
-                        <TextBlock x:Name="TxtWelcomeTitle"
-                                   Text="👋  OrcChat"
-                                   Foreground="#76B900"
-                                   FontSize="14" FontWeight="SemiBold"
-                                   Margin="0,0,0,8"/>
-                        <TextBlock x:Name="TxtWelcomeBody"
-                                   TextWrapping="Wrap"
-                                   Foreground="#A8CC80"
-                                   FontSize="12" LineHeight="20"
-                                   Text="I can search the web and fetch pages when it helps. No system prompt by default — set one above if you want a persona or standing instruction; leave it empty for plain, unfiltered conversation."/>
-                        <TextBlock x:Name="TxtWelcomeTip"
-                                   TextWrapping="Wrap"
-                                   Foreground="#5A7A40"
-                                   FontSize="11" Margin="0,8,0,0" LineHeight="18">
-                            💡  Try: "Summarise the latest news on [topic]" · "Compare X vs Y with sources" · "Find and summarise the docs for [library]"
-                        </TextBlock>
-                        <TextBlock TextWrapping="Wrap"
-                                   Foreground="#444444"
-                                   FontSize="10" Margin="0,10,0,0">
-                            ⌨  Enter to send · Shift+Enter for new line
-                        </TextBlock>
-                    </StackPanel>
-                </Border>
+            <controls:LibraryDrawerControl x:Name="LibraryDrawer"
+                                            Grid.Column="0"
+                                            IsVisible="False"/>
+            <GridSplitter x:Name="LibraryDrawerSplitter"
+                          Grid.Column="1"
+                          Width="3" Background="#1E2E1E"
+                          IsVisible="False"/>
 
-            </StackPanel>
-        </ScrollViewer>
+            <ScrollViewer x:Name="ChatScroll"
+                          Grid.Column="2"
+                          VerticalScrollBarVisibility="Auto"
+                          HorizontalScrollBarVisibility="Disabled"
+                          Padding="16,8">
+                <StackPanel x:Name="ChatStack"
+                            Orientation="Vertical"
+                            Margin="0,8,0,16">
+
+                    <!-- Welcome card (removed from ChatStack on first send) -->
+                    <Border x:Name="BdrWelcome"
+                            Background="#111611"
+                            BorderBrush="#1E2E1E" BorderThickness="1"
+                            CornerRadius="8,8,8,2"
+                            Padding="14,10" Margin="0,4,60,4"
+                            HorizontalAlignment="Left" MaxWidth="780">
+                        <StackPanel>
+                            <TextBlock x:Name="TxtWelcomeTitle"
+                                       Text="👋  OrcChat"
+                                       Foreground="#76B900"
+                                       FontSize="14" FontWeight="SemiBold"
+                                       Margin="0,0,0,8"/>
+                            <TextBlock x:Name="TxtWelcomeBody"
+                                       TextWrapping="Wrap"
+                                       Foreground="#A8CC80"
+                                       FontSize="12" LineHeight="20"
+                                       Text="I can search the web and fetch pages when it helps. No system prompt by default — set one above if you want a persona or standing instruction; leave it empty for plain, unfiltered conversation."/>
+                            <TextBlock x:Name="TxtWelcomeTip"
+                                       TextWrapping="Wrap"
+                                       Foreground="#5A7A40"
+                                       FontSize="11" Margin="0,8,0,0" LineHeight="18">
+                                💡  Try: "Summarise the latest news on [topic]" · "Compare X vs Y with sources" · "Find and summarise the docs for [library]"
+                            </TextBlock>
+                            <TextBlock TextWrapping="Wrap"
+                                       Foreground="#444444"
+                                       FontSize="10" Margin="0,10,0,0">
+                                ⌨  Enter to send · Shift+Enter for new line
+                            </TextBlock>
+                        </StackPanel>
+                    </Border>
+
+                </StackPanel>
+            </ScrollViewer>
+
+            <GridSplitter x:Name="SourcePreviewSplitter"
+                          Grid.Column="3"
+                          Width="3" Background="#1E2E1E"
+                          IsVisible="False"/>
+            <controls:SourcePreviewPanel x:Name="SourcePreviewPanel"
+                                          Grid.Column="4"
+                                          IsVisible="False"/>
+        </Grid>
 
     </DockPanel>
 </UserControl>
diff --git a/OrchestratorIDE.Avalonia/UI/Panels/ChatPanel.axaml.cs b/OrchestratorIDE.Avalonia/UI/Panels/ChatPanel.axaml.cs
index a12e3f06..c7ed201c 100644
--- a/OrchestratorIDE.Avalonia/UI/Panels/ChatPanel.axaml.cs
+++ b/OrchestratorIDE.Avalonia/UI/Panels/ChatPanel.axaml.cs
@@ -16,11 +16,24 @@
 using OrchestratorIDE.Models;
 using OrchestratorIDE.Research;
 using OrchestratorIDE.Services;
+using OrchestratorIDE.Services.ContextFabric;
 using OrchestratorIDE.Services.Hive;
 using OrchestratorIDE.UI.Controls;
+using OrchestratorIDE.UI.ViewModels;
 
 namespace OrchestratorIDE.UI.Panels;
 
+/// <summary>CF-5: tracks the corpus currently attached to this conversation, if any.</summary>
+public sealed record CorpusAttachmentState(
+    string CorpusId,
+    string DisplayName,
+    string Edition,
+    string Mode,                // "Quick" | "Study" (FabricQueryMode casing for the planner)
+    string CoverageStatus,      // "complete" | "partial" | "none"
+    bool IsStale,
+    bool IsReadOnly,
+    string PolicyProfile);      // "default" | "medical" | ...
+
 /// <summary>
 /// OrcChat — the single merged chat surface (formerly separate Research/Open modes). Web
 /// search/fetch tools are always available to the model, but no system prompt is injected by
@@ -64,6 +77,14 @@ public partial class ChatPanel : UserControl
     // to a temp file instead of polluting the user's actual saved system prompt.
     internal string?                 MemoryStorePathOverride { get; set; }
 
+    // ── CF-5 Library state ──────────────────────────────────────────────────────
+    private CorpusAttachmentState?      _corpus;        // null = plain chat; non-null = source-bound
+    private LibraryViewModel?           _libraryVm;
+    private FabricAskService?           _askService;
+    private FabricIndexingOrchestrator? _indexingOrchestrator;
+    private string                      _notebookPath = "";
+    private readonly List<ConversationNotebookEntry> _notebookEntries = [];
+
     // ── Construction ──────────────────────────────────────────────────────────
 
     public ChatPanel()
@@ -72,6 +93,11 @@ public ChatPanel()
         CbNode.Items.Add(LocalNodeName);
         CbNode.SelectedIndex = 0;
 
+        LibraryDrawer.CorpusAttachRequested += OnCorpusAttachRequested;
+        LibraryDrawer.CorpusDetachRequested += OnCorpusDetachRequested;
+        SourcePreviewPanel.CloseRequested += OnSourcePreviewClosed;
+        SourcePreviewPanel.SaveToNotebookRequested += OnSaveToNotebookRequested;
+
         // Auto-saves the system prompt on every edit -- including a preset button's
         // programmatic Text assignment, which also fires TextChanged. This is the actual
         // persistence mechanism: whatever the user puts here (a chosen name, a standing
@@ -148,6 +174,31 @@ internal void RefreshHiveHosts(string? storePath)
         CbNode.SelectedIndex = idx >= 0 ? idx : 0;
     }
 
+    /// <summary>
+    /// Wires the CF-5 Context Fabric Library services into this panel — called by
+    /// MainWindow after construction, same lifecycle as SetModels(). Until this is called,
+    /// the library drawer/source-preview rails stay hidden and chat behaves exactly as
+    /// before CF-5 (plain ChatEngine path only).
+    /// </summary>
+    public void SetFabricServices(
+        FabricAskService askService,
+        FabricIndexingOrchestrator indexingOrchestrator,
+        LibraryViewModel libraryVm,
+        FabricWebImporter? webImporter,
+        string workspaceRoot)
+    {
+        _askService           = askService;
+        _indexingOrchestrator = indexingOrchestrator;
+        _libraryVm            = libraryVm;
+        _notebookPath         = ConversationNotebookStore.StorePath(workspaceRoot, "default");
+
+        _notebookEntries.Clear();
+        _notebookEntries.AddRange(ConversationNotebookStore.Load(_notebookPath));
+
+        LibraryDrawer.Attach(libraryVm, indexingOrchestrator, webImporter);
+        LibraryDrawer.UpdateNotebook(_notebookEntries);
+    }
+
     // ── System-prompt presets ────────────────────────────────────────────────────
     // Concrete, behaviorally-specific instructions, not vague dispositions -- "answer
     // without judgment" tested out to have near-zero effect in real use, while a concrete
@@ -365,6 +416,18 @@ private async Task SendAsync()
         var text = TbInput.Text?.Trim() ?? "";
         if ((string.IsNullOrEmpty(text) && _pendingAttachments.Count == 0) || _isSending) return;
 
+        // ── CF-5: route through FabricAskService when a corpus is attached ───────
+        // Source-bound asks skip the Ollama model picker entirely (FabricAskService
+        // generates via the native IRoleRuntime Reviewer role, not the chat model).
+        // Only takes this path with no pending attachments -- FabricAskService has no
+        // attachment support, so falling through to the plain ChatEngine path below is what
+        // actually sends them instead of silently dropping them.
+        if (_corpus is not null && _askService is not null && !string.IsNullOrEmpty(text) && _pendingAttachments.Count == 0)
+        {
+            await SendFabricAsync(_corpus, text, CancellationToken.None);
+            return;
+        }
+
         var model = CbModel.SelectedItem as string ?? "";
         if (string.IsNullOrEmpty(model)) return;
 
@@ -446,6 +509,341 @@ private async Task SendAsync()
         }
     }
 
+    // ── CF-5: source-bound ask path ──────────────────────────────────────────
+
+    private async Task SendFabricAsync(CorpusAttachmentState corpus, string question, CancellationToken ct)
+    {
+        if (_askService is null) return;
+
+        if (BdrWelcome.IsVisible)
+        {
+            ChatStack.Children.Remove(BdrWelcome);
+            BdrWelcome.IsVisible = false;
+        }
+
+        TbInput.Clear();
+        _isSending = true;
+        BtnSend.IsEnabled = false;
+
+        AppendUserBubble(question, []);
+        var placeholder = new TextBlock { Text = "…", Foreground = new SolidColorBrush(Color.FromRgb(0x7E, 0x8C, 0x7E)) };
+        var bubble = MakeAssistantBubble(placeholder);
+        ChatStack.Children.Add(bubble);
+        ScrollToBottom();
+
+        var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+        _cts = cts;
+
+        try
+        {
+            // No ConfigureAwait(false) -- the finally block below touches UI-thread-only
+            // controls (BtnSend.IsEnabled), so this must resume on Avalonia's UI-thread
+            // SynchronizationContext, same as the rest of this method.
+            var result = await _askService.AskAsync(question, corpus.CorpusId, corpus.Mode, cts.Token);
+
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                bubble.Child = BuildCitedAnswerView(result, corpus);
+                bubble.Tag = result.Answer;
+                ScrollToBottom();
+            });
+        }
+        catch (OperationCanceledException)
+        {
+            // user cancelled
+        }
+        catch (Exception ex)
+        {
+            await Dispatcher.UIThread.InvokeAsync(() =>
+                bubble.Child = new TextBlock
+                {
+                    Text = $"⚠ Library ask failed: {ex.Message}",
+                    Foreground = new SolidColorBrush(Color.FromRgb(0xC0, 0x61, 0x4F)),
+                    TextWrapping = TextWrapping.Wrap,
+                });
+        }
+        finally
+        {
+            _isSending = false;
+            BtnSend.IsEnabled = true;
+            if (ReferenceEquals(_cts, cts)) _cts = null;
+            cts.Dispose();
+        }
+    }
+
+    private Control BuildCitedAnswerView(FabricAskResult result, CorpusAttachmentState corpus)
+    {
+        var stack = new StackPanel { Spacing = 6 };
+
+        if (corpus.IsStale || (result.SegmentsTotal > 0 && result.SegmentsConsidered < result.SegmentsTotal * 0.5))
+        {
+            stack.Children.Add(new Border
+            {
+                Background = new SolidColorBrush(Color.FromRgb(0x22, 0x1B, 0x0C)),
+                BorderBrush = new SolidColorBrush(Color.FromRgb(0x4A, 0x3C, 0x18)),
+                BorderThickness = new Avalonia.Thickness(0, 0, 0, 1),
+                Padding = new Avalonia.Thickness(0, 0, 0, 6),
+                Child = new TextBlock
+                {
+                    Text = $"⚠ Index incomplete — answers may miss sections. Coverage: {result.SegmentsConsidered}/{result.SegmentsTotal} segments.",
+                    Foreground = new SolidColorBrush(Color.FromRgb(0xD6, 0xA8, 0x5A)),
+                    FontSize = 11,
+                    TextWrapping = TextWrapping.Wrap,
+                },
+            });
+        }
+
+        if (!string.Equals(corpus.PolicyProfile, "default", StringComparison.OrdinalIgnoreCase))
+        {
+            stack.Children.Add(new TextBlock
+            {
+                Text = "Educational interpretation of the cited source — not professional advice.",
+                Foreground = new SolidColorBrush(Color.FromRgb(0xA8, 0xC4, 0xD8)),
+                FontSize = 11,
+                TextWrapping = TextWrapping.Wrap,
+            });
+        }
+
+        if (!result.FitsBudget)
+        {
+            stack.Children.Add(new TextBlock
+            {
+                Text = "Evidence truncated by token budget — ask a narrower question or switch to Study.",
+                Foreground = new SolidColorBrush(Color.FromRgb(0xD6, 0xA8, 0x5A)),
+                FontSize = 11,
+                TextWrapping = TextWrapping.Wrap,
+            });
+        }
+
+        if (result.Abstained)
+        {
+            stack.Children.Add(new TextBlock { Text = result.Answer, TextWrapping = TextWrapping.Wrap, Foreground = new SolidColorBrush(Color.FromRgb(0xD4, 0xD4, 0xD4)) });
+        }
+        else
+        {
+            stack.Children.Add(new MarkdownView { Text = result.Answer, LinkClicked = OpenChatLink });
+        }
+
+        stack.Children.Add(BuildCoverageLine(result, corpus));
+
+        var citations = BuildCitationViewModels(result, corpus.CorpusId);
+        foreach (var cit in citations)
+            stack.Children.Add(BuildFootnoteRow(cit));
+
+        return stack;
+    }
+
+    private static Control BuildCoverageLine(FabricAskResult result, CorpusAttachmentState corpus)
+    {
+        var row = new StackPanel
+        {
+            Orientation = Orientation.Horizontal,
+            Spacing = 8,
+            Margin = new Avalonia.Thickness(0, 6, 0, 0),
+        };
+        var mono = new FontFamily("JetBrains Mono, Consolas, monospace");
+
+        row.Children.Add(new Border
+        {
+            Background = new SolidColorBrush(Color.FromRgb(0x13, 0x25, 0x13)),
+            BorderBrush = new SolidColorBrush(Color.FromRgb(0x2F, 0x4F, 0x2F)),
+            BorderThickness = new Avalonia.Thickness(1),
+            CornerRadius = new Avalonia.CornerRadius(999),
+            Padding = new Avalonia.Thickness(7, 2),
+            Child = new TextBlock
+            {
+                Text = string.Equals(result.Mode, "study", StringComparison.OrdinalIgnoreCase) ? "Study mode" : "Quick mode",
+                FontFamily = mono, FontSize = 10, Foreground = new SolidColorBrush(Color.FromRgb(0x9F, 0xD3, 0x7F)),
+            },
+        });
+
+        var reopened = result.TriggeredSourceReopen ? $" · reopened {result.SegmentsConsidered} sources" : "";
+        row.Children.Add(new TextBlock
+        {
+            Text = $"considered {result.SegmentsConsidered} / {result.SegmentsTotal} segments{reopened}",
+            FontFamily = mono, FontSize = 10, Foreground = new SolidColorBrush(Color.FromRgb(0x6E, 0x80, 0x68)),
+            VerticalAlignment = VerticalAlignment.Center,
+        });
+
+        var allVerified = result.Claims.Count == 0 || result.Claims.All(c => c.VerificationLabel is "supported" or "partially_supported");
+        row.Children.Add(new TextBlock
+        {
+            Text = allVerified ? "✓ citations verified" : "⚠ coverage incomplete",
+            FontFamily = mono, FontSize = 10,
+            Foreground = new SolidColorBrush(allVerified ? Color.FromRgb(0x7F, 0xB0, 0x69) : Color.FromRgb(0xD6, 0xA8, 0x5A)),
+            VerticalAlignment = VerticalAlignment.Center,
+        });
+
+        var interpretiveCount = result.Claims.Count(c => c.VerificationLabel == "interpretive");
+        if (interpretiveCount > 0)
+        {
+            row.Children.Add(new TextBlock
+            {
+                Text = $"✎ {interpretiveCount} interpretive",
+                FontFamily = mono, FontSize = 10, Foreground = new SolidColorBrush(Color.FromRgb(0x7F, 0x94, 0xA8)),
+                VerticalAlignment = VerticalAlignment.Center,
+            });
+        }
+
+        return row;
+    }
+
+    private List<CitationViewModel> BuildCitationViewModels(FabricAskResult result, string corpusId)
+    {
+        var list = new List<CitationViewModel>();
+        var seen = new HashSet<int>();
+        foreach (var claim in result.Claims)
+            foreach (var cit in claim.Citations)
+            {
+                if (!seen.Add(cit.Index)) continue;
+                // FabricAskService leaves HeadingPath blank by design ("resolved from repo at
+                // render time in the UI layer" -- see FabricAskService.BuildCitationDetail).
+                var heading = string.IsNullOrWhiteSpace(cit.HeadingPath)
+                    ? _libraryVm?.Repository.GetSegment(cit.SegmentId)?.HeadingPath ?? ""
+                    : cit.HeadingPath;
+                list.Add(new CitationViewModel(
+                    cit.Index, cit.SegmentId, corpusId, heading,
+                    cit.CharStart, cit.CharEnd, cit.Quote,
+                    MapVerificationLabel(cit.VerificationLabel)));
+            }
+        return list;
+    }
+
+    private static string MapVerificationLabel(string fabricLabel) => fabricLabel switch
+    {
+        FabricCitationVerificationLabel.Supported => "Supported",
+        FabricCitationVerificationLabel.PartiallySupported => "PartiallySupported",
+        FabricCitationVerificationLabel.Interpretive => "Interpretive",
+        FabricCitationVerificationLabel.CitationMismatch => "CitationMismatch",
+        _ => "Unverifiable",
+    };
+
+    private Control BuildFootnoteRow(CitationViewModel cit)
+    {
+        var (fg, bg) = cit.IsVerified
+            ? (Color.FromRgb(0x9F, 0xD3, 0x7F), Color.FromRgb(0x13, 0x25, 0x13))
+            : cit.IsInterpretive
+                ? (Color.FromRgb(0x7F, 0x94, 0xA8), Color.FromRgb(0x10, 0x16, 0x1C))
+                : (Color.FromRgb(0xC0, 0x61, 0x4F), Color.FromRgb(0x1E, 0x11, 0x0E));
+
+        var row = new Border
+        {
+            Background = new SolidColorBrush(Color.FromRgb(0x0E, 0x14, 0x0E)),
+            BorderBrush = new SolidColorBrush(Color.FromRgb(0x1A, 0x24, 0x1A)),
+            BorderThickness = new Avalonia.Thickness(1),
+            CornerRadius = new Avalonia.CornerRadius(6),
+            Padding = new Avalonia.Thickness(8, 5),
+            Margin = new Avalonia.Thickness(0, 2, 0, 0),
+            Cursor = new Cursor(StandardCursorType.Hand),
+            Child = new StackPanel
+            {
+                Orientation = Orientation.Horizontal,
+                Spacing = 6,
+                Children =
+                {
+                    new Border
+                    {
+                        Background = new SolidColorBrush(bg),
+                        CornerRadius = new Avalonia.CornerRadius(999),
+                        Padding = new Avalonia.Thickness(5, 1),
+                        Child = new TextBlock { Text = $"{cit.Index}", FontSize = 9.5, Foreground = new SolidColorBrush(fg) },
+                    },
+                    new TextBlock
+                    {
+                        Text = string.IsNullOrWhiteSpace(cit.HeadingPath)
+                            ? $"seg-{(cit.SegmentId.Length > 8 ? cit.SegmentId[..8] : cit.SegmentId)} · {cit.CharStart}-{cit.CharEnd} · {cit.VerificationLabel}"
+                            : $"{cit.HeadingPath} · seg-{(cit.SegmentId.Length > 8 ? cit.SegmentId[..8] : cit.SegmentId)} · {cit.CharStart}-{cit.CharEnd} · {cit.VerificationLabel}",
+                        FontFamily = new FontFamily("JetBrains Mono, Consolas, monospace"),
+                        FontSize = 10, Foreground = new SolidColorBrush(Color.FromRgb(0x8A, 0x9A, 0x84)),
+                    },
+                },
+            },
+        };
+        row.PointerPressed += (_, _) => OpenSourcePreview(cit);
+        return row;
+    }
+
+    private void OpenSourcePreview(CitationViewModel cit)
+    {
+        if (_libraryVm is null) return;
+        SourcePreviewPanel.IsVisible = true;
+        SourcePreviewSplitter.IsVisible = true;
+        SourcePreviewPanel.LoadCitation(cit, _libraryVm);
+    }
+
+    // ── CF-5: library drawer / corpus bar event handlers ────────────────────
+
+    private void BtnToggleLibrary_Click(object? sender, RoutedEventArgs e)
+    {
+        var show = !LibraryDrawer.IsVisible;
+        LibraryDrawer.IsVisible = show;
+        LibraryDrawerSplitter.IsVisible = show;
+    }
+
+    private void OnCorpusAttachRequested(string corpusId)
+    {
+        if (_libraryVm is null) return;
+        var corpus = _libraryVm.Corpora.FirstOrDefault(c => c.CorpusId == corpusId);
+        if (corpus is null) return;
+
+        _corpus = new CorpusAttachmentState(
+            corpusId, corpus.Name, "", FabricQueryMode.Quick, "complete", false, false, "default");
+
+        TxtCorpusName.Text = corpus.Name;
+        TxtCorpusStatus.Text = "source-bound · coverage complete";
+        BdrCorpusBadge.IsVisible = true;
+        StackModeToggle.IsVisible = true;
+        SetModeUi(FabricQueryMode.Quick);
+
+        LibraryDrawer.SetAttachedCorpus(corpusId);
+    }
+
+    private void OnCorpusDetachRequested()
+    {
+        _corpus = null;
+        BdrCorpusBadge.IsVisible = false;
+        StackModeToggle.IsVisible = false;
+        TxtModeHint.Text = "";
+        SourcePreviewPanel.IsVisible = false;
+        SourcePreviewSplitter.IsVisible = false;
+        LibraryDrawer.SetAttachedCorpus(null);
+    }
+
+    private void BtnDetachCorpus_Click(object? sender, RoutedEventArgs e) => OnCorpusDetachRequested();
+
+    private void BtnModeQuick_Click(object? sender, RoutedEventArgs e) => SetModeUi(FabricQueryMode.Quick);
+    private void BtnModeStudy_Click(object? sender, RoutedEventArgs e) => SetModeUi(FabricQueryMode.Study);
+
+    private void SetModeUi(string mode)
+    {
+        if (_corpus is not null) _corpus = _corpus with { Mode = mode };
+
+        var isQuick = mode == FabricQueryMode.Quick;
+        BtnModeQuick.Background = isQuick ? new SolidColorBrush(Color.FromRgb(0x1A, 0x2A, 0x1A)) : Brushes.Transparent;
+        BtnModeQuick.Foreground = isQuick ? new SolidColorBrush(Color.FromRgb(0xC4, 0xE8, 0x9A)) : new SolidColorBrush(Color.FromRgb(0x7E, 0x8C, 0x7E));
+        BtnModeStudy.Background = isQuick ? Brushes.Transparent : new SolidColorBrush(Color.FromRgb(0x1A, 0x2A, 0x1A));
+        BtnModeStudy.Foreground = isQuick ? new SolidColorBrush(Color.FromRgb(0x7E, 0x8C, 0x7E)) : new SolidColorBrush(Color.FromRgb(0xC4, 0xE8, 0x9A));
+
+        TxtModeHint.Text = isQuick
+            ? "hybrid retrieval over segments + summaries"
+            : "iterative retrieval + targeted rereading";
+    }
+
+    private void OnSourcePreviewClosed()
+    {
+        SourcePreviewSplitter.IsVisible = false;
+    }
+
+    private void OnSaveToNotebookRequested(CitationViewModel cit)
+    {
+        var entry = new ConversationNotebookEntry(
+            cit.Quote, [cit], DateTimeOffset.UtcNow, Guid.NewGuid().ToString("N"));
+        _notebookEntries.Add(entry);
+        if (!string.IsNullOrEmpty(_notebookPath))
+            ConversationNotebookStore.Append(_notebookPath, entry);
+        LibraryDrawer.UpdateNotebook(_notebookEntries);
+    }
+
     // ── Engine event handlers ─────────────────────────────────────────────────
 
     /// <summary>
diff --git a/OrchestratorIDE.Avalonia/UI/ViewModels/CitationViewModel.cs b/OrchestratorIDE.Avalonia/UI/ViewModels/CitationViewModel.cs
new file mode 100644
index 00000000..7888ef0f
--- /dev/null
+++ b/OrchestratorIDE.Avalonia/UI/ViewModels/CitationViewModel.cs
@@ -0,0 +1,23 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+namespace OrchestratorIDE.UI.ViewModels;
+
+public sealed record CitationViewModel(
+    int Index,
+    string SegmentId,
+    string DocumentId,
+    string HeadingPath,
+    int CharStart,
+    int CharEnd,
+    string Quote,
+    string VerificationLabel)   // Supported | PartiallySupported | Interpretive | CitationMismatch | Unverifiable
+{
+    public bool IsVerified =>
+        VerificationLabel is "Supported" or "PartiallySupported";
+
+    public bool IsInterpretive =>
+        VerificationLabel == "Interpretive";
+
+    public bool IsMismatch =>
+        VerificationLabel is "CitationMismatch" or "Unverifiable";
+}
diff --git a/OrchestratorIDE.Avalonia/UI/ViewModels/IndexProgressViewModel.cs b/OrchestratorIDE.Avalonia/UI/ViewModels/IndexProgressViewModel.cs
new file mode 100644
index 00000000..d315ca94
--- /dev/null
+++ b/OrchestratorIDE.Avalonia/UI/ViewModels/IndexProgressViewModel.cs
@@ -0,0 +1,49 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+using System.Collections.ObjectModel;
+using Avalonia.Threading;
+using OrchestratorIDE.Services.ContextFabric;
+
+namespace OrchestratorIDE.UI.ViewModels;
+
+public sealed class IndexProgressViewModel : System.ComponentModel.INotifyPropertyChanged
+{
+    public event System.ComponentModel.PropertyChangedEventHandler? PropertyChanged;
+
+    public string DocumentId { get; }
+    private IndexStageKind _stage = IndexStageKind.Reading;
+    private int _completed;
+    private int _total;
+    public ObservableCollection<string> FailedSegmentIds { get; } = [];
+
+    public IndexStageKind Stage { get => _stage; private set { _stage = value; Notify(); } }
+    public int CompletedSegments { get => _completed; private set { _completed = value; Notify(); } }
+    public int TotalSegments { get => _total; private set { _total = value; Notify(); } }
+    public double ProgressFraction => TotalSegments == 0 ? 0 : (double)CompletedSegments / TotalSegments;
+    public string StageLabel => Stage switch
+    {
+        IndexStageKind.Parsing  => "Parsing source…",
+        IndexStageKind.Reading  => $"Reading evidence cards · {CompletedSegments}/{TotalSegments}",
+        IndexStageKind.Reducing => "Building memory hierarchy…",
+        IndexStageKind.Complete => "Ready",
+        IndexStageKind.Failed   => "Failed",
+        _ => "",
+    };
+
+    public IndexProgressViewModel(string documentId) => DocumentId = documentId;
+
+    public void Apply(IndexStageEvent ev)
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            Stage = ev.Stage;
+            CompletedSegments = ev.CompletedSegments;
+            TotalSegments = ev.TotalSegments;
+            FailedSegmentIds.Clear();
+            foreach (var id in ev.FailedSegmentIds) FailedSegmentIds.Add(id);
+        });
+    }
+
+    private void Notify([System.Runtime.CompilerServices.CallerMemberName] string? n = null) =>
+        PropertyChanged?.Invoke(this, new System.ComponentModel.PropertyChangedEventArgs(n));
+}
diff --git a/OrchestratorIDE.Avalonia/UI/ViewModels/LibraryViewModel.cs b/OrchestratorIDE.Avalonia/UI/ViewModels/LibraryViewModel.cs
new file mode 100644
index 00000000..576c7332
--- /dev/null
+++ b/OrchestratorIDE.Avalonia/UI/ViewModels/LibraryViewModel.cs
@@ -0,0 +1,108 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// CF-5: Observable wrapper over FabricLibraryService for the Library drawer.
+
+using System.Collections.ObjectModel;
+using Avalonia.Threading;
+using OrchestratorIDE.Services.ContextFabric;
+
+namespace OrchestratorIDE.UI.ViewModels;
+
+/// <summary>
+/// Thin observable wrapper over FabricLibraryService.
+/// Follows the same "no-MVVM-framework" pattern as the rest of the Avalonia UI:
+/// raise PropertyChanged manually; bind directly in code-behind.
+/// </summary>
+public sealed class LibraryViewModel : System.ComponentModel.INotifyPropertyChanged
+{
+    public event System.ComponentModel.PropertyChangedEventHandler? PropertyChanged;
+
+    private readonly FabricLibraryService _library;
+    private readonly FabricLibraryRepository _repository;
+
+    public FabricLibraryRepository Repository => _repository;
+
+    public ObservableCollection<CorpusCardViewModel> Corpora { get; } = [];
+    public ObservableCollection<FabricSearchHit> SearchResults { get; } = [];
+
+    private string _searchQuery = "";
+    public string SearchQuery
+    {
+        get => _searchQuery;
+        set
+        {
+            if (_searchQuery == value) return;
+            _searchQuery = value;
+            OnPropertyChanged();
+            Dispatcher.UIThread.Post(RefreshSearch);
+        }
+    }
+
+    private string _storagePath = "";
+    public string StoragePath
+    {
+        get => _storagePath;
+        set { _storagePath = value; OnPropertyChanged(); }
+    }
+
+    public LibraryViewModel(FabricLibraryService library, FabricLibraryRepository repository, string storagePath)
+    {
+        _library = library;
+        _repository = repository;
+        StoragePath = storagePath;
+        Refresh();
+    }
+
+    public void Refresh()
+    {
+        Corpora.Clear();
+        foreach (var corpus in _library.ListCorpora())
+        {
+            var docs = _library.ListDocuments(corpus.CorpusId);
+            Corpora.Add(new CorpusCardViewModel(corpus, docs, _repository));
+        }
+    }
+
+    public FabricCorpusEntry CreateCorpus(string name, string? description = null) =>
+        _library.CreateCorpus(name, description);
+
+    public async Task<FabricImportResult> ImportFileAsync(
+        string corpusId, string path, CancellationToken ct = default)
+    {
+        var result = await _library.ImportFileAsync(corpusId, path, ct: ct).ConfigureAwait(false);
+        Dispatcher.UIThread.Post(Refresh);
+        return result;
+    }
+
+    public bool DeleteCorpus(string corpusId)
+    {
+        var ok = _library.DeleteCorpus(corpusId);
+        if (ok) Dispatcher.UIThread.Post(Refresh);
+        return ok;
+    }
+
+    private void RefreshSearch()
+    {
+        SearchResults.Clear();
+        if (string.IsNullOrWhiteSpace(_searchQuery)) return;
+        foreach (var hit in _library.Search(_searchQuery, limit: 20))
+            SearchResults.Add(hit);
+    }
+
+    private void OnPropertyChanged([System.Runtime.CompilerServices.CallerMemberName] string? name = null) =>
+        PropertyChanged?.Invoke(this, new System.ComponentModel.PropertyChangedEventArgs(name));
+}
+
+public sealed class CorpusCardViewModel(
+    FabricCorpusEntry corpus,
+    IReadOnlyList<FabricDocumentEntry> documents,
+    FabricLibraryRepository repository)
+{
+    public string CorpusId => corpus.CorpusId;
+    public string Name => corpus.Name;
+    public string Description => corpus.Description ?? "";
+    public string Status => corpus.Status;   // ready | indexing | stale | failed
+    public IReadOnlyList<FabricDocumentEntry> Documents => documents;
+    public int TotalSegments => documents.Sum(d => repository.GetSegments(d.DocumentId).Count);
+    public bool IsAttached { get; set; }
+}
diff --git a/OrchestratorIDE.UnitTests/ContextFabricAskServiceTests.cs b/OrchestratorIDE.UnitTests/ContextFabricAskServiceTests.cs
new file mode 100644
index 00000000..c51c6bd6
--- /dev/null
+++ b/OrchestratorIDE.UnitTests/ContextFabricAskServiceTests.cs
@@ -0,0 +1,175 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+using System.Runtime.CompilerServices;
+using NUnit.Framework;
+using OrchestratorIDE.Core.Runtime;
+using OrchestratorIDE.Models;
+using OrchestratorIDE.Services.ContextFabric;
+using OrchestratorIDE.Services.Data;
+
+namespace OrchestratorIDE.UnitTests;
+
+[TestFixture]
+public sealed class ContextFabricAskServiceTests
+{
+    [Test]
+    public async Task AskAsync_Returns_Supported_Citation_For_Exact_Quote()
+    {
+        using var harness = NewHarness();
+        var quote = "LANTERN is the assigned call sign.";
+        var runtime = new FakeAskRuntime(BuildAnswerJson(quote, "seg-0"));
+        var service = harness.NewAskService(runtime);
+
+        var result = await service.AskAsync("What is the call sign?", harness.Corpus.CorpusId, FabricQueryMode.Quick);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.Abstained, Is.False);
+            Assert.That(result.Mode, Is.EqualTo(FabricQueryMode.Quick));
+            Assert.That(result.SegmentsTotal, Is.EqualTo(2));
+            Assert.That(result.Claims, Has.Count.EqualTo(1));
+            Assert.That(result.Claims[0].VerificationLabel, Is.EqualTo(FabricCitationVerificationLabel.Supported));
+            Assert.That(result.Claims[0].Citations.Single().Quote, Is.EqualTo(quote));
+        });
+    }
+
+    [Test]
+    public async Task AskAsync_Marks_Mismatched_Citation()
+    {
+        using var harness = NewHarness();
+        var runtime = new FakeAskRuntime(BuildAnswerJson("LANTERN is the call sign.", "seg-0", quoteDigest: "wrong-digest"));
+        var service = harness.NewAskService(runtime);
+
+        var result = await service.AskAsync("What is the call sign?", harness.Corpus.CorpusId, FabricQueryMode.Quick);
+
+        Assert.That(result.Claims[0].VerificationLabel, Is.EqualTo(FabricCitationVerificationLabel.CitationMismatch));
+    }
+
+    [Test]
+    public async Task AskAsync_Surfaces_Abstention()
+    {
+        using var harness = NewHarness();
+        var runtime = new FakeAskRuntime("""{"schemaVersion":"cf0-answer-1.0","answer":"The provided sources do not contain sufficient evidence to answer this question.","abstained":true,"claims":[]}""");
+        var service = harness.NewAskService(runtime);
+
+        var result = await service.AskAsync("What is the orbital period?", harness.Corpus.CorpusId, FabricQueryMode.Quick);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.Abstained, Is.True);
+            Assert.That(result.Claims, Is.Empty);
+        });
+    }
+
+    [Test]
+    public void AskAsync_Rejects_Blank_Question()
+    {
+        using var harness = NewHarness();
+        var service = harness.NewAskService(new FakeAskRuntime("{}"));
+
+        Assert.That(
+            () => service.AskAsync("   ", harness.Corpus.CorpusId, FabricQueryMode.Quick).GetAwaiter().GetResult(),
+            Throws.TypeOf<ArgumentException>());
+    }
+
+    private static string BuildAnswerJson(string quote, string segmentId, string? quoteDigest = null) =>
+        $$"""
+        {"schemaVersion":"cf0-answer-1.0","answer":"{{quote}}","abstained":false,"claims":[{"text":"{{quote}}","citations":[{"segmentId":"{{segmentId}}","charStart":0,"charEnd":{{quote.Length}},"quote":"{{quote}}","quoteDigest":"{{quoteDigest ?? FabricHashing.Sha256(quote)}}"}]}]}
+        """;
+
+    private static Harness NewHarness()
+    {
+        var store = new SqliteStore(":memory:");
+        store.Initialize();
+        var library = new FabricLibraryRepository(store);
+        var graph = new DocumentGraphRepository(store);
+        var corpus = library.CreateCorpus("cf5-ask-corpus", "CF-5 ask lane");
+        var now = DateTimeOffset.UtcNow;
+        var document = new FabricDocumentEntry(
+            "cf5-ask-doc",
+            corpus.CorpusId,
+            "source-digest",
+            "normalized-digest",
+            "CF-5 Ask Notes",
+            "text/plain",
+            FabricIngestionVersions.TextMarkdownParser,
+            FabricIngestionVersions.TextMarkdownParser,
+            "ready",
+            [],
+            now,
+            now);
+
+        var texts = new[]
+        {
+            "LANTERN is the assigned call sign.",
+            "Emergency frequency is 17.4 MHz.",
+        };
+        var start = 0;
+        library.ReplaceDocument(document, texts.Select((text, index) =>
+        {
+            var draft = new FabricSegmentDraft(
+                $"seg-{index}",
+                index,
+                $"Section {index}",
+                start,
+                start + text.Length,
+                Math.Max(6, text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length),
+                FabricHashing.Sha256(text),
+                text,
+                index > 0 ? $"seg-{index - 1}" : null,
+                index < texts.Length - 1 ? $"seg-{index + 1}" : null,
+                FabricIngestionVersions.Segmenter);
+            start += text.Length + 1;
+            return draft;
+        }).ToArray());
+
+        return new Harness(store, library, graph, corpus, document);
+    }
+
+    private sealed class Harness(
+        SqliteStore store,
+        FabricLibraryRepository library,
+        DocumentGraphRepository graph,
+        FabricCorpusEntry corpus,
+        FabricDocumentEntry document) : IDisposable
+    {
+        public FabricCorpusEntry Corpus { get; } = corpus;
+        public FabricDocumentEntry Document { get; } = document;
+
+        public FabricAskService NewAskService(IRoleRuntime runtime)
+        {
+            var search = new FabricSearchService(library, graph);
+            var planner = new FabricQueryPlanner(search, graph);
+            var packBuilder = new EvidencePackBuilder(library, graph);
+            var verifier = new FabricCitationVerifier(library);
+            return new FabricAskService(planner, packBuilder, verifier, library, runtime);
+        }
+
+        public void Dispose() => store.Dispose();
+    }
+
+    /// <summary>Minimal IRoleRuntime stand-in for FabricAskService — returns one canned JSON
+    /// answer regardless of prompt content, since these tests only assert on the
+    /// verification/parsing path, not retrieval-driven prompt content.</summary>
+    private sealed class FakeAskRuntime(string answerJson) : IRoleRuntime
+    {
+        public string RuntimeName => "fake-ask-runtime";
+
+        public async IAsyncEnumerable<string> StreamRoleCompletionAsync(
+            RuntimeRole role,
+            IEnumerable<AgentMessage> history,
+            IReadOnlyList<object>? tools = null,
+            double temperature = 0.1,
+            int maxTokens = 4096,
+            Action<ToolCall>? onToolCall = null,
+            Action<int, int>? onUsage = null,
+            [EnumeratorCancellation] CancellationToken ct = default)
+        {
+            await Task.Yield();
+            yield return answerJson;
+        }
+
+        public RuntimeHealth GetHealth(RuntimeRole? role = null) => new(true, RuntimeName, "fake.gguf");
+        public RuntimeStats GetStats(RuntimeRole? role = null) => new(RuntimeName, "fake.gguf");
+    }
+}
diff --git a/OrchestratorIDE.UnitTests/ContextFabricIndexingOrchestratorTests.cs b/OrchestratorIDE.UnitTests/ContextFabricIndexingOrchestratorTests.cs
new file mode 100644
index 00000000..33403703
--- /dev/null
+++ b/OrchestratorIDE.UnitTests/ContextFabricIndexingOrchestratorTests.cs
@@ -0,0 +1,212 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+using NUnit.Framework;
+using OrchestratorIDE.Services.ContextFabric;
+using OrchestratorIDE.Services.Data;
+
+namespace OrchestratorIDE.UnitTests;
+
+[TestFixture]
+public sealed class ContextFabricIndexingOrchestratorTests
+{
+    [Test]
+    public async Task IndexDocumentAsync_Reads_Then_Reduces_And_Reports_Complete()
+    {
+        using var harness = NewHarness();
+        var orchestrator = harness.NewOrchestrator();
+        var events = new List<IndexStageEvent>();
+        var progress = new Progress<IndexStageEvent>(events.Add);
+
+        var result = await orchestrator.IndexDocumentAsync(harness.Document.DocumentId, readOnly: false, progress);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.Stage, Is.EqualTo(IndexStageKind.Complete));
+            Assert.That(result.CompletedSegments, Is.EqualTo(2));
+            Assert.That(result.FailedSegmentIds, Is.Empty);
+            Assert.That(events.Select(e => e.Stage), Does.Contain(IndexStageKind.Reading));
+            Assert.That(events.Select(e => e.Stage), Does.Contain(IndexStageKind.Reducing));
+            // Reduce actually ran and persisted memory nodes for the document.
+            Assert.That(harness.Graph.ListMemoryNodes(harness.Corpus.CorpusId, harness.Document.DocumentId), Is.Not.Empty);
+        });
+    }
+
+    [Test]
+    public async Task IndexDocumentAsync_ReadOnly_Skips_Reduce_Stage()
+    {
+        using var harness = NewHarness();
+        var orchestrator = harness.NewOrchestrator();
+        var events = new List<IndexStageEvent>();
+        var progress = new Progress<IndexStageEvent>(events.Add);
+
+        var result = await orchestrator.IndexDocumentAsync(harness.Document.DocumentId, readOnly: true, progress);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.Stage, Is.EqualTo(IndexStageKind.Complete));
+            Assert.That(events.Select(e => e.Stage), Does.Not.Contain(IndexStageKind.Reducing));
+            Assert.That(harness.Graph.ListMemoryNodes(harness.Corpus.CorpusId, harness.Document.DocumentId), Is.Empty);
+        });
+    }
+
+    [Test]
+    public void IndexDocumentAsync_Fails_Fast_When_Document_Has_No_Segments()
+    {
+        using var harness = NewHarness();
+        var orchestrator = harness.NewOrchestrator();
+
+        // FabricLibraryRepository.ReplaceDocument rejects zero-segment documents outright, so
+        // the orchestrator's own guard is only reachable for a document id with no repository
+        // row at all (GetSegments returns empty rather than throwing) — exercise that path.
+        var result = orchestrator.IndexDocumentAsync("missing-doc", readOnly: true).GetAwaiter().GetResult();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.Stage, Is.EqualTo(IndexStageKind.Failed));
+            Assert.That(result.Error, Does.Contain("no segments"));
+        });
+    }
+
+    [Test]
+    public async Task RetryFailedAsync_With_No_Failed_Segments_Delegates_To_Full_Index()
+    {
+        using var harness = NewHarness();
+        var orchestrator = harness.NewOrchestrator();
+
+        var result = await orchestrator.RetryFailedAsync(harness.Document.DocumentId, [], readOnly: false);
+
+        Assert.That(result.Stage, Is.EqualTo(IndexStageKind.Complete));
+        Assert.That(harness.Graph.ListMemoryNodes(harness.Corpus.CorpusId, harness.Document.DocumentId), Is.Not.Empty);
+    }
+
+    [Test]
+    public async Task RetryFailedAsync_Reimports_Only_The_Given_Segments_Without_Wiping_Others()
+    {
+        using var harness = NewHarness();
+        var orchestrator = harness.NewOrchestrator();
+
+        // Full read first — both segments' claims land in the graph.
+        await orchestrator.IndexDocumentAsync(harness.Document.DocumentId, readOnly: true);
+        var claimsBefore = harness.Graph.ListClaimsForDocument(harness.Document.DocumentId, limit: 64);
+        Assert.That(claimsBefore, Has.Count.GreaterThanOrEqualTo(2));
+
+        // Retry only seg-0 — seg-1's previously-imported claims must survive untouched
+        // (RetryFailedAsync uses FabricNativeReaderService.ReadSegmentsAsync + ReplaceSegmentEvidenceCard,
+        // not the document-wide ReplaceDocumentEvidenceCards the full read path uses).
+        var result = await orchestrator.RetryFailedAsync(harness.Document.DocumentId, ["seg-0"], readOnly: true);
+
+        var claimsAfter = harness.Graph.ListClaimsForDocument(harness.Document.DocumentId, limit: 64);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.Stage, Is.EqualTo(IndexStageKind.Complete));
+            Assert.That(claimsAfter.Select(c => c.SegmentId), Does.Contain("seg-1"));
+            Assert.That(claimsAfter.Select(c => c.SegmentId), Does.Contain("seg-0"));
+        });
+    }
+
+    [Test]
+    public void ReplaceSegmentEvidenceCard_Drops_Claims_No_Longer_In_A_Smaller_Retry_Card()
+    {
+        using var harness = NewHarness();
+        var importer = new FabricEvidenceGraphImporter(harness.Library, harness.Graph);
+
+        var firstCard = new FabricEvidenceCard
+        {
+            CorpusId = harness.Corpus.CorpusId,
+            DocumentId = harness.Document.DocumentId,
+            SegmentId = "seg-0",
+            Claims =
+            [
+                new FabricClaim { Text = "LANTERN is the call sign.", Citations = [new FabricCitation { SegmentId = "seg-0", CharStart = 0, CharEnd = 9, Quote = "call sign" }] },
+                new FabricClaim { Text = "A second fact that won't survive the retry.", Citations = [new FabricCitation { SegmentId = "seg-0", CharStart = 9, CharEnd = 20, Quote = "second fact" }] },
+            ],
+        };
+        importer.ReplaceSegmentEvidenceCard(firstCard);
+        Assert.That(harness.Graph.ListClaimsForDocument(harness.Document.DocumentId, limit: 64), Has.Count.EqualTo(2));
+
+        // A retry that returns fewer claims for the same segment must drop the orphaned one,
+        // not just upsert what's present (the bug ImportEvidenceCard had).
+        var retriedCard = firstCard with { Claims = [firstCard.Claims[0]] };
+        importer.ReplaceSegmentEvidenceCard(retriedCard);
+
+        var claims = harness.Graph.ListClaimsForDocument(harness.Document.DocumentId, limit: 64);
+        Assert.Multiple(() =>
+        {
+            Assert.That(claims, Has.Count.EqualTo(1));
+            Assert.That(claims[0].ClaimText, Is.EqualTo("LANTERN is the call sign."));
+        });
+    }
+
+    private static Harness NewHarness(string[]? segments = null, string corpusId = "cf5-corpus", string documentId = "cf5-doc")
+    {
+        var store = new SqliteStore(":memory:");
+        store.Initialize();
+        var library = new FabricLibraryRepository(store);
+        var graph = new DocumentGraphRepository(store);
+        var corpus = library.CreateCorpus(corpusId, "CF-5 indexing lane");
+        var now = DateTimeOffset.UtcNow;
+        var document = new FabricDocumentEntry(
+            documentId,
+            corpus.CorpusId,
+            "source-digest",
+            "normalized-digest",
+            "CF-5 Notes",
+            "text/plain",
+            FabricIngestionVersions.TextMarkdownParser,
+            FabricIngestionVersions.TextMarkdownParser,
+            "ready",
+            [],
+            now,
+            now);
+
+        var texts = segments ?? new[]
+        {
+            "Section about call signs.\nEVIDENCE: LANTERN is the assigned call sign.\n",
+            "Section about frequencies.\nEVIDENCE: Emergency frequency is 17.4 MHz.\n",
+        };
+
+        var start = 0;
+        library.ReplaceDocument(document, texts.Select((text, index) =>
+        {
+            var draft = new FabricSegmentDraft(
+                $"seg-{index}",
+                index,
+                $"Section {index}",
+                start,
+                start + text.Length,
+                Math.Max(6, text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length),
+                FabricHashing.Sha256(text),
+                text,
+                index > 0 ? $"seg-{index - 1}" : null,
+                index < texts.Length - 1 ? $"seg-{index + 1}" : null,
+                FabricIngestionVersions.Segmenter);
+            start += text.Length + 1;
+            return draft;
+        }).ToArray());
+
+        return new Harness(store, library, graph, corpus, document);
+    }
+
+    private sealed class Harness(
+        SqliteStore store,
+        FabricLibraryRepository library,
+        DocumentGraphRepository graph,
+        FabricCorpusEntry corpus,
+        FabricDocumentEntry document) : IDisposable
+    {
+        public FabricLibraryRepository Library { get; } = library;
+        public DocumentGraphRepository Graph { get; } = graph;
+        public FabricCorpusEntry Corpus { get; } = corpus;
+        public FabricDocumentEntry Document { get; } = document;
+
+        public FabricIndexingOrchestrator NewOrchestrator()
+        {
+            var reader = new FabricNativeReaderService(Library, Graph, new ScriptedFabricRuntime());
+            var reducer = new FabricReducer(Library, Graph, new FabricReducerOptions(FanIn: 2, MaxSummaryChars: 200));
+            return new FabricIndexingOrchestrator(reader, reducer, Library);
+        }
+
+        public void Dispose() => store.Dispose();
+    }
+}
diff --git a/OrchestratorIDE/Services/ContextFabric/DocumentGraphRepository.cs b/OrchestratorIDE/Services/ContextFabric/DocumentGraphRepository.cs
index ebc2dcd7..c2869772 100644
--- a/OrchestratorIDE/Services/ContextFabric/DocumentGraphRepository.cs
+++ b/OrchestratorIDE/Services/ContextFabric/DocumentGraphRepository.cs
@@ -61,6 +61,54 @@ FROM fabric_claims
         });
     }
 
+    /// <summary>
+    /// Replaces only the claims for one segment of a document, leaving every other segment's
+    /// claims untouched -- the scoped counterpart to ReplaceClaimsForDocument, used when
+    /// re-reading a subset of a document's segments (see FabricNativeReaderService.ReadSegmentsAsync)
+    /// so a retry that returns fewer claims than before doesn't leave the old ones orphaned.
+    /// </summary>
+    public void ReplaceClaimsForSegment(
+        string documentId,
+        string segmentId,
+        IReadOnlyList<FabricClaimEntry> claims,
+        IReadOnlyDictionary<string, IReadOnlyList<FabricClaimCitationEntry>> citationsByClaimId)
+    {
+        if (string.IsNullOrWhiteSpace(documentId))
+            throw new ArgumentException("Document id is required.", nameof(documentId));
+        if (string.IsNullOrWhiteSpace(segmentId))
+            throw new ArgumentException("Segment id is required.", nameof(segmentId));
+        ArgumentNullException.ThrowIfNull(claims);
+        ArgumentNullException.ThrowIfNull(citationsByClaimId);
+        if (claims.Any(claim => !string.Equals(claim.DocumentId, documentId, StringComparison.Ordinal) ||
+                                 !string.Equals(claim.SegmentId, segmentId, StringComparison.Ordinal)))
+            throw new InvalidDataException($"Replacement claims must all belong to document '{documentId}' segment '{segmentId}'.");
+
+        InTransaction((conn, tx) =>
+        {
+            ExecuteOn(tx, """
+                DELETE FROM fabric_claim_citations
+                WHERE claim_id IN (
+                    SELECT claim_id
+                    FROM fabric_claims
+                    WHERE document_id = $document AND segment_id = $segment
+                )
+                """,
+                ps => { P(ps, "$document", documentId); P(ps, "$segment", segmentId); });
+            ExecuteOn(tx, "DELETE FROM fabric_claims WHERE document_id = $document AND segment_id = $segment",
+                ps => { P(ps, "$document", documentId); P(ps, "$segment", segmentId); });
+
+            foreach (var claim in claims)
+            {
+                UpsertClaimOn(conn, tx, claim);
+                if (!citationsByClaimId.TryGetValue(claim.ClaimId, out var citations))
+                    continue;
+
+                foreach (var citation in citations.OrderBy(item => item.Ordinal))
+                    InsertCitationOn(conn, tx, claim.ClaimId, citation);
+            }
+        });
+    }
+
     public IReadOnlyList<FabricClaimEntry> ListClaims(string corpusId, string? verificationStatus = null, int limit = 200) => Query(
         """
         SELECT *
diff --git a/OrchestratorIDE/Services/ContextFabric/FabricAskService.cs b/OrchestratorIDE/Services/ContextFabric/FabricAskService.cs
new file mode 100644
index 00000000..19c320a8
--- /dev/null
+++ b/OrchestratorIDE/Services/ContextFabric/FabricAskService.cs
@@ -0,0 +1,190 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// CF-5: OrcChat Library ask service — chains planner -> pack -> native answer -> verifier.
+
+using System.Text;
+using System.Text.Json;
+using OrchestratorIDE.Core.Runtime;
+using OrchestratorIDE.Models;
+
+namespace OrchestratorIDE.Services.ContextFabric;
+
+public sealed record FabricAskResult(
+    string Answer,
+    bool Abstained,
+    string Mode,
+    int SegmentsConsidered,
+    int SegmentsTotal,
+    bool FitsBudget,
+    bool TriggeredSourceReopen,
+    IReadOnlyList<FabricAnswerClaimResult> Claims);
+
+public sealed record FabricAnswerClaimResult(
+    string ClaimText,
+    string VerificationLabel,
+    IReadOnlyList<FabricCitationDetail> Citations);
+
+public sealed record FabricCitationDetail(
+    int Index,
+    string SegmentId,
+    string DocumentId,
+    string HeadingPath,
+    int CharStart,
+    int CharEnd,
+    string Quote,
+    string VerificationLabel);
+
+public sealed class FabricAskService(
+    FabricQueryPlanner queryPlanner,
+    EvidencePackBuilder packBuilder,
+    FabricCitationVerifier citationVerifier,
+    FabricLibraryRepository libraryRepository,
+    IRoleRuntime runtime,
+    FabricRunOptions? options = null)
+{
+    private static readonly FabricRunOptions _defaultOptions = FabricRunOptions.Default;
+    private readonly FabricRunOptions _options = options ?? _defaultOptions;
+
+    private const string AnswerSystemPrompt = """
+        [FABRIC_ASK] You are a source-bound research assistant. Answer ONLY from the provided evidence.
+        Respond with valid JSON matching this schema exactly:
+        {"schemaVersion":"cf0-answer-1.0","answer":"<prose>","abstained":<bool>,"claims":[{"text":"<claim>","citations":[{"segmentId":"<id>","charStart":<n>,"charEnd":<n>,"quote":"<exact substring>","quoteDigest":""}]}]}
+        Rules:
+        - Every non-trivial claim must carry at least one citation with an exact quote from the evidence.
+        - If the evidence does not support the question, set abstained:true and answer:"The provided sources do not contain sufficient evidence to answer this question."
+        - Do not invent facts. Do not use knowledge outside the provided evidence.
+        - quoteDigest is left empty - the host computes it.
+        """;
+
+    public async Task<FabricAskResult> AskAsync(
+        string question,
+        string corpusId,
+        string mode,
+        CancellationToken ct = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(question);
+        ArgumentException.ThrowIfNullOrWhiteSpace(corpusId);
+
+        var plan = queryPlanner.BuildPlan(question, corpusId, mode);
+        var pack = packBuilder.Build(plan);
+
+        var evidenceText = BuildEvidenceText(pack);
+        var userPrompt = $"""
+            Evidence from the corpus:
+
+            {evidenceText}
+
+            ---
+            Question: {question}
+
+            Respond with the JSON answer schema.
+            """;
+
+        var rawAnswer = await GenerateAsync(userPrompt, ct).ConfigureAwait(false);
+        var draft = ParseAnswerDraft(rawAnswer);
+
+        var claimResults = new List<FabricAnswerClaimResult>(draft.Claims.Count);
+        var citIndex = 0;
+        foreach (var claim in draft.Claims)
+        {
+            var verificationResult = citationVerifier.VerifyClaim(
+                claim.Text, claim.Citations, allowRepair: true);
+
+            var citDetails = verificationResult.Items
+                .Select(item => BuildCitationDetail(ref citIndex, item))
+                .ToList();
+
+            claimResults.Add(new FabricAnswerClaimResult(
+                claim.Text,
+                verificationResult.Label,
+                citDetails));
+        }
+
+        var totalSegments = libraryRepository
+            .ListDocuments(corpusId)
+            .Sum(d => libraryRepository.GetSegments(d.DocumentId).Count);
+
+        return new FabricAskResult(
+            draft.Answer,
+            draft.Abstained,
+            plan.Mode,
+            plan.SeedHits.Count + plan.ReopenedSegmentIds.Count,
+            totalSegments,
+            pack.WithinBudget,
+            plan.TriggeredSourceReopen,
+            claimResults);
+    }
+
+    private async Task<string> GenerateAsync(string userPrompt, CancellationToken ct)
+    {
+        var messages = new AgentMessage[]
+        {
+            new() { Role = MessageRole.System, Content = AnswerSystemPrompt },
+            new() { Role = MessageRole.User, Content = userPrompt },
+        };
+
+        var sb = new StringBuilder();
+        await foreach (var token in runtime.StreamRoleCompletionAsync(
+            RuntimeRole.Reviewer,
+            messages,
+            temperature: _options.Temperature,
+            maxTokens: _options.AnswerMaxTokens,
+            ct: ct).ConfigureAwait(false))
+        {
+            sb.Append(token);
+        }
+        return sb.ToString();
+    }
+
+    private static FabricAnswerDraft ParseAnswerDraft(string raw)
+    {
+        var json = raw.Trim();
+        if (json.StartsWith("```", StringComparison.Ordinal))
+        {
+            var start = json.IndexOf('{');
+            var end = json.LastIndexOf('}');
+            if (start >= 0 && end > start)
+                json = json[start..(end + 1)];
+        }
+
+        try
+        {
+            return JsonSerializer.Deserialize<FabricAnswerDraft>(json,
+                new JsonSerializerOptions { PropertyNameCaseInsensitive = true })
+                ?? new FabricAnswerDraft { Abstained = true, Answer = "Could not parse answer." };
+        }
+        catch
+        {
+            return new FabricAnswerDraft
+            {
+                Abstained = true,
+                Answer = "Answer schema parse failed - raw: " + raw[..Math.Min(200, raw.Length)],
+            };
+        }
+    }
+
+    private static string BuildEvidenceText(FabricEvidencePack pack)
+    {
+        var sb = new StringBuilder();
+        foreach (var item in pack.Included)
+        {
+            sb.AppendLine(item.FromSource
+                ? $"[SOURCE {item.Id} | {item.Provenance}]"
+                : $"[SUMMARY {item.Id} | {item.Provenance}]");
+            sb.AppendLine(item.Text);
+            sb.AppendLine();
+        }
+        if (pack.Excluded.Count > 0)
+            sb.AppendLine($"// {pack.Excluded.Count} additional evidence items excluded by token budget.");
+        return sb.ToString();
+    }
+
+    private static FabricCitationDetail BuildCitationDetail(
+        ref int index, FabricCitationVerificationItem item)
+    {
+        index++;
+        return new FabricCitationDetail(
+            index, item.SegmentId, "", "", item.CharStart, item.CharEnd,
+            item.QuoteText, item.Label);
+    }
+}
diff --git a/OrchestratorIDE/Services/ContextFabric/FabricEvidenceGraphImporter.cs b/OrchestratorIDE/Services/ContextFabric/FabricEvidenceGraphImporter.cs
index fb1a58b3..26ba3b89 100644
--- a/OrchestratorIDE/Services/ContextFabric/FabricEvidenceGraphImporter.cs
+++ b/OrchestratorIDE/Services/ContextFabric/FabricEvidenceGraphImporter.cs
@@ -20,6 +20,35 @@ public int ImportEvidenceCard(
         return imports.Count;
     }
 
+    /// <summary>
+    /// Replaces one segment's claims with the given card's claims, leaving every other
+    /// segment's claims in the document untouched -- unlike ImportEvidenceCard (which only
+    /// upserts what's in the card and never removes a claim that dropped out between reads)
+    /// or ReplaceDocumentEvidenceCards (which wipes the whole document). Used for scoped
+    /// re-reads (see FabricNativeReaderService.ReadSegmentsAsync) so a retry that returns
+    /// fewer claims than the previous read doesn't leave the old ones orphaned in the graph.
+    /// </summary>
+    public int ReplaceSegmentEvidenceCard(
+        FabricEvidenceCard card,
+        string verificationStatus = FabricVerificationStatus.Provisional)
+    {
+        ArgumentNullException.ThrowIfNull(card);
+        var imports = BuildClaimImports(card, verificationStatus);
+
+        graphRepository.ReplaceClaimsForSegment(
+            card.DocumentId,
+            card.SegmentId,
+            imports.Select(item => item.Claim).ToArray(),
+            imports.ToDictionary(
+                item => item.Claim.ClaimId,
+                item => (IReadOnlyList<FabricClaimCitationEntry>)item.Citations,
+                StringComparer.Ordinal));
+
+        if (imports.Count > 0)
+            UpsertEntities(imports[0].Document, verificationStatus, imports[0].Card.Entities);
+        return imports.Count;
+    }
+
     public int ReplaceDocumentEvidenceCards(
         string documentId,
         IEnumerable<FabricEvidenceCard> cards,
diff --git a/OrchestratorIDE/Services/ContextFabric/FabricIndexingOrchestrator.cs b/OrchestratorIDE/Services/ContextFabric/FabricIndexingOrchestrator.cs
new file mode 100644
index 00000000..eb7488e6
--- /dev/null
+++ b/OrchestratorIDE/Services/ContextFabric/FabricIndexingOrchestrator.cs
@@ -0,0 +1,136 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// CF-5: wraps the native read pipeline + best-effort reduce, with staged IProgress<> events.
+
+namespace OrchestratorIDE.Services.ContextFabric;
+
+public enum IndexStageKind { Parsing, Reading, Reducing, Complete, Failed }
+
+public sealed record IndexStageEvent(
+    string DocumentId,
+    IndexStageKind Stage,
+    int CompletedSegments,
+    int TotalSegments,
+    IReadOnlyList<string> FailedSegmentIds,
+    string? Error = null);
+
+public sealed class FabricIndexingOrchestrator(
+    FabricNativeReaderService readerService,
+    FabricReducer reducer,
+    FabricLibraryRepository libraryRepository)
+{
+    public async Task<IndexStageEvent> IndexDocumentAsync(
+        string documentId,
+        bool readOnly,
+        IProgress<IndexStageEvent>? progress = null,
+        CancellationToken ct = default)
+    {
+        var segments = libraryRepository.GetSegments(documentId);
+        var total = segments.Count;
+        if (total == 0)
+            return Fail(documentId, total, "Document has no segments. Re-import the source file.");
+
+        progress?.Report(new IndexStageEvent(documentId, IndexStageKind.Reading, 0, total, []));
+
+        FabricDocumentReadResult readResult;
+        try
+        {
+            readResult = await readerService.ReadDocumentAsync(documentId, ct).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) { throw; }
+        catch (Exception ex)
+        {
+            return Fail(documentId, total, ex.Message);
+        }
+
+        var failedIds = readResult.ReadReport.SegmentResults
+            .Where(r => !r.Accepted)
+            .Select(r => r.SegmentId)
+            .ToList();
+
+        var completed = total - failedIds.Count;
+
+        if (readOnly)
+        {
+            var doneEvent = new IndexStageEvent(documentId, IndexStageKind.Complete, completed, total, failedIds);
+            progress?.Report(doneEvent);
+            return doneEvent;
+        }
+
+        progress?.Report(new IndexStageEvent(documentId, IndexStageKind.Reducing, completed, total, failedIds));
+
+        try
+        {
+            reducer.ReduceDocument(documentId);
+        }
+        catch (OperationCanceledException) { throw; }
+        catch
+        {
+            // Reduce failure is non-fatal — Quick mode still works on segments + claims.
+            // Study mode falls back to segment reopening (planner handles it).
+        }
+
+        var ev = new IndexStageEvent(documentId, IndexStageKind.Complete, completed, total, failedIds);
+        progress?.Report(ev);
+        return ev;
+    }
+
+    public async Task<IndexStageEvent> RetryFailedAsync(
+        string documentId,
+        IReadOnlyList<string> failedSegmentIds,
+        bool readOnly,
+        IProgress<IndexStageEvent>? progress = null,
+        CancellationToken ct = default)
+    {
+        ArgumentNullException.ThrowIfNull(failedSegmentIds);
+        var total = libraryRepository.GetSegments(documentId).Count;
+        if (failedSegmentIds.Count == 0)
+            return await IndexDocumentAsync(documentId, readOnly, progress, ct).ConfigureAwait(false);
+
+        progress?.Report(new IndexStageEvent(documentId, IndexStageKind.Reading, 0, failedSegmentIds.Count, []));
+
+        FabricCorpusReadReport retryReport;
+        try
+        {
+            retryReport = await readerService.ReadSegmentsAsync(documentId, failedSegmentIds, ct)
+                .ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) { throw; }
+        catch (Exception ex)
+        {
+            return Fail(documentId, total, ex.Message);
+        }
+
+        var stillFailedIds = retryReport.SegmentResults
+            .Where(r => !r.Accepted)
+            .Select(r => r.SegmentId)
+            .ToList();
+        var completed = total - stillFailedIds.Count;
+
+        if (readOnly)
+        {
+            var doneEvent = new IndexStageEvent(documentId, IndexStageKind.Complete, completed, total, stillFailedIds);
+            progress?.Report(doneEvent);
+            return doneEvent;
+        }
+
+        progress?.Report(new IndexStageEvent(documentId, IndexStageKind.Reducing, completed, total, stillFailedIds));
+
+        try
+        {
+            reducer.ReduceDocument(documentId);
+        }
+        catch (OperationCanceledException) { throw; }
+        catch
+        {
+            // Non-fatal — see IndexDocumentAsync.
+        }
+
+        var ev = new IndexStageEvent(documentId, IndexStageKind.Complete, completed, total, stillFailedIds);
+        progress?.Report(ev);
+        return ev;
+    }
+
+    private static IndexStageEvent Fail(string documentId, int total, string error) =>
+        new(documentId, IndexStageKind.Failed, 0, total, [], error);
+}
diff --git a/OrchestratorIDE/Services/ContextFabric/FabricNativeReaderService.cs b/OrchestratorIDE/Services/ContextFabric/FabricNativeReaderService.cs
index c005203f..1d528a84 100644
--- a/OrchestratorIDE/Services/ContextFabric/FabricNativeReaderService.cs
+++ b/OrchestratorIDE/Services/ContextFabric/FabricNativeReaderService.cs
@@ -50,6 +50,41 @@ public async Task<FabricDocumentReadResult> ReadDocumentAsync(
         return new FabricDocumentReadResult(document, readReport, importedClaims);
     }
 
+    /// <summary>
+    /// Re-reads only the given segments and replaces each one's claims without touching
+    /// claims already imported for the rest of the document (unlike ReadDocumentAsync, which
+    /// replaces the full document's claim set). Replacing per-segment rather than upserting
+    /// means a retry that returns fewer claims than the previous read for the same segment
+    /// doesn't leave the dropped-out claims orphaned in the graph.
+    /// </summary>
+    public async Task<FabricCorpusReadReport> ReadSegmentsAsync(
+        string documentId,
+        IReadOnlyList<string> segmentIds,
+        CancellationToken ct = default)
+    {
+        ArgumentNullException.ThrowIfNull(segmentIds);
+        var document = _libraryRepository.GetDocument(documentId)
+            ?? throw new KeyNotFoundException($"Context Fabric document '{documentId}' does not exist.");
+        var requested = segmentIds.ToHashSet(StringComparer.Ordinal);
+        var scopedSegments = _libraryRepository.GetSegments(documentId)
+            .Where(segment => requested.Contains(segment.SegmentId))
+            .ToArray();
+        if (scopedSegments.Length == 0)
+            throw new InvalidDataException($"None of the requested segment ids belong to document '{documentId}'.");
+
+        var corpus = BuildCorpus(document, scopedSegments);
+        var readReport = await _runner.ReadCorpusAsync(corpus, ct).ConfigureAwait(false);
+
+        foreach (var card in readReport.SegmentResults
+                     .Where(item => item.Accepted && item.Card is not null)
+                     .Select(item => item.Card!))
+        {
+            _graphImporter.ReplaceSegmentEvidenceCard(card);
+        }
+
+        return readReport;
+    }
+
     internal static FabricCorpus BuildCorpus(
         FabricDocumentEntry document,
         IReadOnlyList<FabricSegmentEntry> segments)
diff --git a/OrchestratorIDE/Services/ContextFabric/FabricWebImporter.cs b/OrchestratorIDE/Services/ContextFabric/FabricWebImporter.cs
new file mode 100644
index 00000000..c917a538
--- /dev/null
+++ b/OrchestratorIDE/Services/ContextFabric/FabricWebImporter.cs
@@ -0,0 +1,131 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// CF-5: web-find import — search, candidate selection, download, import.
+// POLICY: only call DownloadAndImportAsync for URLs the user explicitly selects.
+//         Display the license/attribution note before downloading.
+//         Never auto-download without user confirmation.
+
+using OrchestratorIDE.Research;
+
+namespace OrchestratorIDE.Services.ContextFabric;
+
+public sealed record WebImportCandidate(
+    string Url,
+    string Title,
+    string Format,       // "pdf" | "txt" | "md"
+    long EstimatedBytes,
+    string Attribution);
+
+public sealed record WebImportResult(
+    FabricImportResult ImportResult,
+    string SourceUrl,
+    string DownloadedDigest);
+
+public sealed class FabricWebImporter(
+    FabricLibraryService libraryService,
+    HttpClient httpClient,
+    WebSearchTool? webSearch = null)
+{
+    // Max download size: 50 MB. Mirrors FabricLibraryOptions.MaximumSourceBytes default.
+    private const long MaxDownloadBytes = 50 * 1024 * 1024;
+    private const int MaxSearchResults = 12;
+
+    private readonly WebSearchTool _webSearch = webSearch ?? new WebSearchTool();
+
+    // The current parser registry only handles .txt/.md/.pdf (no EPUB/DOCX/OCR — out of
+    // scope for this slice), so candidates whose URL doesn't resolve to one of those
+    // extensions are filtered out rather than offered as a dead-end "Add to library".
+    public async Task<IReadOnlyList<WebImportCandidate>> SearchAsync(
+        string query,
+        CancellationToken ct = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(query);
+
+        var hits = await _webSearch.SearchAsync(query, MaxSearchResults, ct).ConfigureAwait(false);
+
+        var candidates = new List<WebImportCandidate>();
+        foreach (var hit in hits)
+        {
+            if (string.IsNullOrWhiteSpace(hit.Url))
+                continue;
+
+            var format = InferSupportedFormat(hit.Url);
+            if (format is null)
+                continue;
+
+            candidates.Add(new WebImportCandidate(
+                hit.Url,
+                string.IsNullOrWhiteSpace(hit.Title) ? hit.Url : hit.Title,
+                format,
+                EstimatedBytes: 0,
+                Attribution: InferAttribution(hit.Url)));
+        }
+
+        return candidates;
+    }
+
+    public async Task<WebImportResult> DownloadAndImportAsync(
+        string corpusId,
+        WebImportCandidate candidate,
+        CancellationToken ct = default)
+    {
+        using var response = await httpClient.GetAsync(
+            candidate.Url, HttpCompletionOption.ResponseHeadersRead, ct).ConfigureAwait(false);
+        response.EnsureSuccessStatusCode();
+
+        var contentLength = response.Content.Headers.ContentLength ?? 0;
+        if (contentLength > MaxDownloadBytes)
+            throw new InvalidDataException($"Remote file exceeds {MaxDownloadBytes / 1024 / 1024} MB limit.");
+
+        using var stream = await response.Content.ReadAsStreamAsync(ct).ConfigureAwait(false);
+        var memStream = new MemoryStream();
+        var buf = new byte[65536];
+        long total = 0;
+        int read;
+        while ((read = await stream.ReadAsync(buf, ct).ConfigureAwait(false)) > 0)
+        {
+            total += read;
+            if (total > MaxDownloadBytes)
+                throw new InvalidDataException("Download exceeded size limit mid-stream.");
+            memStream.Write(buf, 0, read);
+        }
+
+        var ext = candidate.Format switch { "pdf" => ".pdf", "md" => ".md", _ => ".txt" };
+        var tmpPath = Path.Combine(Path.GetTempPath(), $"orc-webimport-{Guid.NewGuid():N}{ext}");
+        try
+        {
+            await File.WriteAllBytesAsync(tmpPath, memStream.ToArray(), ct).ConfigureAwait(false);
+            var importResult = await libraryService.ImportFileAsync(corpusId, tmpPath, ct: ct).ConfigureAwait(false);
+            var digest = importResult.Document.SourceDigest;
+            return new WebImportResult(importResult, candidate.Url, digest);
+        }
+        finally
+        {
+            if (File.Exists(tmpPath)) File.Delete(tmpPath);
+        }
+    }
+
+    private static string? InferSupportedFormat(string url)
+    {
+        var path = url.Split('?', '#')[0];
+        if (path.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase)) return "pdf";
+        if (path.EndsWith(".md", StringComparison.OrdinalIgnoreCase)) return "md";
+        if (path.EndsWith(".txt", StringComparison.OrdinalIgnoreCase)) return "txt";
+        return null;
+    }
+
+    private static string InferAttribution(string url)
+    {
+        try
+        {
+            var host = new Uri(url).Host;
+            return host.Contains("gutenberg", StringComparison.OrdinalIgnoreCase)
+                ? "Project Gutenberg · Public Domain"
+                : host;
+        }
+        catch
+        {
+            return "Unknown source";
+        }
+    }
+}
diff --git a/OrchestratorIDE/Services/ConversationNotebookStore.cs b/OrchestratorIDE/Services/ConversationNotebookStore.cs
new file mode 100644
index 00000000..16a1a8b0
--- /dev/null
+++ b/OrchestratorIDE/Services/ConversationNotebookStore.cs
@@ -0,0 +1,50 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// CF-5: per-conversation cited-conclusion store. Mirrors OpenChatMemory pattern.
+
+using System.Text.Json;
+using OrchestratorIDE.UI.ViewModels;
+
+namespace OrchestratorIDE.Services;
+
+public sealed record ConversationNotebookEntry(
+    string ClaimText,
+    IReadOnlyList<CitationViewModel> Citations,
+    DateTimeOffset CreatedAt,
+    string QueryRunId);
+
+public static class ConversationNotebookStore
+{
+    private static readonly JsonSerializerOptions _json =
+        new() { WriteIndented = true, PropertyNameCaseInsensitive = true };
+
+    public static string StorePath(string workspaceRoot, string conversationId) =>
+        Path.Combine(workspaceRoot, ".orc", "chat", $"notebook-{conversationId}.json");
+
+    public static IReadOnlyList<ConversationNotebookEntry> Load(string path)
+    {
+        if (!File.Exists(path)) return [];
+        try
+        {
+            var json = File.ReadAllText(path);
+            return JsonSerializer.Deserialize<List<ConversationNotebookEntry>>(json, _json) ?? [];
+        }
+        catch
+        {
+            return [];
+        }
+    }
+
+    public static void Append(string path, ConversationNotebookEntry entry)
+    {
+        var entries = Load(path).ToList();
+        entries.Add(entry);
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        File.WriteAllText(path, JsonSerializer.Serialize(entries, _json));
+    }
+
+    public static void Clear(string path)
+    {
+        if (File.Exists(path)) File.Delete(path);
+    }
+}
diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md
index ffb513fe..9fcca762 100644
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@@ -440,7 +440,7 @@ Commit `22db2ccf` landed the shared headless native loop, `native_agent` and `co
 
 This is not yet a finished Phase 3B product. The remaining release gates are dependency-aware campaign stages, native-agent input-artifact materialization, hostile-input hardening, complete campaign-control UX, and the planned multi-node acceptance run with worker loss, re-lease, stale-result rejection, pause/resume/cancel, artifact verification, and measured speedup.
 
-### The Orc Context Fabric — effectively unbounded source memory (CF-0 PASSED; CF-1 READY)
+### The Orc Context Fabric — effectively unbounded source memory (CF-0 through CF-4 passed in focused tests; CF-5 framework done, real-model exit gate pending)
 
 Full design: [The Orc Context Fabric.md](The%20Orc%20Context%20Fabric.md).
 
@@ -453,9 +453,9 @@ Delivery order:
 1. CF-0 contracts, evidence schema, deterministic corpus, and 16-segment native feasibility spike. **Passed:** the scripted lane remains green; the pinned Hermes 3 Llama 3.1 8B native lane passed 16/16 segment cards, 5/5 questions, 100% citation precision, all nine gates, and an 11.50x source-to-working-context ratio inside the 8K limit. A second verified native lane now passes on Gemma 4 12B through the runtime's `GemmaNativeFallback` prompt path with 16/16 segment cards, 5/5 questions, 100% citation precision, and an 11.48x ratio. Quote anchoring and the 2/2 native boundary-stitch lane also pass.
 2. CF-1 deterministic ingestion, structural segmentation, and content-addressed source storage. **Passed in focused tests:** migrations v8-v9, strict UTF-8 text/Markdown parsing, stable structural segmentation, SHA-256 source/normalized storage, transactional repository replacement, FTS5 search, rebuild/delete paths, Darwin text/PDF reproducibility, pinned Constitution and Federalist fixtures, artifact GC, and focused failure tests are implemented. Product-surface work remains follow-on rather than a CF-1 blocker.
 3. CF-2 document graph, SQLite migrations, FTS, source tools, and local retrieval. **Passed in focused tests:** migration v10, `DocumentGraphRepository`, `FabricEvidenceGraphImporter`, claim FTS, provenance-carrying `FabricSearchService`, and read-only library graph/search/open/list tools are implemented, with in-memory and on-disk repository tests plus unchanged CodeGraph tests.
-4. CF-3 native readers, boundary stitching, schema validation, and source verification.
-5. CF-4 hierarchical reducers, context budgeting, source rehydration, Quick and Study modes.
-6. CF-5 OrcChat Library, corpus attachment, citations, coverage, and persistent cited notebook.
+4. CF-3 native readers, boundary stitching, schema validation, and source verification. **Framework exit gate passed in focused no-fallback tests.**
+5. CF-4 hierarchical reducers, context budgeting, source rehydration, Quick and Study modes. **Framework exit gate passed in focused tests.**
+6. CF-5 OrcChat Library, corpus attachment, citations, coverage, and persistent cited notebook. **Framework/integration exit passed in focused headless/scripted-runtime tests (351 unit + 73 headless, all green); the real native-model end-to-end exit gate (index the real Darwin PDF, ask a cited cross-chapter question) has not yet been run.**
 7. CF-6 HIVE stage dependencies, native input staging, distributed readers/reducers/verifiers.
 8. CF-7 Exhaustive mode and frozen B0-B4 benchmark gate.
 9. CF-8 multimodal documents, optional vector acceleration, and cross-CodeGraph links.
diff --git a/docs/The Orc Context Fabric.md b/docs/The Orc Context Fabric.md
index 7b9751a3..b68321da 100644
--- a/docs/The Orc Context Fabric.md	
+++ b/docs/The Orc Context Fabric.md	
@@ -1357,6 +1357,15 @@ Exit gate:
 
 - a user can add Darwin, wait for indexing, start a fresh chat, and ask cited cross-chapter questions without manually managing context.
 
+Implementation status (2026-06-29): **framework exit passed in focused headless/scripted-runtime tests; real native-model end-to-end exit gate still pending**.
+
+- `FabricAskService` chains `FabricQueryPlanner` → `EvidencePackBuilder` → native answer generation (via `IRoleRuntime`, Reviewer role) → `FabricCitationVerifier`, mirroring `ContextFabricFeasibilityRunner`'s existing invocation pattern.
+- `FabricIndexingOrchestrator` drives read-then-reduce indexing with staged `IProgress<>` events, plus a scoped retry path: `FabricNativeReaderService.ReadSegmentsAsync` re-reads only the requested segments, and `FabricEvidenceGraphImporter.ReplaceSegmentEvidenceCard` / `DocumentGraphRepository.ReplaceClaimsForSegment` replace only that segment's claims so a retry returning fewer claims than before doesn't leave the dropped ones orphaned in the graph.
+- `FabricWebImporter` resolves web-find search directly through the existing `WebSearchTool` (no model round-trip needed for a deterministic search), filtered to the formats the parser registry actually supports (pdf/txt/md), and downloads behind an explicit user-confirmed "Add to library" action with a 50MB cap.
+- Two new Avalonia controls (`LibraryDrawerControl`, `SourcePreviewPanel`) and targeted `ChatPanel` edits deliver the library drawer, corpus attach/detach, Quick/Study mode toggle, cited-answer bubbles with coverage/verification lines, citation footnotes, and the source-preview rail — all code-behind-only, matching the existing no-MVVM convention. `BeginIndexing`/`BeginRetry` guard against re-entrant indexing of the same document, and a "Repair" affordance on partially-failed documents calls the scoped retry instead of forcing a full re-read.
+- `ConversationNotebookStore` persists cited conclusions per conversation as JSON, loaded into the drawer's notebook section on `SetFabricServices`.
+- This status is intentionally narrower than a real-model benchmark claim, same framing as CF-3/CF-4: it closes the framework/integration gate in code and tests (351 unit + 73 headless tests green, full solution builds clean), behind the existing `ExperimentalNativeMainChatEnabled` opt-in (off by default). The literal exit-gate scenario — add the real Darwin PDF, index it with a loaded native model, and get a cited cross-chapter answer — has not yet been run and remains the actual acceptance step before this phase is declared done.
+
 ### Phase CF-6: HIVE stage engine and distributed readers
 
 Deliver:
diff --git a/docs/research/design_handoff_cf5_orcchat_library/CLAUDE_CODE_PROMPT.md b/docs/research/design_handoff_cf5_orcchat_library/CLAUDE_CODE_PROMPT.md
new file mode 100644
index 00000000..9579841f
--- /dev/null
+++ b/docs/research/design_handoff_cf5_orcchat_library/CLAUDE_CODE_PROMPT.md
@@ -0,0 +1,68 @@
+# CF-5 OrcChat Library — Implementation Prompt for Claude Code
+
+Paste this prompt into Claude Code (desktop or CLI) from the root of the TheOrc repo.
+The design_handoff_cf5_orcchat_library/ folder contains all supporting files.
+
+---
+
+You are implementing CF-5 for the TheOrc repo (hardcoreerik/TheOrc, branch master, HEAD d7a6af70c67d).
+Read design_handoff_cf5_orcchat_library/README.md fully before writing any code.
+
+## Your task
+
+Implement the CF-5 OrcChat Library experience as a **single PR** on branch `feat/cf5-orcchat-library`.
+
+1. Drop the stub files from design_handoff_cf5_orcchat_library/src/ into their target locations:
+   - FabricAskService.cs → OrchestratorIDE/Services/ContextFabric/
+   - FabricIndexingOrchestrator.cs → OrchestratorIDE/Services/ContextFabric/
+   - FabricWebImporter.cs → OrchestratorIDE/Services/ContextFabric/
+   - ViewModels/*.cs → OrchestratorIDE.Avalonia/UI/ViewModels/
+   - ConversationNotebookStore.cs → OrchestratorIDE/Services/
+
+2. Fill in the stub TODOs. Key ones:
+   - FabricAskService.GenerateAsync: check how ContextFabricFeasibilityRunner generates answers internally and follow the same IRoleRuntime streaming pattern.
+   - FabricWebImporter.SearchAsync: implement via a one-shot ChatEngine call using the existing web_search tool (OrcChatToolCatalog). Return WebImportCandidate list.
+   - LibraryViewModel.CorpusCardViewModel.TotalSegments: sum from FabricLibraryRepository.GetSegments per document.
+   - FabricIndexingOrchestrator.RetryFailedAsync: add ReadSegmentsAsync overload to FabricNativeReaderService, or call ReadDocumentAsync and filter results.
+
+3. Apply ChatPanel_CF5_changes.md — targeted edits only. Do NOT rewrite ChatPanel.axaml.cs.
+
+4. Create the two new Avalonia UserControls:
+   - OrchestratorIDE.Avalonia/UI/Controls/LibraryDrawerControl.axaml(.cs)
+   - OrchestratorIDE.Avalonia/UI/Controls/SourcePreviewPanel.axaml(.cs)
+   Follow the design spec in README.md exactly (colors, layout, fonts). Use the design token values listed there. Follow the existing code-behind-only pattern (no MVVM framework — look at HiveConstellationView.cs and ChatPanel.axaml.cs for style).
+
+5. Wire services in MainWindow.axaml.cs per the instructions in ChatPanel_CF5_changes.md § 8.
+
+6. Write tests:
+   OrchestratorIDE.UnitTests/:
+   - ContextFabricAskServiceTests.cs (use ContextFabricScriptedRuntime from existing test infra)
+   - ContextFabricIndexingOrchestratorTests.cs
+   OrchestratorIDE.Avalonia.HeadlessTests/:
+   - OrcChatLibraryTests.cs (follow TestAppBuilder + ChatPanelModeToggleTests.cs pattern)
+   - OrcChatCitationNavigationTests.cs
+   - OrcChatContextFabricQueryTests.cs
+
+7. STOP conditions — do NOT do any of these:
+   - Add Exhaustive mode or lift FabricQueryPlanner's mode restriction
+   - Add new SQLite migrations (the CF-1..CF-4 schema is already in place)
+   - Add new parser formats (EPUB, DOCX, OCR)
+   - Add library_* model tools to OrcChatToolCatalog
+   - Touch the HIVE campaign engine
+   - Rewrite ChatPanel from scratch
+
+## Key existing files to read first
+- OrchestratorIDE/Services/ContextFabric/FabricLibraryService.cs
+- OrchestratorIDE/Services/ContextFabric/FabricQueryPlanner.cs
+- OrchestratorIDE/Services/ContextFabric/EvidencePackBuilder.cs
+- OrchestratorIDE/Services/ContextFabric/FabricCitationVerifier.cs
+- OrchestratorIDE/Services/ContextFabric/FabricNativeReaderService.cs
+- OrchestratorIDE/Services/ContextFabric/ContextFabricContracts.cs
+- OrchestratorIDE.Avalonia/UI/Panels/ChatPanel.axaml.cs
+- OrchestratorIDE.UnitTests/ContextFabricScriptedRuntime.cs
+
+## One-PR definition
+Branch: feat/cf5-orcchat-library
+Exit gate: user can add darwin-origin-species-primary.pdf, wait for indexing,
+start a fresh chat, attach the corpus, ask a cross-chapter question,
+and receive a cited, verified answer — with no manual context management.
diff --git a/docs/research/design_handoff_cf5_orcchat_library/ChatPanel_CF5_changes.md b/docs/research/design_handoff_cf5_orcchat_library/ChatPanel_CF5_changes.md
new file mode 100644
index 00000000..3a2fde6b
--- /dev/null
+++ b/docs/research/design_handoff_cf5_orcchat_library/ChatPanel_CF5_changes.md
@@ -0,0 +1,226 @@
+# ChatPanel.axaml.cs — CF-5 Edit Instructions
+
+> File: OrchestratorIDE.Avalonia/UI/Panels/ChatPanel.axaml.cs (currently 48 KB)
+> Do NOT rewrite the whole file. Make these targeted additions only.
+
+## 1. New private fields (add to the "State" region)
+
+```csharp
+// ── CF-5 Library state ────────────────────────────────────────────────────
+private CorpusAttachmentState? _corpus;   // null = plain chat; non-null = source-bound
+private LibraryViewModel?      _libraryVm;
+private FabricAskService?      _askService;
+private FabricIndexingOrchestrator? _indexingOrchestrator;
+private string _notebookPath = "";
+```
+
+## 2. New public setters (add to "Public API" region)
+
+```csharp
+// Called by MainWindow after constructing the panel, same lifecycle as SetModels().
+public void SetFabricServices(
+    FabricAskService askService,
+    FabricIndexingOrchestrator indexingOrchestrator,
+    LibraryViewModel libraryVm,
+    string workspaceRoot)
+{
+    _askService            = askService;
+    _indexingOrchestrator  = indexingOrchestrator;
+    _libraryVm             = libraryVm;
+    _notebookPath          = ConversationNotebookStore.StorePath(workspaceRoot, "default");
+    // Wire library view model to the drawer controls (see AXAML section below)
+    RefreshLibraryDrawer();
+}
+```
+
+## 3. Modify SendAsync — corpus routing branch
+
+Add this branch at the top of SendAsync, BEFORE the engine.SendAsync call:
+
+```csharp
+// ── CF-5: route through FabricAskService when a corpus is attached ───────
+if (_corpus is not null && _askService is not null)
+{
+    await SendFabricAsync(_corpus, text, cts.Token);
+    return; // skip plain ChatEngine path
+}
+```
+
+## 4. New method: SendFabricAsync
+
+Add after SendAsync:
+
+```csharp
+private async Task SendFabricAsync(
+    CorpusAttachmentState corpus,
+    string question,
+    CancellationToken ct)
+{
+    if (_askService is null) return;
+
+    try
+    {
+        var result = await _askService.AskAsync(question, corpus.CorpusId, corpus.Mode, ct)
+            .ConfigureAwait(false);
+
+        await Dispatcher.UIThread.InvokeAsync(() =>
+        {
+            if (_streamBox is null) return;
+
+            // Build the cited answer bubble (replaces the streaming textbox)
+            var bubble = _streamBox.Parent as Border;
+            _streamBox = null;
+            if (bubble is null) return;
+
+            bubble.Child = BuildCitedAnswerView(result, corpus);
+            bubble.Tag   = result.Answer;
+        });
+    }
+    catch (OperationCanceledException) { /* user cancelled */ }
+    catch (Exception ex)
+    {
+        await Dispatcher.UIThread.InvokeAsync(() =>
+        {
+            if (_streamBox is not null)
+                _streamBox.Text = $"⚠ Library ask failed: {ex.Message}";
+        });
+    }
+}
+```
+
+## 5. New method: BuildCitedAnswerView
+
+This builds the rich cited answer control. Returns a StackPanel containing:
+- Stale/incomplete banner (if applicable)
+- Medical policy banner (if policyProfile != "default")
+- Answer prose with inline citation superscripts (use MarkdownView with citation chips)
+- Coverage + verification line
+- Citation footnote rows
+
+```csharp
+private Control BuildCitedAnswerView(FabricAskResult result, CorpusAttachmentState corpus)
+{
+    var stack = new StackPanel { Spacing = 0 };
+
+    // Stale / incomplete banner
+    if (corpus.IsStale || result.SegmentsConsidered < result.SegmentsTotal * 0.5)
+    {
+        stack.Children.Add(new Border
+        {
+            Background = new SolidColorBrush(Color.FromRgb(0x22, 0x1B, 0x0C)),
+            BorderBrush = new SolidColorBrush(Color.FromRgb(0x4A, 0x3C, 0x18)),
+            BorderThickness = new Thickness(0, 0, 0, 1),
+            Padding = new Thickness(12, 6),
+            Child = new TextBlock
+            {
+                Text = $"⚠ Index incomplete — answers may miss sections. Coverage: {result.SegmentsConsidered}/{result.SegmentsTotal} segments.",
+                Foreground = new SolidColorBrush(Color.FromRgb(0xD6, 0xA8, 0x5A)),
+                FontSize = 11, TextWrapping = TextWrapping.Wrap
+            }
+        });
+    }
+
+    // Medical policy banner
+    if (!string.Equals(corpus.PolicyProfile, "default", StringComparison.OrdinalIgnoreCase))
+    {
+        stack.Children.Add(new Border
+        {
+            Background = new SolidColorBrush(Color.FromRgb(0x10, 0x16, 0x1C)),
+            BorderBrush = new SolidColorBrush(Color.FromRgb(0x2A, 0x42, 0x56)),
+            BorderThickness = new Thickness(0, 0, 0, 1),
+            Padding = new Thickness(12, 6),
+            Child = new TextBlock
+            {
+                Text = "Educational interpretation of the cited source — not professional advice.",
+                Foreground = new SolidColorBrush(Color.FromRgb(0xA8, 0xC4, 0xD8)),
+                FontSize = 11, TextWrapping = TextWrapping.Wrap
+            }
+        });
+    }
+
+    // Budget overflow notice
+    if (!result.FitsBudget)
+    {
+        stack.Children.Add(new Border
+        {
+            Padding = new Thickness(12, 5),
+            Child = new TextBlock
+            {
+                Text = "Evidence truncated by token budget — ask a narrower question or switch to Study.",
+                Foreground = new SolidColorBrush(Color.FromRgb(0xD6, 0xA8, 0x5A)),
+                FontSize = 11, TextWrapping = TextWrapping.Wrap
+            }
+        });
+    }
+
+    // Answer prose  
+    stack.Children.Add(new Padding(12, 10) { Child = new MarkdownView
+    {
+        Text = result.Answer,
+        LinkClicked = OpenChatLink
+    }});
+
+    // Coverage + verification line (see design tokens for exact colors)
+    stack.Children.Add(BuildCoverageLine(result));
+
+    // Citation footnotes
+    var citIndices = new List<CitationViewModel>();
+    foreach (var claim in result.Claims)
+        foreach (var cit in BuildCitationViewModels(claim))
+            citIndices.Add(cit);
+
+    foreach (var cit in citIndices.DistinctBy(c => c.Index))
+        stack.Children.Add(BuildFootnoteRow(cit));
+
+    return stack;
+}
+```
+
+## 6. Citation click → source preview pane
+
+When a citation footnote row is clicked, open the source preview pane:
+
+```csharp
+private void OpenSourcePreview(CitationViewModel cit)
+{
+    // Show the right-side source preview panel (add SourcePreviewPanel to ChatPanel layout)
+    SourcePreviewPanel.IsVisible = true;
+    SourcePreviewPanel.LoadCitation(cit, _libraryVm);
+}
+```
+
+## 7. AXAML changes (ChatPanel.axaml)
+
+Add inside the main Grid/DockPanel, before the existing chat area:
+- A 312 px left `Grid.Column` for the library drawer (contains LibraryDrawerControl)
+- A GridSplitter (3 px)  
+- A 372 px right column for SourcePreviewPanel (Visibility=Collapsed by default)
+
+Create two new UserControls:
+- `UI/Controls/LibraryDrawerControl.axaml(.cs)`
+- `UI/Controls/SourcePreviewPanel.axaml(.cs)`
+
+Follow the same code-behind-only (no MVVM framework) style as existing controls.
+
+## 8. MainWindow.axaml.cs — wire services
+
+In the region where ChatPanel is constructed and SetModels is called, add:
+
+```csharp
+var fabricRepo     = new FabricLibraryRepository(sqliteStore);
+var graphRepo      = new DocumentGraphRepository(sqliteStore);
+var fabricArtifacts = new ContentAddressedStore(Path.Combine(workspaceRoot, ".orc", "fabric", "objects"));
+var libraryService = new FabricLibraryService(fabricRepo, fabricArtifacts);
+var searchService  = new FabricSearchService(fabricRepo, graphRepo);
+var planner        = new FabricQueryPlanner(searchService, graphRepo);
+var packBuilder    = new EvidencePackBuilder(fabricRepo, graphRepo);
+var verifier       = new FabricCitationVerifier(fabricRepo);
+var nativeReader   = new FabricNativeReaderService(fabricRepo, graphRepo, nativeRoleRuntime);
+var reducer        = new FabricReducer(/* see existing FabricReducer constructor */);
+var graphImporter  = new FabricEvidenceGraphImporter(fabricRepo, graphRepo);
+var askService     = new FabricAskService(planner, packBuilder, verifier, fabricRepo, nativeRoleRuntime);
+var orchestrator   = new FabricIndexingOrchestrator(libraryService, nativeReader, reducer, graphImporter, fabricRepo, graphRepo);
+var libraryVm      = new LibraryViewModel(libraryService, Path.Combine(workspaceRoot, ".orc", "fabric"));
+
+ChatPanelInstance.SetFabricServices(askService, orchestrator, libraryVm, workspaceRoot);
+```
diff --git a/docs/research/design_handoff_cf5_orcchat_library/OrcChat Library.dc.html b/docs/research/design_handoff_cf5_orcchat_library/OrcChat Library.dc.html
new file mode 100644
index 00000000..71e9ce6d
--- /dev/null
+++ b/docs/research/design_handoff_cf5_orcchat_library/OrcChat Library.dc.html	
@@ -0,0 +1,413 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<script src="./support.js"></script>
+</head>
+<body>
+<x-dc>
+<helmet>
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet">
+<style>
+  *{box-sizing:border-box;}
+  html,body{margin:0;padding:0;background:#070A07;}
+  ::-webkit-scrollbar{width:9px;height:9px;}
+  ::-webkit-scrollbar-thumb{background:#1E2E1E;border-radius:6px;}
+  ::-webkit-scrollbar-track{background:transparent;}
+  @keyframes orcShimmer{0%{transform:translateX(-100%);}100%{transform:translateX(280%);}}
+  @keyframes orcBlink{0%,49%{opacity:1;}50%,100%{opacity:0;}}
+  @keyframes orcPulse{0%,100%{opacity:.55;}50%{opacity:1;}}
+</style>
+</helmet>
+
+<div data-screen-label="OrcChat Library" style="width:1440px;height:920px;margin:0 auto;background:#0B0F0B;color:#D4D4D4;font-family:'Segoe UI',system-ui,-apple-system,sans-serif;font-size:13px;display:flex;flex-direction:column;border:1px solid #1A241A;box-shadow:0 24px 80px rgba(0,0,0,.6);overflow:hidden;border-radius:6px;">
+
+  <!-- ============ MODE BAR ============ -->
+  <div style="height:46px;flex:0 0 46px;background:#0D120D;border-bottom:1px solid #1A241A;display:flex;align-items:center;padding:0 14px;gap:4px;">
+    <div style="display:flex;align-items:center;gap:8px;margin-right:18px;">
+      <div style="width:22px;height:22px;border-radius:5px;background:linear-gradient(135deg,#2A4A2A,#162616);display:flex;align-items:center;justify-content:center;font-size:13px;">🗡</div>
+      <span style="font-weight:600;letter-spacing:.3px;color:#A8CC80;font-size:13px;">TheOrc</span>
+    </div>
+    <div style="display:flex;align-items:center;gap:2px;">
+      <div style="padding:6px 13px;border-radius:6px;color:#7E8C7E;cursor:default;">Single</div>
+      <div style="padding:6px 13px;border-radius:6px;color:#7E8C7E;cursor:default;">Swarm</div>
+      <div style="padding:6px 13px;border-radius:6px;background:#162616;color:#C4E89A;border:1px solid #2A4A2A;font-weight:600;">Chat</div>
+      <div style="padding:6px 13px;border-radius:6px;color:#7E8C7E;cursor:default;">Pit</div>
+      <div style="padding:6px 13px;border-radius:6px;color:#7E8C7E;cursor:default;">Hive</div>
+    </div>
+    <div style="flex:1;"></div>
+    <div style="display:flex;align-items:center;gap:7px;padding:5px 11px;border-radius:6px;background:#0E160E;border:1px solid #1E2E1E;color:#9FB890;font-family:'JetBrains Mono',monospace;font-size:11px;">
+      <span style="width:7px;height:7px;border-radius:50%;background:#7FB069;box-shadow:0 0 6px #7FB069;"></span>
+      hermes-3-llama-3.1-8b
+    </div>
+    <div style="position:relative;padding:6px 13px;border-radius:6px;color:#7E8C7E;margin-left:4px;">⬆ Update<span style="position:absolute;top:4px;right:6px;width:6px;height:6px;border-radius:50%;background:#D6A85A;"></span></div>
+  </div>
+
+  <!-- ============ BODY ============ -->
+  <div style="flex:1;min-height:0;display:flex;">
+
+    <!-- ====== LIBRARY DRAWER ====== -->
+    <div style="width:312px;flex:0 0 312px;background:#0A0D0A;border-right:1px solid #1A241A;display:flex;flex-direction:column;min-height:0;">
+      <div style="padding:14px 15px 10px;border-bottom:1px solid #162016;">
+        <div style="display:flex;align-items:center;justify-content:space-between;">
+          <div style="display:flex;align-items:center;gap:8px;">
+            <span style="font-size:13px;">📚</span>
+            <span style="font-weight:600;color:#C8D4C8;letter-spacing:.2px;">Library</span>
+          </div>
+          <div style="position:relative;">
+            <button onClick="{{ toggleAdd }}" style="background:#162616;border:1px solid #2A4A2A;color:#C4E89A;border-radius:6px;padding:5px 10px;font-size:11.5px;font-weight:600;cursor:pointer;font-family:inherit;" style-hover="background:#1E3A1E;">+ Add source ▾</button>
+            <sc-if value="{{ addMenu }}" hint-placeholder-val="{{ false }}">
+              <div style="position:absolute;top:32px;right:0;z-index:20;width:228px;background:#0E140E;border:1px solid #2A4A2A;border-radius:9px;padding:6px;box-shadow:0 14px 40px rgba(0,0,0,.6);">
+                <div style="display:flex;align-items:center;gap:9px;padding:8px 9px;border-radius:6px;cursor:pointer;" style-hover="background:#142014;"><span>📄</span><div><div style="color:#D8E4D0;font-size:12px;font-weight:600;">From file…</div><div style="font-family:'JetBrains Mono',monospace;font-size:9px;color:#6E8068;">.txt · .md · .pdf</div></div></div>
+                <div style="display:flex;align-items:center;gap:9px;padding:8px 9px;border-radius:6px;cursor:pointer;" style-hover="background:#142014;"><span>📁</span><div><div style="color:#D8E4D0;font-size:12px;font-weight:600;">From folder…</div><div style="font-family:'JetBrains Mono',monospace;font-size:9px;color:#6E8068;">batch import a directory</div></div></div>
+                <div style="display:flex;align-items:center;gap:9px;padding:8px 9px;border-radius:6px;cursor:pointer;" style-hover="background:#142014;"><span>🌐</span><div><div style="color:#C4E89A;font-size:12px;font-weight:600;">Find on the web…</div><div style="font-family:'JetBrains Mono',monospace;font-size:9px;color:#6E8068;">orc searches &amp; downloads</div></div></div>
+              </div>
+            </sc-if>
+          </div>
+        </div>
+        <div style="margin-top:10px;display:flex;align-items:center;gap:8px;background:#0B0F0B;border:1px solid #1E2E1E;border-radius:7px;padding:6px 9px;">
+          <span style="color:#5A6B5A;font-size:12px;">🔎</span>
+          <span style="color:#5E6E5A;font-size:11.5px;flex:1;">Search the library…</span>
+          <span style="font-family:'JetBrains Mono',monospace;font-size:9px;color:#5A6B5A;border:1px solid #1E2E1E;border-radius:4px;padding:1px 5px;">FTS</span>
+        </div>
+      </div>
+
+      <div style="flex:1;min-height:0;overflow-y:auto;padding:12px 12px 16px;">
+
+        <div style="font-size:10px;font-weight:600;letter-spacing:1.2px;color:#5A6B5A;text-transform:uppercase;margin:2px 4px 9px;">Corpora</div>
+
+        <!-- Darwin — READY, attached -->
+        <div style="background:#101A10;border:1px solid #2A4A2A;border-radius:9px;padding:11px 12px;margin-bottom:10px;box-shadow:0 0 0 1px rgba(127,176,105,.05);">
+          <div style="display:flex;align-items:flex-start;justify-content:space-between;gap:8px;">
+            <div style="min-width:0;">
+              <div style="font-weight:600;color:#D8E4D0;font-size:12.5px;line-height:1.25;">On the Origin of Species</div>
+              <div style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#6E8068;margin-top:3px;">Darwin · 1st ed. 1859 · PDF</div>
+            </div>
+            <span style="flex:0 0 auto;display:inline-flex;align-items:center;gap:5px;background:#132513;border:1px solid #2F4F2F;color:#9FD37F;border-radius:999px;padding:3px 8px;font-size:10px;font-weight:600;font-family:'JetBrains Mono',monospace;">● Attached</span>
+          </div>
+          <div style="margin-top:10px;display:flex;align-items:center;gap:8px;">
+            <div style="flex:1;height:5px;border-radius:3px;background:#162016;overflow:hidden;"><div style="width:100%;height:100%;background:linear-gradient(90deg,#3F6E33,#7FB069);"></div></div>
+            <span style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#7FB069;white-space:nowrap;">384 / 384</span>
+          </div>
+          <div style="margin-top:8px;display:flex;flex-wrap:wrap;gap:5px;font-family:'JetBrains Mono',monospace;font-size:9.5px;">
+            <span style="color:#7FB069;background:#132513;border-radius:4px;padding:2px 6px;">✓ coverage complete</span>
+            <span style="color:#6E8068;background:#0E160E;border-radius:4px;padding:2px 6px;">14 chapters</span>
+            <span style="color:#6E8068;background:#0E160E;border-radius:4px;padding:2px 6px;">2,914 claims</span>
+          </div>
+        </div>
+
+        <!-- DSM — INDEXING -->
+        <div style="background:#12100A;border:1px solid #3A3017;border-radius:9px;padding:11px 12px;margin-bottom:10px;">
+          <div style="display:flex;align-items:flex-start;justify-content:space-between;gap:8px;">
+            <div style="min-width:0;">
+              <div style="font-weight:600;color:#E0D8C4;font-size:12.5px;line-height:1.25;">Clinical Reference (sample)</div>
+              <div style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#8A7E60;margin-top:3px;">5th ed. · PDF · educational use</div>
+            </div>
+            <span style="flex:0 0 auto;display:inline-flex;align-items:center;gap:5px;background:#221B0C;border:1px solid #4A3C18;color:#D6A85A;border-radius:999px;padding:3px 8px;font-size:10px;font-weight:600;font-family:'JetBrains Mono',monospace;"><span style="width:6px;height:6px;border-radius:50%;background:#D6A85A;animation:orcPulse 1.1s infinite;"></span> Indexing</span>
+          </div>
+          <div style="margin-top:10px;display:flex;align-items:center;gap:8px;">
+            <div style="position:relative;flex:1;height:5px;border-radius:3px;background:#1E1810;overflow:hidden;">
+              <div style="width:64%;height:100%;background:linear-gradient(90deg,#7A5E22,#D6A85A);"></div>
+              <div style="position:absolute;top:0;left:0;width:38%;height:100%;background:linear-gradient(90deg,transparent,rgba(255,220,150,.45),transparent);animation:orcShimmer 1.6s infinite;"></div>
+            </div>
+            <span style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#D6A85A;white-space:nowrap;">247 / 384</span>
+          </div>
+          <div style="margin-top:7px;font-family:'JetBrains Mono',monospace;font-size:10px;color:#8A7E60;">Reading evidence cards · ~2m left</div>
+          <div style="margin-top:8px;display:flex;align-items:center;gap:6px;">
+            <span style="font-family:'JetBrains Mono',monospace;font-size:9.5px;color:#C0614F;background:#1E110E;border:1px solid #3A1E18;border-radius:4px;padding:2px 6px;">⚠ 3 segments failed</span>
+            <button style="margin-left:auto;background:transparent;border:1px solid #3A3017;color:#D6A85A;border-radius:5px;padding:3px 9px;font-size:10px;cursor:pointer;font-family:inherit;" style-hover="background:#221B0C;">Repair</button>
+          </div>
+        </div>
+
+        <!-- A small corpus — STALE -->
+        <div style="background:#0E120E;border:1px solid #1E2E1E;border-radius:9px;padding:11px 12px;margin-bottom:10px;">
+          <div style="display:flex;align-items:flex-start;justify-content:space-between;gap:8px;">
+            <div style="min-width:0;">
+              <div style="font-weight:600;color:#B8C4B4;font-size:12.5px;line-height:1.25;">Project Manuals</div>
+              <div style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#6E8068;margin-top:3px;">9 docs · Markdown</div>
+            </div>
+            <span style="flex:0 0 auto;display:inline-flex;align-items:center;gap:5px;background:#1A140B;border:1px solid #443714;color:#C98A4B;border-radius:999px;padding:3px 8px;font-size:10px;font-weight:600;font-family:'JetBrains Mono',monospace;">↻ Stale</span>
+          </div>
+          <div style="margin-top:9px;font-family:'JetBrains Mono',monospace;font-size:10px;color:#9A845E;line-height:1.4;">Parser v2.1 → index built on v1.8.<br>Re-index to use latest extraction.</div>
+          <button style="margin-top:9px;width:100%;background:#1A140B;border:1px solid #443714;color:#C98A4B;border-radius:6px;padding:6px;font-size:11px;font-weight:600;cursor:pointer;font-family:inherit;" style-hover="background:#221A0C;">Re-index corpus</button>
+        </div>
+
+        <div style="margin:18px 4px 9px;font-size:10px;font-weight:600;letter-spacing:1.2px;color:#5A6B5A;text-transform:uppercase;">Notebook · this chat</div>
+        <div style="background:#0E140E;border:1px dashed #243424;border-radius:8px;padding:10px 11px;">
+          <div style="font-family:'JetBrains Mono',monospace;font-size:9.5px;color:#6E8068;margin-bottom:7px;">2 cited conclusions saved</div>
+          <div style="font-size:11.5px;color:#A8B8A0;line-height:1.45;border-left:2px solid #2F4F2F;padding-left:8px;margin-bottom:8px;">Selection acts on heritable variation that already exists in populations. <span style="font-family:'JetBrains Mono',monospace;color:#6E9E5A;font-size:9.5px;">[Ch.1, Ch.4]</span></div>
+          <div style="font-size:11.5px;color:#A8B8A0;line-height:1.45;border-left:2px solid #2F4F2F;padding-left:8px;">Geometric population growth creates the struggle that makes selection inevitable. <span style="font-family:'JetBrains Mono',monospace;color:#6E9E5A;font-size:9.5px;">[Ch.3]</span></div>
+        </div>
+
+      </div>
+
+      <!-- storage location footer -->
+      <div style="flex:0 0 auto;border-top:1px solid #162016;padding:10px 13px;display:flex;align-items:center;gap:9px;">
+        <span style="font-size:12px;color:#5A6B5A;">🗄</span>
+        <div style="min-width:0;flex:1;">
+          <div style="font-family:'JetBrains Mono',monospace;font-size:9px;color:#5A6B5A;letter-spacing:.5px;">LIBRARY STORAGE</div>
+          <div style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#8A9A84;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;">~/research/darwin/.orc/fabric</div>
+        </div>
+        <button style="background:transparent;border:1px solid #1E2E1E;color:#9FB890;border-radius:5px;padding:4px 9px;font-size:10px;cursor:pointer;font-family:inherit;" style-hover="border-color:#2A4A2A;">Change…</button>
+      </div>
+    </div>
+
+    <!-- ====== CHAT PANEL ====== -->
+    <div style="flex:1;min-width:0;display:flex;flex-direction:column;background:#0B0F0B;min-height:0;">
+
+      <!-- chat header -->
+      <div style="flex:0 0 auto;padding:11px 18px;border-bottom:1px solid #162016;display:flex;align-items:center;gap:12px;">
+        <!-- corpus badge -->
+        <div style="display:flex;align-items:center;gap:8px;background:#101A10;border:1px solid #2A4A2A;border-radius:8px;padding:6px 11px;">
+          <span style="font-size:12px;">📖</span>
+          <div style="line-height:1.15;">
+            <div style="font-size:12px;font-weight:600;color:#D8E4D0;">Origin of Species <span style="color:#6E8068;font-weight:400;font-family:'JetBrains Mono',monospace;font-size:10px;">1st ed.</span></div>
+            <div style="font-size:9.5px;color:#7FB069;font-family:'JetBrains Mono',monospace;">source-bound · coverage complete</div>
+          </div>
+          <span style="color:#5A6B5A;cursor:pointer;padding-left:4px;font-size:13px;" style-hover="color:#C0614F;">✕</span>
+        </div>
+
+        <!-- Quick / Study toggle -->
+        <div style="display:flex;align-items:center;background:#0E140E;border:1px solid #1E2E1E;border-radius:8px;padding:3px;gap:3px;">
+          <button onClick="{{ setQuick }}" style="{{ quickStyle }}border-radius:6px;padding:5px 14px;font-size:11.5px;font-weight:600;cursor:pointer;font-family:inherit;">Quick</button>
+          <button onClick="{{ setStudy }}" style="{{ studyStyle }}border-radius:6px;padding:5px 14px;font-size:11.5px;font-weight:600;cursor:pointer;font-family:inherit;">Study</button>
+        </div>
+        <div style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#6E8068;max-width:170px;line-height:1.3;">{{ modeHint }}</div>
+
+        <div style="flex:1;"></div>
+        <div style="display:flex;align-items:center;gap:7px;padding:5px 10px;border-radius:6px;background:#0E160E;border:1px solid #1E2E1E;color:#7E8C7E;font-family:'JetBrains Mono',monospace;font-size:10px;">Context: 3,120 / 8,192 (38%)</div>
+      </div>
+
+      <!-- conversation -->
+      <div style="flex:1;min-height:0;overflow-y:auto;padding:22px 26px;">
+
+        <!-- user bubble -->
+        <div style="display:flex;justify-content:flex-end;margin-bottom:18px;">
+          <div style="max-width:620px;background:#1A2A1A;border:1px solid #2A4A2A;border-radius:10px 10px 2px 10px;padding:11px 14px;color:#D8E4D0;line-height:1.5;">How does Darwin build the case for natural selection — from variation under domestication, through the struggle for existence, to selection in the wild? Trace it across chapters.</div>
+        </div>
+
+        <!-- tool chip -->
+        <div style="display:flex;margin-bottom:8px;">
+          <div style="display:inline-flex;align-items:center;gap:8px;background:#0E160E;border:1px solid #1E2E1E;border-radius:6px;padding:5px 10px;font-family:'JetBrains Mono',monospace;font-size:10px;color:#5A7744;">
+            🔎 library_ask <span style="color:#446633;">→ planned {{ modePlanLabel }} · {{ segConsidered }} segments · packed 3,120 tok</span>
+          </div>
+        </div>
+
+        <!-- assistant bubble -->
+        <div style="display:flex;margin-bottom:14px;">
+          <div style="max-width:760px;background:#111611;border:1px solid #1E2E1E;border-radius:10px 10px 10px 2px;padding:15px 17px;">
+
+            <div style="color:#C8D4C8;line-height:1.62;font-size:13px;">
+              Darwin builds the argument cumulatively rather than asserting it. He opens with <strong style="color:#D8E4D0;">variation under domestication</strong>, showing that breeders reshape species by accumulating small heritable differences over generations<span onClick="{{ open1 }}" style="{{ chip1 }}">1</span>. That establishes his raw material: variation is real, heritable, and acted upon.
+              <br><br>
+              He then argues that a parallel pressure operates in nature. Because populations tend to multiply geometrically while resources do not, far more individuals are born than can survive — producing a constant <strong style="color:#D8E4D0;">struggle for existence</strong><span onClick="{{ open2 }}" style="{{ chip2 }}">2</span>. This is the engine that domestic breeding only imitates.
+              <br><br>
+              Selection in the wild follows by analogy: where the breeder chooses, nature's struggle does the choosing, preserving favourable variations and rejecting injurious ones<span onClick="{{ open3 }}" style="{{ chip3 }}">3</span>. The cross-chapter move is the key claim — the same accumulative mechanism, with the selecting agent swapped from human to environment.
+            </div>
+
+            <!-- coverage / verification line -->
+            <div style="margin-top:15px;padding-top:12px;border-top:1px solid #1A241A;display:flex;flex-wrap:wrap;align-items:center;gap:7px;font-family:'JetBrains Mono',monospace;font-size:10px;">
+              <span style="display:inline-flex;align-items:center;gap:5px;color:#9FD37F;background:#132513;border:1px solid #2F4F2F;border-radius:5px;padding:3px 8px;">{{ modeBadge }}</span>
+              <span style="color:#7E8C7E;background:#0E160E;border:1px solid #1A241A;border-radius:5px;padding:3px 8px;">{{ coverageText }}</span>
+              <span style="display:inline-flex;align-items:center;gap:5px;color:#7FB069;background:#0E160E;border:1px solid #1A241A;border-radius:5px;padding:3px 8px;">✓ citations verified</span>
+              <span style="display:inline-flex;align-items:center;gap:5px;color:#7F94A8;background:#0E160E;border:1px solid #1A241A;border-radius:5px;padding:3px 8px;">✎ 1 interpretive</span>
+            </div>
+
+            <!-- citation footnotes -->
+            <div style="margin-top:11px;display:flex;flex-direction:column;gap:6px;">
+              <div onClick="{{ open1 }}" style="display:flex;align-items:center;gap:9px;cursor:pointer;padding:6px 9px;border-radius:6px;background:#0E140E;border:1px solid #1A241A;" style-hover="border-color:#2A4A2A;">
+                <span style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#9FD37F;background:#132513;border-radius:4px;padding:1px 6px;">1</span>
+                <span style="font-size:11px;color:#A8B8A0;">Ch. 1 · Variation under Domestication</span>
+                <span style="margin-left:auto;font-family:'JetBrains Mono',monospace;font-size:9.5px;color:#7FB069;">✓ supported · seg-1f4 · 612–741</span>
+              </div>
+              <div onClick="{{ open2 }}" style="display:flex;align-items:center;gap:9px;cursor:pointer;padding:6px 9px;border-radius:6px;background:#0E140E;border:1px solid #1A241A;" style-hover="border-color:#2A4A2A;">
+                <span style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#9FD37F;background:#132513;border-radius:4px;padding:1px 6px;">2</span>
+                <span style="font-size:11px;color:#A8B8A0;">Ch. 3 · Struggle for Existence</span>
+                <span style="margin-left:auto;font-family:'JetBrains Mono',monospace;font-size:9.5px;color:#7FB069;">✓ supported · seg-8b2 · 1042–1190</span>
+              </div>
+              <div onClick="{{ open3 }}" style="display:flex;align-items:center;gap:9px;cursor:pointer;padding:6px 9px;border-radius:6px;background:#0E140E;border:1px solid #1A241A;" style-hover="border-color:#2A4A2A;">
+                <span style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#7F94A8;background:#10161C;border-radius:4px;padding:1px 6px;">3</span>
+                <span style="font-size:11px;color:#A8B8A0;">Ch. 4 · Natural Selection</span>
+                <span style="margin-left:auto;font-family:'JetBrains Mono',monospace;font-size:9.5px;color:#7F94A8;">✎ interpretive · seg-c07 · 88–233</span>
+              </div>
+            </div>
+
+          </div>
+        </div>
+
+      </div>
+
+      <!-- input -->
+      <div style="flex:0 0 auto;padding:13px 18px 16px;border-top:1px solid #162016;">
+        <div style="display:flex;align-items:flex-end;gap:10px;background:#0E140E;border:1px solid #243424;border-radius:11px;padding:11px 13px;">
+          <span style="color:#5A6B5A;font-size:15px;padding-bottom:1px;cursor:pointer;">📎</span>
+          <div style="flex:1;color:#5E6E5A;font-size:13px;padding-bottom:2px;">Ask a source-bound question…<span style="display:inline-block;width:1px;height:14px;background:#7FB069;margin-left:1px;vertical-align:middle;animation:orcBlink 1.1s infinite;"></span></div>
+          <button style="background:#1E3A1E;border:1px solid #2F4F2F;color:#C4E89A;border-radius:8px;padding:7px 16px;font-size:12px;font-weight:600;cursor:pointer;font-family:inherit;" style-hover="background:#264A26;">Send</button>
+        </div>
+        <div style="margin-top:8px;font-family:'JetBrains Mono',monospace;font-size:9.5px;color:#5A6B5A;display:flex;align-items:center;gap:7px;">
+          <span style="color:#6E8068;">⛓ source-bound</span> answers cite source ranges and are independently verified · summaries are navigation, not truth
+        </div>
+      </div>
+
+    </div>
+
+    <!-- ====== SOURCE PREVIEW PANE ====== -->
+    <div style="width:372px;flex:0 0 372px;background:#0A0D0A;border-left:1px solid #1A241A;display:flex;flex-direction:column;min-height:0;">
+      <div style="flex:0 0 auto;padding:13px 15px;border-bottom:1px solid #162016;display:flex;align-items:center;justify-content:space-between;">
+        <div style="display:flex;align-items:center;gap:8px;"><span style="font-size:12px;">📄</span><span style="font-weight:600;color:#C8D4C8;">Source</span></div>
+        <span style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#6E8068;">{{ citLabel }}</span>
+      </div>
+
+      <div style="flex:1;min-height:0;overflow-y:auto;padding:15px;">
+
+        <!-- meta -->
+        <div style="background:#0E140E;border:1px solid #1A241A;border-radius:8px;padding:11px 12px;margin-bottom:13px;">
+          <div style="font-weight:600;color:#D8E4D0;font-size:12.5px;">{{ citDoc }}</div>
+          <div style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#6E8068;margin-top:5px;line-height:1.6;">
+            heading · {{ citHeading }}<br>
+            segment · {{ citSeg }}<br>
+            chars · {{ citRange }}
+          </div>
+          <div style="margin-top:9px;">{{ citVerifyBadge }}</div>
+        </div>
+
+        <!-- source text with highlighted quote -->
+        <div style="font-size:12.5px;line-height:1.72;color:#8A9A84;font-family:'JetBrains Mono',monospace;">
+          {{ citContext }}
+        </div>
+
+        <div style="margin-top:16px;padding-top:13px;border-top:1px solid #1A241A;display:flex;gap:8px;">
+          <button style="flex:1;background:#0E160E;border:1px solid #1E2E1E;color:#9FB890;border-radius:7px;padding:7px;font-size:11px;cursor:pointer;font-family:inherit;" style-hover="border-color:#2A4A2A;">Open full segment</button>
+          <button style="flex:1;background:#0E160E;border:1px solid #1E2E1E;color:#9FB890;border-radius:7px;padding:7px;font-size:11px;cursor:pointer;font-family:inherit;" style-hover="border-color:#2A4A2A;">Save to notebook</button>
+        </div>
+
+      </div>
+    </div>
+
+  </div>
+
+  <!-- ============ STATUS BAR ============ -->
+  <div style="height:28px;flex:0 0 28px;background:#0D120D;border-top:1px solid #1A241A;display:flex;align-items:center;padding:0 14px;gap:16px;font-family:'JetBrains Mono',monospace;font-size:10px;color:#6E8068;">
+    <span>📁 ~/research/darwin</span>
+    <span style="color:#5A6B5A;">⎇ master</span>
+    <span style="color:#5A6B5A;">build d7a6af7</span>
+    <span style="flex:1;"></span>
+    <span style="display:inline-flex;align-items:center;gap:6px;color:#7FB069;"><span style="width:6px;height:6px;border-radius:50%;background:#7FB069;"></span>corpus: Origin of Species · 384/384</span>
+    <span style="color:#5A6B5A;">Quick/Study ready</span>
+  </div>
+
+</div>
+</x-dc>
+<script type="text/x-dc" data-dc-script data-props="{&quot;$preview&quot;:{&quot;width&quot;:1440,&quot;height&quot;:920}}">
+class Component extends DCLogic {
+  state = { mode: 'Study', open: 1, addMenu: false };
+
+  renderVals() {
+    const mode = this.state.mode;
+    const open = this.state.open;
+
+    const activeToggle = 'background:#1A2A1A;color:#C4E89A;border:1px solid #3A5A3A;';
+    const idleToggle   = 'background:transparent;color:#7E8C7E;border:1px solid transparent;';
+
+    const chipBase = 'cursor:pointer;font-family:\'JetBrains Mono\',monospace;font-size:9px;vertical-align:super;margin-left:2px;border-radius:4px;padding:1px 5px;';
+    const chipGreen = (on) => chipBase + (on
+      ? 'background:#1E3A1E;color:#C4E89A;border:1px solid #3A5A3A;'
+      : 'background:#132513;color:#9FD37F;border:1px solid transparent;');
+    const chipBlue = (on) => chipBase + (on
+      ? 'background:#16222C;color:#A8C4D8;border:1px solid #2A4256;'
+      : 'background:#10161C;color:#7F94A8;border:1px solid transparent;');
+
+    const studyMode = mode === 'Study';
+
+    // citation source data
+    const cites = {
+      1: {
+        label: 'citation [1]',
+        doc: 'On the Origin of Species — Darwin, 1859',
+        heading: 'Ch. 1 › Variation under Domestication',
+        seg: 'seg-1f4a9c',
+        range: '612–741',
+        verify: 'green',
+        pre: 'When we compare the individuals of the same variety or sub-variety of our older cultivated plants and animals, one of the first points which strikes us is, that they generally differ more from each other than do the individuals of any one species or variety in a state of nature. ',
+        quote: 'Breeders habitually speak of an animal\u2019s organisation as something plastic, which they can model almost as they please.',
+        post: ' If gifted with this power of selection for so short a time, what may not nature effect in the long lapse of whole geological periods?'
+      },
+      2: {
+        label: 'citation [2]',
+        doc: 'On the Origin of Species — Darwin, 1859',
+        heading: 'Ch. 3 › The Struggle for Existence',
+        seg: 'seg-8b2e07',
+        range: '1042–1190',
+        verify: 'green',
+        pre: 'A struggle for existence inevitably follows from the high rate at which all organic beings tend to increase. ',
+        quote: 'There is no exception to the rule that every organic being naturally increases at so high a rate, that, if not destroyed, the earth would soon be covered by the progeny of a single pair.',
+        post: ' Hence, as more individuals are produced than can possibly survive, there must in every case be a struggle for existence.'
+      },
+      3: {
+        label: 'citation [3]',
+        doc: 'On the Origin of Species — Darwin, 1859',
+        heading: 'Ch. 4 › Natural Selection',
+        seg: 'seg-c07f31',
+        range: '88–233',
+        verify: 'blue',
+        pre: 'Can it, then, be thought improbable, seeing that variations useful to man have undoubtedly occurred, that other variations useful in some way to each being in the great and complex battle of life, should sometimes occur? ',
+        quote: 'This preservation of favourable variations and the rejection of injurious variations, I call Natural Selection.',
+        post: ' Variations neither useful nor injurious would not be affected by natural selection.'
+      }
+    };
+    const c = cites[open];
+
+    const verifyBadge = c.verify === 'green'
+      ? React.createElement('span', { style: { fontFamily:"'JetBrains Mono',monospace", fontSize:'10px', color:'#7FB069', background:'#132513', border:'1px solid #2F4F2F', borderRadius:'5px', padding:'3px 8px', display:'inline-flex', gap:'5px' } }, '✓ supported — exact source match')
+      : React.createElement('span', { style: { fontFamily:"'JetBrains Mono',monospace", fontSize:'10px', color:'#7F94A8', background:'#10161C', border:'1px solid #2A4256', borderRadius:'5px', padding:'3px 8px', display:'inline-flex', gap:'5px' } }, '✎ interpretive — not directly stated');
+
+    // context block with highlighted quote
+    const hlStyle = c.verify === 'green'
+      ? { background:'#1B3018', color:'#D8E4D0', borderBottom:'2px solid #7FB069', padding:'1px 2px', borderRadius:'2px' }
+      : { background:'#16222C', color:'#D4E0E8', borderBottom:'2px solid #7F94A8', padding:'1px 2px', borderRadius:'2px' };
+    const citContext = React.createElement('span', null,
+      c.pre,
+      React.createElement('span', { style: hlStyle }, c.quote),
+      c.post
+    );
+
+    return {
+      mode,
+      quickStyle: mode === 'Quick' ? activeToggle : idleToggle,
+      studyStyle: mode === 'Study' ? activeToggle : idleToggle,
+      addMenu: this.state.addMenu,
+      toggleAdd: () => this.setState({ addMenu: !this.state.addMenu }),
+      setQuick: () => this.setState({ mode: 'Quick' }),
+      setStudy: () => this.setState({ mode: 'Study' }),
+      open1: () => this.setState({ open: 1 }),
+      open2: () => this.setState({ open: 2 }),
+      open3: () => this.setState({ open: 3 }),
+      chip1: chipGreen(open === 1),
+      chip2: chipGreen(open === 2),
+      chip3: chipBlue(open === 3),
+
+      modeHint: studyMode
+        ? 'iterative retrieval + targeted rereading'
+        : 'hybrid retrieval over segments + summaries',
+      modePlanLabel: studyMode ? 'Study (multi-hop)' : 'Quick (local)',
+      segConsidered: studyMode ? '38' : '9',
+      modeBadge: studyMode ? 'Study mode' : 'Quick mode',
+      coverageText: studyMode
+        ? 'considered 38 / 384 segments · reopened 12 sources'
+        : 'considered 9 / 384 segments',
+
+      citLabel: c.label,
+      citDoc: c.doc,
+      citHeading: c.heading,
+      citSeg: c.seg,
+      citRange: c.range,
+      citVerifyBadge: verifyBadge,
+      citContext,
+    };
+  }
+}
+</script>
+</body>
+</html>
diff --git a/docs/research/design_handoff_cf5_orcchat_library/README.md b/docs/research/design_handoff_cf5_orcchat_library/README.md
new file mode 100644
index 00000000..2d314794
--- /dev/null
+++ b/docs/research/design_handoff_cf5_orcchat_library/README.md
@@ -0,0 +1,237 @@
+# Handoff: CF-5 OrcChat Library Experience
+> Repo: hardcoreerik/TheOrc · Branch: master · HEAD: d7a6af70c67de402c593e0933998f49ec686d058
+
+## Overview
+CF-5 brings a **Context Fabric Library** into OrcChat — TheOrc's chat panel. A user adds a document (Darwin, a manual, a reference), waits for it to be indexed by local native models, attaches it to a conversation, and asks cross-document questions that come back with cited, verifiable answers. No manual context management.
+
+This is a **C# / Avalonia desktop app** (see ARCHITECTURE.md). Everything in this package targets that codebase. Do not ship the HTML design reference files directly — they are prototypes illustrating intended layout and behavior. Recreate each surface as Avalonia controls following the existing ChatPanel / SwarmBoardPanel patterns.
+
+## Fidelity
+**High-fidelity.** The HTML mockup (`OrcChat Library.dc.html`) shows exact colors, typography, spacing, and interactions. Match them using inline-style-equivalent Avalonia property setters. The color palette and sizing are specified in Design Tokens below. Use JetBrains Mono for technical labels (segment IDs, token counts, digests), Segoe UI / system-ui for all other text.
+
+---
+
+## Confirmed Scope for This Slice
+
+| Decision | Choice |
+|---|---|
+| Ask routing | **Direct in-ChatPanel bridge** (no library_* model tools, no tool-call probing) |
+| Indexing depth | **Read + Reduce** (FabricNativeReaderService + FabricReducer), with a read-only checkbox |
+| Extras in this slice | Web-find import · Library search (FTS) · Storage-path setting |
+
+### Explicitly OUT of this slice
+- HIVE / distributed campaign engine
+- Exhaustive query mode (FabricQueryPlanner already throws on it — do not lift that restriction)
+- New DB migrations (all CF-5 schema tables — fabric_corpora through fabric_query_runs — are already in theorc.db via CF-1..CF-4 migrations)
+- New parser formats (EPUB / DOCX / OCR) — current registry handles .txt, .md, .pdf only
+- Model-facing library_* tool family (may follow in CF-5.1)
+- Full cross-conversation notebook knowledge base
+
+---
+
+## Screens / Views
+
+### 1 · Library Drawer (left rail inside ChatPanel)
+A 312 px collapsible left rail. Always shown when the Chat mode button is active; toggled by a Library icon button in the chat header.
+
+**Header row:**
+- "📚 Library" label (Segoe UI 13 px, weight 600, #C8D4C8)
+- "+ Add source ▾" dropdown button: bg #162616, border #2A4A2A, text #C4E89A, 11.5 px, 600 weight, corner-radius 6. Click opens a flyout with three items: From file… / From folder… / Find on the web…
+- Search box below the header: bg #0B0F0B, border #1E2E1E, radius 7, icon 🔎 #5A6B5A, placeholder "Search the library…" #5E6E5A 11.5 px, FTS badge at right (JetBrains Mono 9 px, #5A6B5A)
+
+**Corpus cards (scrollable list):**
+Each card is a Border: bg #101A10 (Ready) / #12100A (Indexing) / #0E120E (Stale), border-radius 9, padding 11×12.
+
+Ready card:
+- Name: Segoe UI 12.5 px, weight 600, #D8E4D0
+- Edition/type: JetBrains Mono 10 px, #6E8068
+- "● Attached" pill: bg #132513, border #2F4F2F, text #9FD37F, radius 999, 10 px mono 600
+- Progress bar: 5 px, radius 3, bg #162016, fill gradient #3F6E33→#7FB069, width 100%
+- Coverage / chapter / claim chips: mono 9.5 px, bg #132513 (green), #0E160E (grey)
+
+Indexing card:
+- "Indexing" pill: bg #221B0C, border #4A3C18, text #D6A85A, dot animates orcPulse (@keyframes 0%/100% opacity .55, 50% opacity 1, 1.1s infinite)
+- Progress bar: 5 px, fill gradient #7A5E22→#D6A85A at reported %, shimmer overlay @keyframes orcShimmer translateX(-100%→280%) 1.6s infinite
+- Stage label: "Reading evidence cards · ~2m left" JetBrains Mono 10 px, #8A7E60
+- Failed segment count chip + Repair button (border #3A3017, text #D6A85A)
+- Read-only checkbox below the progress bar: "Read-only (skip reduce)" — stores a bool `IndexReadOnly` on CorpusAttachmentState. When checked, FabricIndexingOrchestrator skips the FabricReducer stage. Reducer runs best-effort when unchecked; failure does not block completion.
+
+Stale card:
+- "↻ Stale" pill: bg #1A140B, border #443714, text #C98A4B
+- Explanation text: mono 10 px, #9A845E
+- "Re-index corpus" full-width button: bg #1A140B, border #443714, text #C98A4B
+
+**Notebook section** (below corpus list, same scroll area):
+- Section label: NOTEBOOK · THIS CHAT, 10 px, 600 weight, 1.2 px letter-spacing, uppercase, #5A6B5A
+- Dashed border container #0E140E/#243424 showing up to 5 most recent cited conclusions, each with border-left 2 px #2F4F2F and monospace citation tag.
+
+**Storage footer** (below scroll area, flex:0):
+- Border-top #162016, bg #0A0D0A, padding 10×13
+- 🗄 label + current path (JetBrains Mono 10 px, #8A9A84, overflow ellipsis) + "Change…" button
+- "Change…" opens a SaveFolderPickerAsync dialog; calls FabricLibraryOptions setter then restarts the store at the new path.
+
+### 2 · Chat Header Bar
+Inside ChatPanel, a row above the conversation scroll area.
+
+Corpus badge (shown when corpus attached):
+- bg #101A10, border #2A4A2A, radius 8, padding 6×11
+- 📖 icon + corpus name (12 px 600 #D8E4D0) + edition (JetBrains Mono 10 px #6E8068) + status line ("source-bound · coverage complete" 9.5 px mono #7FB069)
+- ✕ detach button (#5A6B5A → hover #C0614F)
+
+Quick / Study toggle:
+- Outer: bg #0E140E, border #1E2E1E, radius 8, padding 3
+- Active button: bg #1A2A1A, text #C4E89A, border #3A5A3A, radius 6, padding 5×14, 11.5 px 600
+- Idle button: bg transparent, text #7E8C7E, border transparent
+- Mode hint text right of toggle: JetBrains Mono 10 px #6E8068, max-width 170 px
+  - Quick: "hybrid retrieval over segments + summaries"
+  - Study: "iterative retrieval + targeted rereading"
+
+Context usage badge: right-aligned, existing pattern, unchanged.
+
+### 3 · Cited Answer Bubble
+The assistant bubble (bg #111611, border #1E2E1E, radius 10/10/10/2, padding 15×17) renders:
+
+- Answer prose with inline citation superscripts: `[1]` `[2]` etc. as clickable spans. Green chip (bg #132513, text #9FD37F) for supported citations; blue chip (bg #10161C, text #7F94A8) for interpretive.
+- **Coverage / verification line** (border-top #1A241A, JetBrains Mono 10 px):
+  - Mode badge: "Study mode" or "Quick mode" — bg #132513, border #2F4F2F, text #9FD37F
+  - Segments considered: "considered 38 / 384 segments · reopened 12 sources" (or "considered 9 / 384 segments")
+  - "✓ citations verified" #7FB069 or "⚠ coverage incomplete" #D6A85A
+  - "✎ N interpretive" #7F94A8 if any
+- **Citation footnotes**: one row per citation, bg #0E140E border #1A241A radius 6, clickable (opens source preview). Shows: index pill + "Ch. N · Heading" + verification label + seg-id + char range.
+
+**Stale/incomplete banner** (only when CoverageStatus ≠ Complete OR generation keys stale):
+- Full-width, bg #221B0C, border-bottom #4A3C18, text #D6A85A, 11 px
+- "⚠ Index incomplete — answers may miss sections. Segment coverage: k/N."
+
+**Medical/sensitive policy banner** (when policyProfile ≠ "default"):
+- bg #10161C, border-bottom #2A4256, text #A8C4D8
+- "Educational interpretation of the cited source, not professional advice."
+
+### 4 · Source-Preview Pane (right rail)
+372 px right panel. Opens on citation click; closes on ✕ or on corpus detach.
+
+- Header: "📄 Source" + citation label (JetBrains Mono 10 px #6E8068)
+- Meta card: bg #0E140E, border #1A241A, radius 8
+  - Document name (12.5 px 600 #D8E4D0)
+  - heading · seg-id · char-range (mono 10 px #6E8068, line-height 1.6)
+  - Verification badge: "✓ supported — exact source match" (#7FB069/#132513) or "✎ interpretive" (#7F94A8/#10161C)
+- Source text: JetBrains Mono 12.5 px, line-height 1.72, #8A9A84 for context; highlighted quote with bg #1B3018 / text #D8E4D0 / border-bottom 2 px #7FB069 (supported) or bg #16222C / text #D4E0E8 / border-bottom #7F94A8 (interpretive)
+- Footer buttons: "Open full segment" + "Save to notebook", bg #0E160E, border #1E2E1E, #9FB890
+
+### 5 · Add-Source Menu / Web-Find Flow
+
+**From file… / From folder…**: file/folder picker → FabricLibraryService.ImportFileAsync → triggers indexing.
+
+**Find on the web…**: Opens a small inline panel in the drawer (replaces corpus list temporarily):
+- Text input: "Book title, author, or URL…"
+- "Search" button → calls FabricWebImporter.SearchAndDownloadAsync (web_search tool internally via ChatEngine one-shot, or direct HTTP fetch for known URLs like Project Gutenberg)
+- Results list: URL + title + format tag (PDF / TXT) + estimated size, each with "Add to library" button
+- On "Add to library": download → verify digest → save to content store → call ImportFileAsync → trigger indexing
+
+Policy gate displayed below the input: "Only add content you are licensed to use. OrcChat does not redistribute corpus content outside this machine."
+
+### 6 · Library Search
+Activating the drawer search box (click or Tab) filters the corpus list in real time via FabricLibraryService.Search(query). Highlights matching corpus/document names. A "search results" section expands above corpora showing FabricSearchHit items (segment text snippets, claim text) with a "Jump to corpus" link.
+
+---
+
+## Interactions & Behavior
+
+- **Quick/Study toggle**: updates CorpusAttachmentState.Mode; next send uses the new mode. No re-run of previous answers.
+- **Citation click**: sets SourcePreviewState.OpenCitationIndex; pane animates in (slide from right or simple fade). Pane closes on X or on corpus detach.
+- **Attach corpus**: sets CorpusAttachmentState; next send routes through FabricAskService instead of plain ChatEngine.Send.
+- **Detach corpus**: clears CorpusAttachmentState; pane closes; plain chat resumes. Does NOT clear conversation history.
+- **Index → complete**: IndexProgressViewModel raises PropertyChanged; corpus card transitions from Indexing → Ready state; corpus badge updates.
+- **Read-only checkbox**: persisted per corpus (not per conversation). Calls FabricIndexingOrchestrator with readOnly:true, skips FabricReducer stage.
+- **Stale detection**: on chat activate or corpus select, compare corpus generation keys (parser/chunker/schema/model/prompt versions from fabric_derivation_runs) against current FabricRunOptions values. Show stale banner if mismatch.
+- **Budget overflow**: if FabricEvidencePack.FitsBudget == false, prepend "Evidence truncated — ask a narrower question or use Study" to the answer bubble.
+- **Save to notebook**: appends a ConversationNotebookEntry to ConversationNotebookStore; notebook section in drawer live-updates.
+
+---
+
+## State Management
+
+New state objects — follow existing ChatPanel field patterns (`private X _x;`):
+
+```
+CorpusAttachmentState         // null = no corpus attached
+  string CorpusId
+  string DisplayName
+  string Edition
+  string Mode                 // "Quick" | "Study"
+  string CoverageStatus       // "complete" | "partial" | "none"
+  bool IsStale
+  bool IsReadOnly             // from read-only checkbox
+  string PolicyProfile        // "default" | "medical" | ...
+
+IndexProgressViewModel        // per-document, raised via events
+  string DocumentId
+  string Stage                // "parsing" | "reading" | "reducing" | "ready" | "failed"
+  int CompletedSegments
+  int TotalSegments
+  IReadOnlyList<string> FailedSegmentIds
+  string? ErrorMessage
+
+CitationViewModel             // per inline citation chip
+  int Index
+  string SegmentId
+  string DocumentId
+  string HeadingPath
+  int CharStart
+  int CharEnd
+  string Quote
+  string VerificationLabel    // "Supported" | "PartiallySupported" | "Interpretive" | "CitationMismatch" | "Unverifiable"
+
+ConversationNotebookEntry
+  string ClaimText
+  List<CitationViewModel> Citations
+  DateTimeOffset CreatedAt
+  string QueryRunId
+```
+
+---
+
+## Design Tokens
+
+```
+App bg:             #0B0F0B
+Drawer/preview bg:  #0A0D0A
+Mode/status bar bg: #0D120D
+Raised surface:     #101A10   (corpus card ready)
+                    #12100A   (indexing card)
+                    #0E120E   (stale card)
+                    #111611   (assistant bubble)
+                    #0E140E   (insets, footnote rows)
+Borders:
+  subtle:           #1A241A
+  standard:         #1E2E1E
+  emphasis:         #2A4A2A
+  strong:           #3A5A3A
+User bubble:        bg #1A2A1A   border #2A4A2A
+Text primary:       #D4D4D4  #C8D4C8  #D8E4D0
+Text muted:         #8A9A84  #7E8C7E  #6E8068  #5A6B5A
+Green accents:      #C4E89A  #A8CC80  #9FD37F  #7FB069  #3F6E33
+Status amber:       #D6A85A  bg #221B0C  border #4A3C18
+Status orange:      #C98A4B  bg #1A140B  border #443714
+Status red:         #C0614F  bg #1E110E  border #3A1E18
+Status blue (interpretive): #7F94A8  bg #10161C  border #2A4256
+Font body:          "Segoe UI", system-ui, -apple-system, sans-serif
+Font mono:          "JetBrains Mono", ui-monospace, monospace
+```
+
+---
+
+## Files
+
+| File | Purpose |
+|---|---|
+| `OrcChat Library.dc.html` | High-fidelity interactive mockup — reference only |
+| `src/FabricAskService.cs` | Core orchestration: planner → pack → answer → verify |
+| `src/FabricIndexingOrchestrator.cs` | Read + reduce pipeline with IProgress<> + retry |
+| `src/FabricWebImporter.cs` | Web-find: search → download → digest → import |
+| `src/ViewModels/LibraryViewModel.cs` | Corpus/document list, search, attach/detach |
+| `src/ViewModels/IndexProgressViewModel.cs` | Per-document progress state |
+| `src/ViewModels/CitationViewModel.cs` | Per-citation data for chip + pane |
+| `src/ConversationNotebookStore.cs` | Per-conversation cited-conclusion JSON store |
+| `ChatPanel_CF5_changes.md` | Exact instructions for ChatPanel.axaml.cs edits |
+| `CLAUDE_CODE_PROMPT.md` | Ready-to-paste prompt for Claude Code / CLI |
diff --git a/docs/research/design_handoff_cf5_orcchat_library/src/ConversationNotebookStore.cs b/docs/research/design_handoff_cf5_orcchat_library/src/ConversationNotebookStore.cs
new file mode 100644
index 00000000..1e21528a
--- /dev/null
+++ b/docs/research/design_handoff_cf5_orcchat_library/src/ConversationNotebookStore.cs
@@ -0,0 +1,48 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// CF-5: per-conversation cited-conclusion store. Mirrors OpenChatMemory pattern.
+// Drop into OrchestratorIDE/Services/
+
+using System.Text.Json;
+using OrchestratorIDE.UI.ViewModels;
+
+namespace OrchestratorIDE.Services;
+
+public sealed record ConversationNotebookEntry(
+    string ClaimText,
+    IReadOnlyList<CitationViewModel> Citations,
+    DateTimeOffset CreatedAt,
+    string QueryRunId);
+
+public static class ConversationNotebookStore
+{
+    private static readonly JsonSerializerOptions _json =
+        new() { WriteIndented = true, PropertyNameCaseInsensitive = true };
+
+    public static string StorePath(string workspaceRoot, string conversationId) =>
+        Path.Combine(workspaceRoot, ".orc", "chat", $"notebook-{conversationId}.json");
+
+    public static IReadOnlyList<ConversationNotebookEntry> Load(string path)
+    {
+        if (!File.Exists(path)) return [];
+        try
+        {
+            var json = File.ReadAllText(path);
+            return JsonSerializer.Deserialize<List<ConversationNotebookEntry>>(json, _json) ?? [];
+        }
+        catch { return []; }
+    }
+
+    public static void Append(string path, ConversationNotebookEntry entry)
+    {
+        var entries = Load(path).ToList();
+        entries.Add(entry);
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        File.WriteAllText(path, JsonSerializer.Serialize(entries, _json));
+    }
+
+    public static void Clear(string path)
+    {
+        if (File.Exists(path)) File.Delete(path);
+    }
+}
diff --git a/docs/research/design_handoff_cf5_orcchat_library/src/FabricAskService.cs b/docs/research/design_handoff_cf5_orcchat_library/src/FabricAskService.cs
new file mode 100644
index 00000000..76cb16bf
--- /dev/null
+++ b/docs/research/design_handoff_cf5_orcchat_library/src/FabricAskService.cs
@@ -0,0 +1,191 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// CF-5: OrcChat Library ask service — chains planner → pack → native answer → verifier.
+// Drop this file into OrchestratorIDE/Services/ContextFabric/
+
+using System.Text.Json;
+using OrchestratorIDE.Core.Runtime;
+
+namespace OrchestratorIDE.Services.ContextFabric;
+
+public sealed record FabricAskResult(
+    string Answer,
+    bool Abstained,
+    string Mode,
+    int SegmentsConsidered,
+    int SegmentsTotal,
+    bool FitsBudget,
+    bool TriggeredSourceReopen,
+    IReadOnlyList<FabricAnswerClaimResult> Claims);
+
+public sealed record FabricAnswerClaimResult(
+    string ClaimText,
+    string VerificationLabel,      // Supported | PartiallySupported | Interpretive | CitationMismatch | Unverifiable
+    IReadOnlyList<FabricCitationDetail> Citations);
+
+public sealed record FabricCitationDetail(
+    int Index,
+    string SegmentId,
+    string DocumentId,
+    string HeadingPath,
+    int CharStart,
+    int CharEnd,
+    string Quote,
+    string VerificationLabel);
+
+public sealed class FabricAskService(
+    FabricQueryPlanner queryPlanner,
+    EvidencePackBuilder packBuilder,
+    FabricCitationVerifier citationVerifier,
+    FabricLibraryRepository libraryRepository,
+    IRoleRuntime runtime,
+    FabricRunOptions? options = null)
+{
+    private static readonly FabricRunOptions _defaultOptions = FabricRunOptions.Default;
+    private readonly FabricRunOptions _options = options ?? _defaultOptions;
+
+    // System prompt template — answer contract. Adjust cf0-answer-1.2 prompt text here.
+    private const string AnswerSystemPrompt = """
+        You are a source-bound research assistant. Answer ONLY from the provided evidence.
+        Respond with valid JSON matching this schema exactly:
+        {"schemaVersion":"cf0-answer-1.0","answer":"<prose>","abstained":<bool>,"claims":[{"text":"<claim>","citations":[{"segmentId":"<id>","charStart":<n>,"charEnd":<n>,"quote":"<exact substring>","quoteDigest":""}]}]}
+        Rules:
+        - Every non-trivial claim must carry at least one citation with an exact quote from the evidence.
+        - If the evidence does not support the question, set abstained:true and answer:"The provided sources do not contain sufficient evidence to answer this question."
+        - Do not invent facts. Do not use knowledge outside the provided evidence.
+        - quoteDigest is left empty — the host computes it.
+        """;
+
+    public async Task<FabricAskResult> AskAsync(
+        string question,
+        string corpusId,
+        string mode,
+        CancellationToken ct = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(question);
+        ArgumentException.ThrowIfNullOrWhiteSpace(corpusId);
+
+        // 1. Plan
+        var plan = queryPlanner.BuildPlan(question, corpusId, mode);
+
+        // 2. Pack evidence into token budget
+        var pack = packBuilder.Build(plan);
+
+        // 3. Build prompt and generate answer
+        var evidenceText = BuildEvidenceText(pack);
+        var prompt = $"""
+            Evidence from the corpus:
+
+            {evidenceText}
+
+            ---
+            Question: {question}
+
+            Respond with the JSON answer schema.
+            """;
+
+        var rawAnswer = await GenerateAsync(prompt, ct).ConfigureAwait(false);
+
+        // 4. Parse model output
+        var draft = ParseAnswerDraft(rawAnswer);
+
+        // 5. Verify citations and build claim results
+        var claimResults = new List<FabricAnswerClaimResult>(draft.Claims.Count);
+        var citIndex = 0;
+        foreach (var claim in draft.Claims)
+        {
+            var verificationResult = citationVerifier.VerifyClaim(
+                claim.Text, claim.Citations, allowRepair: true);
+
+            var citDetails = verificationResult.Items
+                .Select(item => BuildCitationDetail(ref citIndex, item))
+                .ToList();
+
+            claimResults.Add(new FabricAnswerClaimResult(
+                claim.Text,
+                verificationResult.OverallLabel,
+                citDetails));
+        }
+
+        // 6. Resolve total segment count for coverage display
+        var totalSegments = libraryRepository
+            .ListDocuments(corpusId)
+            .Sum(d => libraryRepository.GetSegments(d.DocumentId).Count);
+
+        return new FabricAskResult(
+            draft.Answer,
+            draft.Abstained,
+            plan.Mode,
+            plan.SeedHits.Count + plan.ReopenedSegmentIds.Count,
+            totalSegments,
+            pack.FitsBudget,
+            plan.TriggeredSourceReopen,
+            claimResults);
+    }
+
+    private async Task<string> GenerateAsync(string prompt, CancellationToken ct)
+    {
+        // IRoleRuntime streaming — collect all tokens into a string.
+        // Mirrors ContextFabricFeasibilityRunner's internal generation pattern.
+        var sb = new System.Text.StringBuilder();
+        await foreach (var token in runtime.GenerateStreamingAsync(
+            AnswerSystemPrompt, prompt,
+            maxTokens: _options.AnswerMaxTokens,
+            temperature: _options.Temperature,
+            ct: ct).ConfigureAwait(false))
+        {
+            sb.Append(token);
+        }
+        return sb.ToString();
+    }
+
+    private static FabricAnswerDraft ParseAnswerDraft(string raw)
+    {
+        // Strip markdown fences if model wrapped the JSON
+        var json = raw.Trim();
+        if (json.StartsWith("```", StringComparison.Ordinal))
+        {
+            var start = json.IndexOf('{');
+            var end   = json.LastIndexOf('}');
+            if (start >= 0 && end > start)
+                json = json[start..(end + 1)];
+        }
+
+        try
+        {
+            return JsonSerializer.Deserialize<FabricAnswerDraft>(json,
+                new JsonSerializerOptions { PropertyNameCaseInsensitive = true })
+                ?? new FabricAnswerDraft { Abstained = true, Answer = "Could not parse answer." };
+        }
+        catch
+        {
+            return new FabricAnswerDraft { Abstained = true, Answer = "Answer schema parse failed — raw: " + raw[..Math.Min(200, raw.Length)] };
+        }
+    }
+
+    private static string BuildEvidenceText(FabricEvidencePack pack)
+    {
+        var sb = new System.Text.StringBuilder();
+        foreach (var item in pack.Included)
+        {
+            sb.AppendLine(item.IsSource
+                ? $"[SOURCE {item.Id} | {item.Provenance}]"
+                : $"[SUMMARY {item.Id} | {item.Provenance}]");
+            sb.AppendLine(item.Text);
+            sb.AppendLine();
+        }
+        if (pack.Excluded.Count > 0)
+            sb.AppendLine($"// {pack.Excluded.Count} additional evidence items excluded by token budget.");
+        return sb.ToString();
+    }
+
+    private static FabricCitationDetail BuildCitationDetail(
+        ref int index, FabricCitationVerificationItem item)
+    {
+        index++;
+        // Segment heading resolved from repo at render time in the UI layer.
+        return new FabricCitationDetail(
+            index, item.SegmentId, "", "", item.CharStart, item.CharEnd,
+            item.MatchedQuote, item.Label);
+    }
+}
diff --git a/docs/research/design_handoff_cf5_orcchat_library/src/FabricIndexingOrchestrator.cs b/docs/research/design_handoff_cf5_orcchat_library/src/FabricIndexingOrchestrator.cs
new file mode 100644
index 00000000..7fc07784
--- /dev/null
+++ b/docs/research/design_handoff_cf5_orcchat_library/src/FabricIndexingOrchestrator.cs
@@ -0,0 +1,114 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// CF-5: wraps the native read pipeline + best-effort reduce, with staged IProgress<> events.
+// Drop into OrchestratorIDE/Services/ContextFabric/
+
+using OrchestratorIDE.Core.Runtime;
+
+namespace OrchestratorIDE.Services.ContextFabric;
+
+public enum IndexStageKind { Parsing, Reading, Reducing, Complete, Failed }
+
+public sealed record IndexStageEvent(
+    string DocumentId,
+    IndexStageKind Stage,
+    int CompletedSegments,
+    int TotalSegments,
+    IReadOnlyList<string> FailedSegmentIds,
+    string? Error = null);
+
+public sealed class FabricIndexingOrchestrator(
+    FabricLibraryService libraryService,
+    FabricNativeReaderService readerService,
+    FabricReducer reducer,
+    FabricEvidenceGraphImporter graphImporter,
+    FabricLibraryRepository libraryRepository,
+    DocumentGraphRepository graphRepository)
+{
+    public async Task<IndexStageEvent> IndexDocumentAsync(
+        string documentId,
+        bool readOnly,
+        IProgress<IndexStageEvent>? progress = null,
+        CancellationToken ct = default)
+    {
+        // Resolve segment count upfront for progress reporting
+        var segments = libraryRepository.GetSegments(documentId);
+        var total = segments.Count;
+        if (total == 0)
+            return Fail(documentId, total, "Document has no segments. Re-import the source file.");
+
+        progress?.Report(new IndexStageEvent(documentId, IndexStageKind.Reading, 0, total, []));
+
+        // ── Stage 1: Native read (per-segment model calls) ──────────────────
+        FabricDocumentReadResult readResult;
+        try
+        {
+            readResult = await readerService.ReadDocumentAsync(documentId, ct).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) { throw; }
+        catch (Exception ex)
+        {
+            return Fail(documentId, total, ex.Message);
+        }
+
+        var failedIds = readResult.ReadReport.SegmentResults
+            .Where(r => !r.Accepted)
+            .Select(r => r.SegmentId)
+            .ToList();
+
+        var completed = total - failedIds.Count;
+
+        if (readOnly)
+        {
+            progress?.Report(new IndexStageEvent(documentId, IndexStageKind.Complete, completed, total, failedIds));
+            return new IndexStageEvent(documentId, IndexStageKind.Complete, completed, total, failedIds);
+        }
+
+        // ── Stage 2: Best-effort reduce ──────────────────────────────────────
+        progress?.Report(new IndexStageEvent(documentId, IndexStageKind.Reducing, completed, total, failedIds));
+
+        try
+        {
+            var doc = libraryRepository.GetDocument(documentId)!;
+            var acceptedCards = readResult.ReadReport.SegmentResults
+                .Where(r => r.Accepted && r.Card is not null)
+                .Select(r => r.Card!)
+                .ToArray();
+
+            // FabricReducer.ReduceAsync builds the hierarchy memory nodes.
+            // If it fails we still consider indexing successful with a partial warning.
+            await reducer.ReduceAsync(doc.CorpusId, documentId, acceptedCards, ct).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) { throw; }
+        catch
+        {
+            // Reduce failure is non-fatal — Quick mode still works on segments + claims.
+            // Study mode will fall back to segment reopening (planner handles gracefully).
+        }
+
+        var ev = new IndexStageEvent(documentId, IndexStageKind.Complete, completed, total, failedIds);
+        progress?.Report(ev);
+        return ev;
+    }
+
+    public async Task<IndexStageEvent> RetryFailedAsync(
+        string documentId,
+        IReadOnlyList<string> failedSegmentIds,
+        bool readOnly,
+        IProgress<IndexStageEvent>? progress = null,
+        CancellationToken ct = default)
+    {
+        // Re-read only the failed segments, then re-import their evidence cards.
+        // Idempotent: evidence import is keyed by generation + canonical hash.
+        var total = libraryRepository.GetSegments(documentId).Count;
+        progress?.Report(new IndexStageEvent(documentId, IndexStageKind.Reading, 0, failedSegmentIds.Count, []));
+
+        // TODO: FabricNativeReaderService needs a ReadSegmentsAsync(IReadOnlyList<string>) overload
+        // that restricts the FeasibilityRunner corpus to the given segment IDs.
+        // For now, call ReadDocumentAsync and filter results client-side.
+        return await IndexDocumentAsync(documentId, readOnly, progress, ct).ConfigureAwait(false);
+    }
+
+    private static IndexStageEvent Fail(string documentId, int total, string error) =>
+        new(documentId, IndexStageKind.Failed, 0, total, [], error);
+}
diff --git a/docs/research/design_handoff_cf5_orcchat_library/src/FabricWebImporter.cs b/docs/research/design_handoff_cf5_orcchat_library/src/FabricWebImporter.cs
new file mode 100644
index 00000000..2d0125ca
--- /dev/null
+++ b/docs/research/design_handoff_cf5_orcchat_library/src/FabricWebImporter.cs
@@ -0,0 +1,86 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// CF-5: web-find import — search, candidate selection, download, import.
+// Drop into OrchestratorIDE/Services/ContextFabric/
+// POLICY: only call DownloadAsync for URLs the user explicitly selects.
+//         Display the license/attribution note before downloading.
+//         Never auto-download without user confirmation.
+
+namespace OrchestratorIDE.Services.ContextFabric;
+
+public sealed record WebImportCandidate(
+    string Url,
+    string Title,
+    string Format,       // "pdf" | "txt" | "md"
+    long EstimatedBytes,
+    string Attribution); // e.g. "Project Gutenberg · Public Domain"
+
+public sealed record WebImportResult(
+    FabricImportResult ImportResult,
+    string SourceUrl,
+    string DownloadedDigest);
+
+public sealed class FabricWebImporter(
+    FabricLibraryService libraryService,
+    HttpClient httpClient)
+{
+    // Max download size: 50 MB. Mirrors FabricLibraryOptions.MaximumSourceBytes default.
+    private const long MaxDownloadBytes = 50 * 1024 * 1024;
+
+    // Search for downloadable copies. Uses the chat model's web_search tool if available,
+    // or falls back to a simple Gutenberg/Archive.org URL pattern for known authors.
+    // In the real impl, this method should call OrcChatToolCatalog.web_search via a
+    // one-shot ChatEngine call, parse the results, and return structured candidates.
+    public Task<IReadOnlyList<WebImportCandidate>> SearchAsync(
+        string query,
+        CancellationToken ct = default)
+    {
+        // TODO: implement via one-shot ChatEngine call with the web_search tool.
+        // Return a list of WebImportCandidate items. Show these to the user for selection.
+        // Never download automatically — require explicit user confirmation.
+        throw new NotImplementedException("Web search integration pending CF-5 implementation.");
+    }
+
+    public async Task<WebImportResult> DownloadAndImportAsync(
+        string corpusId,
+        WebImportCandidate candidate,
+        CancellationToken ct = default)
+    {
+        // 1. Stream download with size gate
+        using var response = await httpClient.GetAsync(
+            candidate.Url, HttpCompletionOption.ResponseHeadersRead, ct).ConfigureAwait(false);
+        response.EnsureSuccessStatusCode();
+
+        var contentLength = response.Content.Headers.ContentLength ?? 0;
+        if (contentLength > MaxDownloadBytes)
+            throw new InvalidDataException($"Remote file exceeds {MaxDownloadBytes / 1024 / 1024} MB limit.");
+
+        using var stream = await response.Content.ReadAsStreamAsync(ct).ConfigureAwait(false);
+        var memStream = new MemoryStream();
+        var buf = new byte[65536];
+        long total = 0;
+        int read;
+        while ((read = await stream.ReadAsync(buf, ct).ConfigureAwait(false)) > 0)
+        {
+            total += read;
+            if (total > MaxDownloadBytes)
+                throw new InvalidDataException("Download exceeded size limit mid-stream.");
+            memStream.Write(buf, 0, read);
+        }
+
+        // 2. Write to temp file, then import via FabricLibraryService
+        var ext = candidate.Format switch { "pdf" => ".pdf", "md" => ".md", _ => ".txt" };
+        var tmpPath = Path.Combine(Path.GetTempPath(), $"orc-webimport-{Guid.NewGuid():N}{ext}");
+        try
+        {
+            await File.WriteAllBytesAsync(tmpPath, memStream.ToArray(), ct).ConfigureAwait(false);
+            var importResult = await libraryService.ImportFileAsync(corpusId, tmpPath, ct: ct).ConfigureAwait(false);
+            var digest = importResult.Document.SourceDigest;
+            return new WebImportResult(importResult, candidate.Url, digest);
+        }
+        finally
+        {
+            if (File.Exists(tmpPath)) File.Delete(tmpPath);
+        }
+    }
+}
diff --git a/docs/research/design_handoff_cf5_orcchat_library/src/ViewModels/CitationViewModel.cs b/docs/research/design_handoff_cf5_orcchat_library/src/ViewModels/CitationViewModel.cs
new file mode 100644
index 00000000..7888ef0f
--- /dev/null
+++ b/docs/research/design_handoff_cf5_orcchat_library/src/ViewModels/CitationViewModel.cs
@@ -0,0 +1,23 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+namespace OrchestratorIDE.UI.ViewModels;
+
+public sealed record CitationViewModel(
+    int Index,
+    string SegmentId,
+    string DocumentId,
+    string HeadingPath,
+    int CharStart,
+    int CharEnd,
+    string Quote,
+    string VerificationLabel)   // Supported | PartiallySupported | Interpretive | CitationMismatch | Unverifiable
+{
+    public bool IsVerified =>
+        VerificationLabel is "Supported" or "PartiallySupported";
+
+    public bool IsInterpretive =>
+        VerificationLabel == "Interpretive";
+
+    public bool IsMismatch =>
+        VerificationLabel is "CitationMismatch" or "Unverifiable";
+}
diff --git a/docs/research/design_handoff_cf5_orcchat_library/src/ViewModels/IndexProgressViewModel.cs b/docs/research/design_handoff_cf5_orcchat_library/src/ViewModels/IndexProgressViewModel.cs
new file mode 100644
index 00000000..ad9ac9b7
--- /dev/null
+++ b/docs/research/design_handoff_cf5_orcchat_library/src/ViewModels/IndexProgressViewModel.cs
@@ -0,0 +1,48 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+using System.Collections.ObjectModel;
+using OrchestratorIDE.Services.ContextFabric;
+
+namespace OrchestratorIDE.UI.ViewModels;
+
+public sealed class IndexProgressViewModel : System.ComponentModel.INotifyPropertyChanged
+{
+    public event System.ComponentModel.PropertyChangedEventHandler? PropertyChanged;
+
+    public string DocumentId { get; }
+    private IndexStageKind _stage = IndexStageKind.Reading;
+    private int _completed;
+    private int _total;
+    public ObservableCollection<string> FailedSegmentIds { get; } = [];
+
+    public IndexStageKind Stage { get => _stage; private set { _stage = value; Notify(); } }
+    public int CompletedSegments { get => _completed; private set { _completed = value; Notify(); } }
+    public int TotalSegments { get => _total; private set { _total = value; Notify(); } }
+    public double ProgressFraction => TotalSegments == 0 ? 0 : (double)CompletedSegments / TotalSegments;
+    public string StageLabel => Stage switch
+    {
+        IndexStageKind.Parsing   => "Parsing source…",
+        IndexStageKind.Reading   => $"Reading evidence cards · {CompletedSegments}/{TotalSegments}",
+        IndexStageKind.Reducing  => "Building memory hierarchy…",
+        IndexStageKind.Complete  => "Ready",
+        IndexStageKind.Failed    => "Failed",
+        _ => ""
+    };
+
+    public IndexProgressViewModel(string documentId) => DocumentId = documentId;
+
+    public void Apply(IndexStageEvent ev)
+    {
+        Avalonia.Threading.Dispatcher.UIThread.Post(() =>
+        {
+            Stage = ev.Stage;
+            CompletedSegments = ev.CompletedSegments;
+            TotalSegments = ev.TotalSegments;
+            FailedSegmentIds.Clear();
+            foreach (var id in ev.FailedSegmentIds) FailedSegmentIds.Add(id);
+        });
+    }
+
+    private void Notify([System.Runtime.CompilerServices.CallerMemberName] string? n = null) =>
+        PropertyChanged?.Invoke(this, new System.ComponentModel.PropertyChangedEventArgs(n));
+}
diff --git a/docs/research/design_handoff_cf5_orcchat_library/src/ViewModels/LibraryViewModel.cs b/docs/research/design_handoff_cf5_orcchat_library/src/ViewModels/LibraryViewModel.cs
new file mode 100644
index 00000000..3da14cc9
--- /dev/null
+++ b/docs/research/design_handoff_cf5_orcchat_library/src/ViewModels/LibraryViewModel.cs
@@ -0,0 +1,103 @@
+// Copyright (C) 2025-present hardcoreerik / TheOrc contributors
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// CF-5: Observable wrapper over FabricLibraryService for the Library drawer.
+// Drop into OrchestratorIDE.Avalonia/UI/ViewModels/ (create folder if needed)
+
+using System.Collections.ObjectModel;
+using OrchestratorIDE.Services.ContextFabric;
+
+namespace OrchestratorIDE.UI.ViewModels;
+
+/// <summary>
+/// Thin observable wrapper over FabricLibraryService.
+/// Follows the same "no-MVVM-framework" pattern as the rest of the Avalonia UI:
+/// raise PropertyChanged manually; bind directly in code-behind.
+/// </summary>
+public sealed class LibraryViewModel : System.ComponentModel.INotifyPropertyChanged
+{
+    public event System.ComponentModel.PropertyChangedEventHandler? PropertyChanged;
+
+    private readonly FabricLibraryService _library;
+
+    public ObservableCollection<CorpusCardViewModel> Corpora { get; } = [];
+    public ObservableCollection<FabricSearchHit> SearchResults { get; } = [];
+
+    private string _searchQuery = "";
+    public string SearchQuery
+    {
+        get => _searchQuery;
+        set
+        {
+            if (_searchQuery == value) return;
+            _searchQuery = value;
+            OnPropertyChanged();
+            Dispatcher.UIThread.Post(RefreshSearch);
+        }
+    }
+
+    private string _storagePath = "";
+    public string StoragePath
+    {
+        get => _storagePath;
+        set { _storagePath = value; OnPropertyChanged(); }
+    }
+
+    public LibraryViewModel(FabricLibraryService library, string storagePath)
+    {
+        _library = library;
+        StoragePath = storagePath;
+        Refresh();
+    }
+
+    public void Refresh()
+    {
+        Corpora.Clear();
+        foreach (var corpus in _library.ListCorpora())
+        {
+            var docs = _library.ListDocuments(corpus.CorpusId);
+            Corpora.Add(new CorpusCardViewModel(corpus, docs));
+        }
+    }
+
+    public FabricCorpusEntry CreateCorpus(string name, string? description = null) =>
+        _library.CreateCorpus(name, description);
+
+    public async Task<FabricImportResult> ImportFileAsync(
+        string corpusId, string path, CancellationToken ct = default)
+    {
+        var result = await _library.ImportFileAsync(corpusId, path, ct: ct).ConfigureAwait(false);
+        Avalonia.Threading.Dispatcher.UIThread.Post(Refresh);
+        return result;
+    }
+
+    public bool DeleteCorpus(string corpusId)
+    {
+        var ok = _library.DeleteCorpus(corpusId);
+        if (ok) Avalonia.Threading.Dispatcher.UIThread.Post(Refresh);
+        return ok;
+    }
+
+    private void RefreshSearch()
+    {
+        SearchResults.Clear();
+        if (string.IsNullOrWhiteSpace(_searchQuery)) return;
+        foreach (var hit in _library.Search(_searchQuery, limit: 20))
+            SearchResults.Add(hit);
+    }
+
+    private void OnPropertyChanged([System.Runtime.CompilerServices.CallerMemberName] string? name = null) =>
+        PropertyChanged?.Invoke(this, new System.ComponentModel.PropertyChangedEventArgs(name));
+}
+
+public sealed class CorpusCardViewModel(
+    FabricCorpusEntry corpus,
+    IReadOnlyList<FabricDocumentEntry> documents)
+{
+    public string CorpusId => corpus.CorpusId;
+    public string Name => corpus.Name;
+    public string Description => corpus.Description ?? "";
+    public string Status => corpus.Status;   // ready | indexing | stale | failed
+    public IReadOnlyList<FabricDocumentEntry> Documents => documents;
+    public int TotalSegments => documents.Sum(d => 0); // TODO: sum from repo
+    public bool IsAttached { get; set; }
+}