Give Quick Chats a canvas of its own

The Quick Chats header row listed sessions but opened nothing — the one
sidebar row that wasn't a way somewhere. It now selects like a folder's
row does and shows the chats drawn as a canvas: ruled sheet, start
marker, a card per chat, pan and zoom, and a + where every other canvas
keeps one. An empty list gets the same "here's what this is, here's the
one thing to do about it" card a folder with no loops gets, generalised
out of CanvasEmptyState rather than copied.

Chat cards carry no loop-type stripe, no presence dot, and no edges: a
chat has no goal, no trigger, and no place in any graph, and borrowing
those channels would claim semantics it doesn't have. Every card hangs
straight off the start marker, which is what each of them is.

Selection grew a case rather than a reserved path — Quick Chats is not a
project and the daemon has never heard of it — with selectedProjectPath
kept as a facade over it so every project-only caller is untouched. The
rename prompt and delete confirmation moved out of the sidebar's local
state into the reducer, hosted once by AppView, now that either can be
started from a sidebar row or from a card and only one of the two
surfaces is ever on screen.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: scgopi

graphcode/Sources/Features/App/AppFeature+QuickChats.swift

@@ -0,0 +1,120 @@
+import ComposableArchitecture
+import Foundation
+import GraphcodeKit
+
+/// The Quick Chats section of the root feature — the sidebar rows, the canvas
+/// (`QuickChatsCanvasView`), and the rename/delete prompts `AppView` hosts for both.
+///
+/// Split out of `AppFeature` rather than nested in its switch because chats share none of
+/// that reducer's subject matter: no project, no graph, no daemon. What they *do* share is
+/// state — a chat's workspace is the same `openLoop` a loop's is, and closing one falls
+/// back to the same `detailSelection` — so this stays a slice of the root reducer over the
+/// same `State` and `Action` instead of becoming a feature with a store of its own.
+extension AppFeature {
+  var quickChatsReducer: some ReducerOf<Self> {
+    Reduce { state, action in
+      switch action {
+      case .newQuickChatTapped:
+        let chat = QuickChat(
+          title: "Chat — \(Date().formatted(.dateTime.month(.abbreviated).day()))",
+          backend: GraphcodeSettingsStore.load().defaultBackend)
+        state.quickChats.append(chat)
+        quickChatStore.save(Array(state.quickChats))
+        openQuickChat(chat, &state)
+        return .none
+
+      case .quickChatsTapped:
+        state.detailSelection = .quickChats
+        state.openLoop = nil
+        return .none
+
+      case .quickChatTapped(let id):
+        guard let chat = state.quickChats[id: id] else { return .none }
+        guard state.openLoop?.node.id != id else { return .none }
+        openQuickChat(chat, &state)
+        return .none
+
+      case .quickChatRenameRequested(let id):
+        guard let chat = state.quickChats[id: id] else { return .none }
+        state.chatPendingRename = id
+        // The field opens on the title it has: a rename is an edit, not a re-entry.
+        state.draftChatTitle = chat.title
+        return .none
+
+      case .quickChatRenameTitleChanged(let title):
+        state.draftChatTitle = title
+        return .none
+
+      case .quickChatRenameCancelled:
+        state.chatPendingRename = nil
+        return .none
+
+      case .quickChatRenameConfirmed:
+        let trimmed = state.draftChatTitle.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let id = state.chatPendingRename else { return .none }
+        state.chatPendingRename = nil
+        guard !trimmed.isEmpty, state.quickChats[id: id] != nil else { return .none }
+        state.quickChats[id: id]?.title = trimmed
+        quickChatStore.save(Array(state.quickChats))
+        // The open workspace carries a synthetic copy of this chat, so its header would
+        // otherwise keep the old name until the chat was reopened.
+        if state.openLoop?.node.id == id {
+          state.openLoop?.node.title = trimmed
+        }
+        return .none
+
+      case .quickChatDeleteRequested(let id):
+        guard state.quickChats[id: id] != nil else { return .none }
+        state.chatPendingDeletion = id
+        return .none
+
+      case .quickChatDeleteCancelled:
+        state.chatPendingDeletion = nil
+        return .none
+
+      case .quickChatDeleteConfirmed:
+        guard let id = state.chatPendingDeletion else { return .none }
+        state.chatPendingDeletion = nil
+        guard state.quickChats[id: id] != nil else { return .none }
+        state.quickChats.remove(id: id)
+        quickChatStore.save(Array(state.quickChats))
+        if state.openLoop?.node.id == id {
+          closeOpenWorkspace(&state)
+          // Back to the chats' own canvas rather than to some folder: the chat that was
+          // on screen is gone, but what you were doing was chatting.
+          state.detailSelection = .quickChats
+        }
+        // The chat's session is app-owned — no daemon cleans it up the way GraphStore
+        // does for a deleted loop, so its zmx session is killed here.
+        return .run { _ in await ZmxSessionLauncher.killSession(id: id) }
+
+      default:
+        return .none
+      }
+    }
+  }
+
+  /// Opens a chat in the same terminal workspace a loop gets, via a synthetic node.
+  /// `.proactive` is the one loop type whose `sessionPrompt` is nil, which is exactly
+  /// what a chat wants: the backend starts bare, with nothing pre-typed into it. The
+  /// node's id is the chat's, so the workspace attaches to the chat's own long-lived
+  /// zmx session, scrollback and all. Home as the working directory — a chat belongs
+  /// to no project on purpose.
+  private func openQuickChat(_ chat: QuickChat, _ state: inout State) {
+    let node = LoopNode(
+      id: chat.id,
+      title: chat.title,
+      loopType: .proactive,
+      backend: chat.backend,
+      createdAt: chat.createdAt)
+    let layout = terminalLayoutStore.load(forNode: chat.id) ?? .defaultLayout(forNode: chat.id)
+    state.openLoop = LoopWorkspaceFeature.State(
+      node: node,
+      layout: layout,
+      projectPath: NSHomeDirectory(),
+      projectName: "Quick Chat")
+    // Quick Chats is what this workspace came from, so it's what closing it falls back
+    // to — the same rule a loop follows with its folder.
+    state.detailSelection = .quickChats
+  }
+}

graphcode/Sources/Features/App/AppFeature.swift

@@ -13,17 +13,41 @@ import GraphcodeKit
 /// project's canvas is the fallback" can live inside any one `ProjectFeature.State`.
 /// They live here instead: `openLoop` (at most one loop's whole terminal
 /// workspace — tabs and splits, see `LoopWorkspaceFeature` — is open at a time, the way
-/// a supacode worktree owns its own terminal area) and `selectedProjectPath` (which
-/// project's canvas is the fallback when no loop is open).
+/// a supacode worktree owns its own terminal area) and `detailSelection` (which canvas —
+/// a folder's, or Quick Chats' — is the fallback when no loop is open).
 @Reducer
 struct AppFeature {
+  /// Which canvas the detail pane falls back to when no loop's workspace is open.
+  ///
+  /// Quick Chats is a case rather than a reserved path because it is not a project and
+  /// has no graph the daemon knows about — it's the app's own surface, drawn like a
+  /// folder's canvas (see `QuickChatsCanvasView`) because that's what it is to a human:
+  /// another place sessions live.
+  enum DetailSelection: Equatable {
+    case project(String)
+    case quickChats
+  }
+
   @ObservableState
   struct State: Equatable {
     var welcome = WelcomeFeature.State()
     var projects: IdentifiedArrayOf<ProjectFeature.State> = []
-    var selectedProjectPath: String?
     var openLoop: LoopWorkspaceFeature.State?
 
+    var detailSelection: DetailSelection?
+
+    /// The selected *folder*, when the selection is one. Every caller that only ever
+    /// deals in projects — opening one, closing one, following a node tap — keeps
+    /// reading and writing selection through this; `nil` now also covers "Quick Chats",
+    /// which no folder path could ever name.
+    var selectedProjectPath: String? {
+      get {
+        if case .project(let path) = detailSelection { return path }
+        return nil
+      }
+      set { detailSelection = newValue.map(DetailSelection.project) }
+    }
+
     /// Ad-hoc backend sessions with no loop semantics — the sidebar's Quick Chats
     /// section. App-local (see `QuickChat`); loaded once at `.task` and saved on every
     /// mutation. A chat's workspace is opened through the same `openLoop` as a loop's,
@@ -33,6 +57,20 @@ struct AppFeature {
     /// Whether the open workspace is a quick chat rather than a graph node's loop.
     func isQuickChat(_ nodeID: UUID) -> Bool { quickChats[id: nodeID] != nil }
 
+    /// The chat a rename prompt is up for, plus what has been typed so far, and the chat
+    /// a delete confirmation is up for.
+    ///
+    /// In the reducer rather than in a view's `@State` for the same reason
+    /// `pendingLoopRename` is: both the sidebar and the Quick Chats canvas start these
+    /// verbs, only one of the two is on screen at any moment, and the dialogs are hosted
+    /// once — by `AppView` — so neither surface can present a version of its own.
+    var chatPendingRename: UUID?
+    var draftChatTitle = ""
+    var chatPendingDeletion: UUID?
+
+    var pendingChatRename: QuickChat? { chatPendingRename.flatMap { quickChats[id: $0] } }
+    var pendingChatDeletion: QuickChat? { chatPendingDeletion.flatMap { quickChats[id: $0] } }
+
     /// Up on first launch (`.task` checks the persisted flag) and whenever the
     /// sidebar's help button asks for it again.
     var showingOnboarding = false
@@ -119,9 +157,19 @@ struct AppFeature {
     case onboardingDismissed
     /// The Quick Chats section's actions — see `State.quickChats`.
     case newQuickChatTapped
+    /// The Quick Chats header row: shows the chats' own canvas, the way a folder row
+    /// shows that folder's.
+    case quickChatsTapped
     case quickChatTapped(UUID)
-    case quickChatRenamed(id: UUID, title: String)
-    case quickChatDeleteConfirmed(UUID)
+    /// Rename and delete, each startable from the sidebar row *or* the canvas card —
+    /// which is why the prompt they raise lives in state; see `State.chatPendingRename`.
+    case quickChatRenameRequested(UUID)
+    case quickChatRenameTitleChanged(String)
+    case quickChatRenameConfirmed
+    case quickChatRenameCancelled
+    case quickChatDeleteRequested(UUID)
+    case quickChatDeleteConfirmed
+    case quickChatDeleteCancelled
   }
 
   private enum CancelID { case daemonSubscription }
@@ -139,6 +187,10 @@ struct AppFeature {
     Scope(state: \.welcome, action: \.welcome) {
       WelcomeFeature()
     }
+    // The Quick Chats section, in `AppFeature+QuickChats.swift` — the same state and
+    // actions, kept in one place of its own because chats are a whole surface (a sidebar
+    // section, a canvas, and two dialogs) that has nothing to do with projects or graphs.
+    quickChatsReducer
     Reduce { state, action in
       switch action {
       case .task:
@@ -313,43 +365,15 @@ struct AppFeature {
         UserDefaults.standard.set(true, forKey: "hasSeenOnboarding")
         return .none
 
-      case .newQuickChatTapped:
-        let chat = QuickChat(
-          title: "Chat — \(Date().formatted(.dateTime.month(.abbreviated).day()))",
-          backend: GraphcodeSettingsStore.load().defaultBackend)
-        state.quickChats.append(chat)
-        quickChatStore.save(Array(state.quickChats))
-        openQuickChat(chat, &state)
+      // Every Quick Chats action is handled by `quickChatsReducer`, in
+      // `AppFeature+QuickChats.swift` — listed here only so this switch stays exhaustive
+      // and a new action can't be added without deciding which of the two answers it.
+      case .newQuickChatTapped, .quickChatsTapped, .quickChatTapped,
+        .quickChatRenameRequested, .quickChatRenameTitleChanged, .quickChatRenameConfirmed,
+        .quickChatRenameCancelled, .quickChatDeleteRequested, .quickChatDeleteConfirmed,
+        .quickChatDeleteCancelled:
         return .none
 
-      case .quickChatTapped(let id):
-        guard let chat = state.quickChats[id: id] else { return .none }
-        guard state.openLoop?.node.id != id else { return .none }
-        openQuickChat(chat, &state)
-        return .none
-
-      case .quickChatRenamed(let id, let title):
-        let trimmed = title.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !trimmed.isEmpty, state.quickChats[id: id] != nil else { return .none }
-        state.quickChats[id: id]?.title = trimmed
-        quickChatStore.save(Array(state.quickChats))
-        if state.openLoop?.node.id == id {
-          state.openLoop?.node.title = trimmed
-        }
-        return .none
-
-      case .quickChatDeleteConfirmed(let id):
-        guard state.quickChats[id: id] != nil else { return .none }
-        state.quickChats.remove(id: id)
-        quickChatStore.save(Array(state.quickChats))
-        if state.openLoop?.node.id == id {
-          closeOpenWorkspace(&state)
-          state.selectedProjectPath = state.projects.first?.id
-        }
-        // The chat's session is app-owned — no daemon cleans it up the way GraphStore
-        // does for a deleted loop, so its zmx session is killed here.
-        return .run { _ in await ZmxSessionLauncher.killSession(id: id) }
-
       // When creating a new loop while another loop's workspace is open, inherit that
       // loop's backend. Matches `parentBackend: nil` only — the re-sent action carries
       // a value, so it falls through instead of looping.
@@ -442,35 +466,14 @@ struct AppFeature {
   private func isGlobal(_ path: String) -> Bool { path == LoopGraphScope.globalPath }
 
   /// Closes the open workspace *and ends its terminals* — for when the loop itself is
-  /// gone, as opposed to merely not being the one on screen any more.
-  private func closeOpenWorkspace(_ state: inout State) {
+  /// gone, as opposed to merely not being the one on screen any more. Not `private`
+  /// because a deleted chat needs the same treatment and lives in the other file.
+  func closeOpenWorkspace(_ state: inout State) {
     guard let openLoop = state.openLoop else { return }
     terminalSurfaceClient.retire(openLoop.layout.tabs.flatMap { $0.surfaces.map(\.id) })
     state.openLoop = nil
   }
 
-  /// Opens a chat in the same terminal workspace a loop gets, via a synthetic node.
-  /// `.proactive` is the one loop type whose `sessionPrompt` is nil, which is exactly
-  /// what a chat wants: the backend starts bare, with nothing pre-typed into it. The
-  /// node's id is the chat's, so the workspace attaches to the chat's own long-lived
-  /// zmx session, scrollback and all. Home as the working directory — a chat belongs
-  /// to no project on purpose.
-  private func openQuickChat(_ chat: QuickChat, _ state: inout State) {
-    let node = LoopNode(
-      id: chat.id,
-      title: chat.title,
-      loopType: .proactive,
-      backend: chat.backend,
-      createdAt: chat.createdAt)
-    let layout = terminalLayoutStore.load(forNode: chat.id) ?? .defaultLayout(forNode: chat.id)
-    state.openLoop = LoopWorkspaceFeature.State(
-      node: node,
-      layout: layout,
-      projectPath: NSHomeDirectory(),
-      projectName: "Quick Chat")
-    state.selectedProjectPath = nil
-  }
-
   /// The nearest project on the given side of `index` that lives in the same sidebar
   /// section — local folders and remote repositories are separate sections, and a move
   /// must not carry a project across the divider. `nil` when there's nothing of its