feat(panel): drop/paste add-repo flow + empty state UI (v0.1.1 prep 5/6)

Closes the loop for the "no IDE recents, no git config hints, repo at
some arbitrary path" case. Instead of dropping the user on a blank
"Scanning…" screen, the panel becomes a first-class drop target. Once
at least one repo is known, the same flow lives as a subtle footer
hint that doesn't fight for real estate with the timeline.

Backend:

* discovery_orchestrator::add_repo_explicit — validates with
  Repository::discover (so dropping a subdirectory of a repo also
  works), upserts with primary_source='manual', confidence=100, and
  promotes user_state to 'pinned' so the row survives at the top of
  paint order. Removes the path from discovery_tombstones if it was
  previously hidden — the user is explicitly asking for it back.
  Learns parent + grandparent roots (the same logic the prewarm
  task uses) so siblings get found on the next scan. Emits
  `timeline://repo-discovered` so the existing listener appends the
  row immediately.
* commands::explicit_add_repo — Tauri command wrapping the above;
  validation failure surfaces as "Not a Git working tree" to the
  frontend instead of a stack trace.

Frontend:

* Tauri `tauri://drag-drop` listener at window level — accepts every
  path in a multi-file drop and tries to add each one. Lives next to
  the existing window pointer-down drag handler.
* Document-level `paste` listener with two guards: target must NOT be
  an input/textarea/contenteditable (so chip search inputs keep
  working), AND the clipboard text must look like a path (drive
  letter, leading /, or leading ~). Anything else is ignored —
  paste of random text never accidentally tries to add a repo.
* `addError` state shows the backend's error string ("Not a Git
  working tree" etc) inline. Auto-clears after 4s so a one-off typo
  doesn't linger.
* `EmptyDropPanel` component for the cold-start state: big dashed
  drop target, paste hint, scanning indicator only when relevant.
* `.panel-footer-hint` strip for the warm state — small "Drop or
  paste a repo folder to add it" text below the timeline. Surfaces
  add errors too so the user notices them whether the panel is
  empty or full.

Dark-mode CSS for both the empty panel and the footer hint.

Also cleaned up two intentional-dead-code warnings on
`GitConfigHint::RootPattern` and `DiscoverySource::{GitConfigIncludeIf,
Watcher}` — collected for Phase 2 expansion, not used yet, marked with
`#[allow(dead_code)]` and a comment explaining why.

Rust tests 34/34, TS type-check clean.

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

Author: var-gg

src-tauri/src/commands.rs

@@ -4,7 +4,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use serde::Serialize;
 use tauri::{AppHandle, Emitter, Manager};
 
-use crate::{cache, discovery, git, settings, watcher};
+use crate::{cache, discovery, discovery_orchestrator, git, settings, watcher};
 
 const MAX_COMMITS_PER_REPO: usize = 10;
 const MAX_COMMITS_PER_REPO_NO_WINDOW: usize = 1_000;
@@ -157,6 +157,26 @@ pub async fn current_upstream_status(
     .map_err(|e| e.to_string())?
 }
 
+/// Add a repo by path (drag-drop / paste). Wraps
+/// discovery_orchestrator::add_repo_explicit and turns the
+/// validation/Repository::discover error into a frontend-friendly
+/// "Not a Git working tree" string. On success the orchestrator has
+/// already emitted `timeline://repo-discovered` — we return the same
+/// payload so the caller can also handle it synchronously.
+#[tauri::command]
+pub async fn explicit_add_repo(
+    app: AppHandle,
+    path: String,
+) -> Result<discovery_orchestrator::DiscoveredRepoPayload, String> {
+    let app2 = app.clone();
+    tauri::async_runtime::spawn_blocking(move || {
+        discovery_orchestrator::add_repo_explicit(&app2, &path)
+            .map_err(|e| e.to_string())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
 #[tauri::command]
 pub async fn changed_files(
     repo_path: String,

src-tauri/src/discovery_orchestrator.rs

@@ -116,6 +116,74 @@ pub fn start(app: AppHandle) -> OrchestratorHandle {
     OrchestratorHandle { cancel }
 }
 
+/// Manually add a repo by path (drag-drop / paste / future file picker).
+/// Validates with git2 (will walk up if the user dropped a subdirectory
+/// of a repo), upserts with primary_source='manual' + user_state='pinned'
+/// + confidence 100 so it stays at the top of the paint order, learns
+/// parent roots, and emits `timeline://repo-discovered` so the frontend
+/// can append a row immediately.
+///
+/// Returns the discovered repo payload on success, or an error string
+/// the frontend can surface inline (e.g. "Not a Git working tree").
+pub fn add_repo_explicit(app: &AppHandle, raw_path: &str) -> Result<DiscoveredRepoPayload> {
+    let path = PathBuf::from(raw_path.trim());
+    if path.as_os_str().is_empty() {
+        return Err(anyhow::anyhow!("empty path"));
+    }
+    let validated = validate_repo_candidate(&path)
+        .ok_or_else(|| anyhow::anyhow!("Not a Git working tree"))?;
+
+    let mut conn = cache::open(app)?;
+    let candidate = Candidate {
+        path: PathBuf::from(&validated.canonical_path),
+        source: DiscoverySource::Manual,
+        confidence: 100,
+        raw_hint: Some(format!("manual:{raw_path}")),
+    };
+    let now = unix_now();
+    {
+        let tx = conn.transaction()?;
+        upsert_discovered_repo(&tx, &validated, &candidate, now)?;
+        // Manual add overrides any pre-existing 'normal' user_state and
+        // promotes the repo to 'pinned' so it survives a tombstone-style
+        // wipe and stays at the top of paint order.
+        tx.execute(
+            "UPDATE repos SET user_state = 'pinned' WHERE canonical_path = ?1",
+            params![&validated.canonical_path],
+        )?;
+        record_repo_source(&tx, &validated, &candidate, now)?;
+        record_path_alias(&tx, &validated, &candidate, now)?;
+        for learned in learn_roots_from_repo(&validated, DiscoverySource::Manual) {
+            upsert_discovery_root(&tx, &learned, &validated.canonical_path, now)?;
+        }
+        // Manual-added paths shouldn't stay on the tombstone list — the
+        // user explicitly asked for them back.
+        tx.execute(
+            "DELETE FROM discovery_tombstones WHERE canonical_path = ?1",
+            params![&validated.canonical_path],
+        )?;
+        tx.commit()?;
+    }
+
+    let payload = DiscoveredRepoPayload {
+        path: validated.canonical_path.clone(),
+        name: validated.name.clone(),
+        source: DiscoverySource::Manual.as_str(),
+        confidence: 100,
+    };
+    let _ = app.emit("timeline://repo-discovered", &payload);
+
+    let _ = append_scan_log(
+        app,
+        &format!(
+            "{} manual_add: path={} name={}",
+            now, validated.canonical_path, validated.name
+        ),
+    );
+
+    Ok(payload)
+}
+
 async fn run_discovery_async(app: AppHandle, cancel: CancellationToken) -> Result<()> {
     let app_for_blocking = app.clone();
     let cancel_for_blocking = cancel.clone();

src-tauri/src/discovery_sources.rs

@@ -42,10 +42,15 @@ pub enum DiscoverySource {
     /// git config `safe.directory`.
     GitConfigSafe,
     /// git config `includeIf.gitdir:<pattern>` — root hint, not repo.
+    /// Collected for Phase 2 root expansion.
+    #[allow(dead_code)]
     GitConfigIncludeIf,
     /// Filesystem walk (Tier 5).
     FsWalk,
-    /// File watcher saw a `.git` directory appear.
+    /// File watcher saw a `.git` directory appear. Hooked up in commit 6
+    /// when the existing watcher promotes its events into orchestrator
+    /// candidates.
+    #[allow(dead_code)]
     Watcher,
 }
 
@@ -408,6 +413,9 @@ pub fn expand_code_workspace(workspace_file: &Path) -> Vec<Candidate> {
 #[derive(Debug, Clone)]
 pub enum GitConfigHint {
     RepoPath(PathBuf),
+    /// `includeIf "gitdir:<pat>"` pattern — collected for future
+    /// Tier 4 expansion (Phase 2). v0.1.1 only acts on RepoPath.
+    #[allow(dead_code)]
     RootPattern(String),
 }
 

src-tauri/src/lib.rs

@@ -256,6 +256,7 @@ pub fn run() {
             commands::recent_commits,
             commands::list_branches,
             commands::current_upstream_status,
+            commands::explicit_add_repo,
             commands::repo_commits,
             commands::changed_files,
             commands::file_diff,

src/App.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import type { UnlistenFn } from "@tauri-apps/api/event";
 
@@ -10,6 +10,7 @@ import { TimeRangeChip } from "./components/TimeRangeChip";
 import {
   currentUpstreamStatus,
   dismissPanel,
+  explicitAddRepo,
   getPinnedRepos,
   listBranches,
   listRecentCommitsCached,
@@ -145,6 +146,10 @@ function App() {
     "repo" | "time" | "authors" | "branch" | null
   >(null);
 
+  // Drop/paste add-repo flow: inline feedback only, no modal.
+  // `addError` clears itself after 4s so a typo'd path doesn't linger.
+  const [addError, setAddError] = useState<string | null>(null);
+
   const singleMode = selectedRepoPath != null;
 
   // Mirror selectedRepoPath into a ref so the file-watcher listener — set up
@@ -360,6 +365,76 @@ function App() {
     };
   }, [singleMode, selectedRepoPath, selectedBranches, windowDays]);
 
+  // Manual add via drag-drop / paste. Returns whether the add succeeded
+  // so the paste handler can clear the clipboard string only on success.
+  // On failure, sets addError to the backend's message ("Not a Git
+  // working tree" etc) for inline display.
+  const tryAddPath = useCallback(async (rawPath: string): Promise<boolean> => {
+    const trimmed = rawPath.trim();
+    if (!trimmed) return false;
+    try {
+      await explicitAddRepo(trimmed);
+      setAddError(null);
+      return true;
+    } catch (err) {
+      setAddError(
+        typeof err === "string"
+          ? err
+          : err instanceof Error
+            ? err.message
+            : "Failed to add repo",
+      );
+      window.setTimeout(() => setAddError(null), 4000);
+      return false;
+    }
+  }, []);
+
+  // Tauri drag-drop. Fires on this window's drop zone (the whole panel).
+  // We listen for the "drop" variant only — "hover"/"cancel" are just
+  // visual cues we'd opt into later. Multi-file drops add each in turn.
+  useEffect(() => {
+    let un: UnlistenFn | undefined;
+    (async () => {
+      type DragDrop = { type: string; paths?: string[] };
+      un = await getCurrentWindow().listen<DragDrop>("tauri://drag-drop", (e) => {
+        if (e.payload.type !== "drop") return;
+        const paths = e.payload.paths ?? [];
+        for (const p of paths) {
+          void tryAddPath(p);
+        }
+      });
+    })();
+    return () => un?.();
+  }, [tryAddPath]);
+
+  // Paste: only act when the user has clearly pasted a path (starts with
+  // a drive letter, slash, or tilde) AND isn't typing into an input/
+  // textarea/contenteditable. This way chip search inputs keep working
+  // normally — paste only adds repos when there's no other use for it.
+  useEffect(() => {
+    function onPaste(e: ClipboardEvent) {
+      const target = e.target as HTMLElement | null;
+      if (target) {
+        const tag = target.tagName;
+        if (
+          tag === "INPUT" ||
+          tag === "TEXTAREA" ||
+          target.getAttribute("contenteditable") === "true"
+        ) {
+          return;
+        }
+      }
+      const text = e.clipboardData?.getData("text/plain")?.trim() ?? "";
+      if (!text) return;
+      // Heuristic: looks like a Windows drive, POSIX absolute, or home-rel path.
+      if (!/^([a-zA-Z]:[\\\/]|\/|~[\\\/])/.test(text)) return;
+      e.preventDefault();
+      void tryAddPath(text);
+    }
+    window.addEventListener("paste", onPaste);
+    return () => window.removeEventListener("paste", onPaste);
+  }, [tryAddPath]);
+
   // Clear fresh-commit markers whenever the panel loses focus (= the user
   // has "seen" what was new). They re-populate as new commits arrive.
   useEffect(() => {
@@ -503,6 +578,8 @@ function App() {
       <section className="panel-body">
         {filteredCommits == null ? (
           <p className="panel-empty">Loading commits…</p>
+        ) : allRepos.length === 0 && !singleMode ? (
+          <EmptyDropPanel scanning={scanning} addError={addError} />
         ) : (
           <Timeline
             key={singleMode ? `single:${selectedRepoPath}` : "all"}
@@ -513,9 +590,41 @@ function App() {
             freshHashes={freshHashes}
           />
         )}
+        {allRepos.length > 0 && (
+          <div className="panel-footer-hint" title="Drag a repo folder onto the panel, or paste a path">
+            Drop or paste a repo folder to add it
+            {addError && <span className="panel-footer-hint-error"> · {addError}</span>}
+          </div>
+        )}
       </section>
     </main>
   );
 }
 
+interface EmptyDropPanelProps {
+  scanning: boolean;
+  addError: string | null;
+}
+
+/** First-paint state for a fresh PC where no repos are cached AND the
+ * background scan hasn't found anything yet (no VS Code recents, no
+ * git config hints, etc). Shows a big drop target as the *primary* UI
+ * rather than a blank "Scanning…" screen — the explicit-add path is a
+ * first-class flow, not a hidden escape hatch. */
+function EmptyDropPanel({ scanning, addError }: EmptyDropPanelProps) {
+  return (
+    <div className="empty-drop">
+      <div className="empty-drop-icon" aria-hidden="true">
+        📂
+      </div>
+      <div className="empty-drop-title">Drop a repo folder here</div>
+      <div className="empty-drop-sub">or paste a path (Ctrl+V / Cmd+V)</div>
+      {scanning && (
+        <div className="empty-drop-status">Scanning for repos…</div>
+      )}
+      {addError && <div className="empty-drop-error">{addError}</div>}
+    </div>
+  );
+}
+
 export default App;

src/lib/ipc.ts

@@ -55,6 +55,17 @@ export async function currentUpstreamStatus(
   });
 }
 
+/** Add a repo by absolute path (drag-drop / paste). Backend validates
+ * via git2::Repository::discover (so a sub-folder of a repo also works).
+ * Throws on non-Git paths so the UI can show an inline error. On
+ * success the orchestrator has already emitted `timeline://repo-
+ * discovered`, so the listener in App.tsx picks the new row up
+ * automatically — the resolved Repo is also returned for callers that
+ * want to show synchronous feedback. */
+export async function explicitAddRepo(path: string): Promise<DiscoveredRepo> {
+  return invoke<DiscoveredRepo>("explicit_add_repo", { path });
+}
+
 export async function repoCommits(
   repoPath: string,
   branches: string[] | null,