Native chat redesign: hero empty-state + elevated composer + Ask/Plan/Build modes

HANDOFF.md

@@ -0,0 +1,38 @@
+# HANDOFF — feat/chat-redesign (Task 1: chat)
+
+_Last updated: Jul 28 2026, end of session. Tip `1447f62`._
+
+## Status
+- **Branch `feat/chat-redesign` (PR #39) — OPEN, HELD. Do NOT merge to `main` without the founder's explicit go.** GitHub reports CLEAN / MERGEABLE (main not diverged), 64 commits today.
+- PR **#37** (chat-first shell) and **#40** (Firebase test-host flake fix) already **merged to main**.
+- **Chat UI/UX workstream = 16/16 Done** on the W1 board (page `3aa3af4aaa9281b1bc09d051a59b0ca6`). "Done" = work-complete + founder-verified; still branch-held (Done-on-board ≠ merged).
+- **AI is DOWN** — no Anthropic credits/key. Use the **mock** for any front-end display (below).
+
+## What's built on this branch
+Redesign (un-bubbled messages + thumbs, one card grammar, luminous orb, dept chips, live empty-state) · **streaming execute-log** · **dept→companion handoff** (specialists appear as pet sprites) · **thread header** (dropdown switcher + Share=copy transcript) · **dark mode** (Light/Dark toggle works via `NSApp.appearance`; `onAccent` text) · **responsive** column (760 + 24pt gutter, shrink-to-fit) · **chat persistence** (Firestore `companies/{uid}/threads/{id}`, survives restart) · **DEBUG mock harness**.
+
+## Run it (mock, no key needed)
+```
+# build TEAM-SIGNED, signed build LAST (tests clobber signing), then verify:
+xcodebuild build -project CodePet.xcodeproj -scheme codepet -destination 'platform=macOS' \
+  -allowProvisioningUpdates CODE_SIGN_STYLE=Automatic DEVELOPMENT_TEAM=YL72VTKBR7 "CODE_SIGN_IDENTITY=Apple Development"
+codesign -dv <app> 2>&1 | grep TeamIdentifier   # MUST be YL72VTKBR7 (not adhoc — else Firebase keychain breaks)
+# launch with the offline mock ON:
+open -n <app> --args -CODEPET_MOCK_CHAT YES
+```
+Mock is keyword-routed: any question → advisor reply; `run my first task` → execute-log → tailored draft (positioning / landing copy / waitlist / pricing / interview); `remember…` → Noted chip; `connect…` → enable card; `roadmap`/dept chip → nav/handoff. Seed the board via **Roadmap** first if "no task to run".
+
+## Gotchas
+- `xcodebuild test … CODE_SIGNING_ALLOWED=NO` rebuilds the app **ad-hoc** into the same DerivedData → breaks Firebase keychain on launch. Always: tests first, **signed build last**, verify TeamIdentifier, then launch.
+- Canonical work checkout drifted to `~/Developer/codepet` (iCloud evicted ~/Documents & ~/Desktop repos; `~/codepet-chat` is behind origin). Prefer a fresh non-iCloud checkout of `feat/chat-redesign`.
+- **Two parallel sessions** run — own branch, own worktree, serialized app testing (one launches at a time). See memory `codepet-parallel-session-protocol`.
+
+## Next candidates (not started)
+Message-cap per thread · search Recent · clear-all-history. Add a W1 board row before building (the board is the source of truth).
+
+## Resume-last-thread on launch (built, unverified in-app)
+Launch now reopens the newest thread when it was touched inside `threadResumeWindow` (**8h**), else opens the live hero — founder's call, so a new day still starts on the time-of-day greeting + roadmap cards. Pure `pickResumeThreadId(in:now:within:)` in `ChatThreads.swift`, called from `CompanyStore.hydrate`. Two adjacent fixes came with it: the transcript now pins to its newest message when it arrives already-populated (resume, or switching into an existing thread — it used to open at the OLDEST message, since it only scrolled on a message-COUNT change), and the enrichment interview survives a relaunch (`interviewState` is session-only, so answering a resumed question used to save the answer and then go silent; `EnrichInterview.remainingGaps` rebuilds the cursor from the brief minus what the transcript already answered, so a skip stays skipped). 10 new tests. **Not yet exercised in the running app** — needs a signed build + a real quit/relaunch inside the window.
+
+DEBUG-only `-CODEPET_RESUME_WINDOW_SECONDS <n>` (same idiom as `-CODEPET_MOCK_CHAT`, only a POSITIVE value counts) shrinks the window so the stale branch is testable in seconds instead of eight hours. Driver script: `~/Developer/codepet-test-resume.sh` — `launch` / `relaunch` (the quit→resume loop, graceful quit so pending thread writes aren't cut off) / `stale` / `lock`.
+
+**Test-suite gotcha found this session:** any running `codepet.app` holds `~/Library/Application Support/firestore/__FIRAPP_DEFAULT/devpet-8f4b1/main/LOCK`, and a second process that initializes Firestore aborts in `FirestoreClient::Initialize` (SIGABRT). That is the "Firebase test-host flake" — every test class that builds a `CompanyStore` with the DEFAULT `threadsLoader` dies, 0 tests executed, while classes injecting fakes pass. Close the app before `xcodebuild test`.

codepet/App/CodePetApp.swift

@@ -1,4 +1,5 @@
 import SwiftUI
+import AppKit
 import FirebaseCore
 import GoogleSignIn
 
@@ -42,9 +43,28 @@ struct CodePetApp: App {
         _chatController = StateObject(wrappedValue: chatController)
     }
 
+    /// Force the app's effective appearance so the CodepetTheme dyn NSColor tokens
+    /// re-resolve on a Light/Dark pick. `.system` → nil (follow macOS).
+    private static func applyAppearance(_ theme: AppTheme) {
+        switch theme {
+        case .system: NSApplication.shared.appearance = nil
+        case .light:  NSApplication.shared.appearance = NSAppearance(named: .aqua)
+        case .dark:   NSApplication.shared.appearance = NSAppearance(named: .darkAqua)
+        }
+    }
+
     var body: some Scene {
         WindowGroup {
-            ContentView()
+            Group {
+#if DEBUG
+                // Dev-only: `-CODEPET_MOCK_GALLERY YES` swaps the root for the
+                // chat-mocks gallery so the scenario mockups are viewable in a
+                // running build (see ChatMocksGalleryView).
+                if MockGallery.enabled { ChatMocksGalleryView() } else { ContentView() }
+#else
+                ContentView()
+#endif
+            }
                 .environment(\.font, CodepetTheme.body(13))
                 .environment(\.uiLanguage, appState.uiLanguage)
                 .environmentObject(appState)
@@ -73,9 +93,20 @@ struct CodePetApp: App {
                 .environmentObject(learnProgress)
                 .environmentObject(challengeProgress)
                 .environmentObject(feedbackManager)
-                .frame(minWidth: 400, minHeight: 700)
+                // 560 = the onboarding card's real floor: a 320pt clamped art panel
+                // (OnboardingLayout.artWidth) + the form's 64pt horizontal padding either
+                // side + room for the 600pt measure to compress into. At 400 the form
+                // panel was driven to a negative width and the layout clipped.
+                .frame(minWidth: 560, minHeight: 700)
                 .themed(isDark: appState.appTheme == .dark)
                 .preferredColorScheme(appState.appTheme.colorScheme)
+                // preferredColorScheme drives SwiftUI-native colors, but the
+                // CodepetTheme.dyn tokens resolve via dynamic NSColor keyed on the
+                // app's EFFECTIVE appearance — which preferredColorScheme does NOT
+                // force. So a Light/Dark pick would leave the tokens on the system
+                // appearance. Force NSApp.appearance to make every dyn token flip.
+                .onChange(of: appState.appTheme) { _, theme in Self.applyAppearance(theme) }
+                .onAppear { Self.applyAppearance(appState.appTheme) }
                 .task {
                     projectStore.load()
                     TipsPersistence.shared.load(into: tipsState)

codepet/Managers/ChatThreads.swift

@@ -1,19 +1,29 @@
 // codepet/Managers/ChatThreads.swift
 import Foundation
 
-/// One session-only chat conversation — a named bucket of `CopilotMessage`s.
-/// Deliberately NOT Codable: Level 1 multi-thread history is in-memory only,
-/// same as `chatMessages` itself (see `CopilotMessage`'s doc comment). Native
-/// port of the web `ThreadMeta` (`lib/firebase/schema.ts`) + its message array,
-/// merged into one struct since there's no persistence layer to split them.
-struct ChatThread: Identifiable, Equatable {
+/// One chat conversation — a named bucket of `CopilotMessage`s. Codable so a
+/// thread can be persisted to `companies/{uid}/threads/{id}` and hydrated on
+/// launch. Native port of the web `ThreadMeta` (`lib/firebase/schema.ts`) + its
+/// message array, merged into one struct.
+struct ChatThread: Identifiable, Equatable, Codable {
     let id: String
     /// nil until the founder's first message derives one (or a rename sets a
     /// non-blank title) — rendered as "New chat" by the view, mirrors the web.
     var title: String?
     var messages: [CopilotMessage]
     let createdAt: Date
     var updatedAt: Date
+
+    /// A copy safe to PERSIST: drops transient "producing" placeholders (they
+    /// exist only mid-run) and clears streaming-only `execSteps`, so a saved
+    /// thread never resurrects a half-finished run on the next launch.
+    var persistable: ChatThread {
+        var copy = self
+        copy.messages = messages
+            .filter { !$0.producing }
+            .map { m in var mm = m; mm.execSteps = nil; return mm }
+        return copy
+    }
 }
 
 // Pure, unit-testable helpers behind the thread switcher — ported from the
@@ -30,7 +40,12 @@ private let threadTitleMax = 40
 /// ellipsis. Returns nil when there is no `.me` message yet, OR its text is
 /// blank — the view falls back to "New chat" for either case, same as the web.
 func deriveThreadTitle(_ messages: [CopilotMessage]) -> String? {
-    guard let first = messages.first(where: { $0.role == .me }) else { return nil }
+    // Prefer the founder's first message; fall back to the first non-empty
+    // message of ANY role so a thread that so far only holds byte's seeded
+    // question/greeting still gets a distinguishable name instead of "New chat".
+    let source = messages.first(where: { $0.role == .me && !$0.text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty })
+        ?? messages.first(where: { !$0.text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty })
+    guard let first = source else { return nil }
     let collapsed = first.text.replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression)
         .trimmingCharacters(in: .whitespacesAndNewlines)
     guard !collapsed.isEmpty else { return nil }
@@ -52,6 +67,28 @@ func pickFallbackThreadId(after deletedId: String, in threads: [ChatThread]) ->
     sortThreadsByRecent(threads.filter { $0.id != deletedId }).first?.id
 }
 
+/// How long after its last message a thread still counts as the founder's
+/// current working stretch. Inside it, launch resumes that thread; outside it,
+/// launch opens the live hero instead — so quitting and reopening keeps your
+/// place, while a new day still starts on the time-of-day greeting and the
+/// roadmap landing cards. One constant to tune.
+let threadResumeWindow: TimeInterval = 8 * 3600
+
+/// Which thread launch should reopen, or nil to land on the empty hero. The
+/// newest thread that actually holds messages, provided it was touched within
+/// `window`. `now` is a parameter (not `Date()` inside) for testability, same as
+/// `relativeTime`. A future-dated `updatedAt` (clock skew from another device)
+/// counts as recent rather than stale.
+///
+/// Order-agnostic: callers may pass threads in any order (a Firestore query's
+/// ordering isn't guaranteed to survive a decode-and-filter pass), so this sorts
+/// before picking rather than trusting the input.
+func pickResumeThreadId(in threads: [ChatThread], now: Date, within window: TimeInterval = threadResumeWindow) -> String? {
+    guard let newest = sortThreadsByRecent(threads).first(where: { !$0.messages.isEmpty }) else { return nil }
+    guard now.timeIntervalSince(newest.updatedAt) <= window else { return nil }
+    return newest.id
+}
+
 /// Compact relative time for the history list — "just now" under a minute,
 /// then minutes/hours/days. English only (the pure helper stays language-
 /// neutral like the rest of `ChatThreads`; the view localizes surrounding