feat: heartbeat manual mode so CLI tunnel does not fan out across projects

HeartbeatAgent::start() auto-enrolls every project the user has access
to, which is correct for the UI (it surfaces tunnels across projects)
but wrong for the CLI tunnel-listen command, which owns exactly one
project. Today's logs showed the fan-out clearly:

    heartbeat: no connector yet project_id=drewr-y4nd1b
    heartbeat: no connector yet project_id=drewr3-ceu4gt

The CLI silently maintained presence in drewr3-ceu4gt — a project the
user never mentioned — for the lifetime of the tunnel. Harmless today,
but it makes logs misleading, multiplies API load, and would create
real risk if a misconfigured token granted access to a project that
shouldn't be touched.

Add start_manual() that skips the watcher entirely. The CLI now starts
manual mode and explicitly registers its single project. Per-project
loops still handle 401s via force-refresh, so transient auth blips are
tolerated; the CLI's own login-state watch surfaces permanent logout.

Keeps start() unchanged so the UI continues to auto-enroll. The new
entry point is documented with a pointer to start_manual for callers
in the CLI-style pattern.

Author: drewr

cli/src/main.rs

@@ -648,10 +648,12 @@ async fn main() -> n0_error::Result<()> {
                         tunnel.id
                     };
 
-                    heartbeat.start().await;
-                    if let Some(ctx) = datum.selected_context() {
-                        heartbeat.register_project(ctx.project_id).await;
-                    }
+                    // Manual mode: only heartbeat the project the tunnel
+                    // lives in. Auto-enroll would silently keep presence in
+                    // every other project the user can see, which is both
+                    // wasteful and confusing in logs.
+                    heartbeat.start_manual().await;
+                    heartbeat.register_project(project_id.clone()).await;
 
                     service.set_enabled_active(&tunnel_id, true).await?;
                     println!();

lib/src/heartbeat.rs

@@ -86,6 +86,13 @@ impl HeartbeatAgent {
         }
     }
 
+    /// Start in auto-enroll mode: watch login + projects state and keep
+    /// heartbeats running for every project the user has access to.
+    /// Intended for multi-project consumers like the UI.
+    ///
+    /// For the CLI tunnel use case where there is exactly one project of
+    /// interest, prefer [`Self::start_manual`] — auto-enroll silently
+    /// maintains presence in projects the user didn't ask about.
     pub async fn start(&self) {
         let mut guard = self.inner.login_task.lock().await;
         if guard.is_some() {
@@ -134,6 +141,24 @@ impl HeartbeatAgent {
         *guard = Some(AbortOnDropHandle::new(task));
     }
 
+    /// Start in manual mode: do not watch login state and do not auto-enroll
+    /// projects. Callers are responsible for [`Self::register_project`] /
+    /// [`Self::deregister_project`] for the projects they want heartbeats
+    /// for. Per-project loops still handle 401s via their own
+    /// force-refresh logic, so transient auth blips are tolerated; a
+    /// permanent logout is surfaced separately by the CLI's own login
+    /// watcher.
+    pub async fn start_manual(&self) {
+        let mut guard = self.inner.login_task.lock().await;
+        if guard.is_some() {
+            return;
+        }
+        // Park a completed task so future start() / start_manual() calls
+        // remain no-ops, matching start()'s "single-start" contract.
+        let task = tokio::spawn(async {});
+        *guard = Some(AbortOnDropHandle::new(task));
+    }
+
     pub async fn register_project(&self, project_id: impl Into<String>) {
         let project_id = project_id.into();
         let mut projects = self.inner.projects.lock().await;
@@ -726,6 +751,53 @@ mod tests {
         assert_eq!(count, 0);
     }
 
+    #[tokio::test]
+    async fn start_manual_does_not_auto_enroll() {
+        // Manual mode is the CLI tunnel-listen path: only the project the
+        // caller explicitly registers should get a heartbeat task. Auto-
+        // enroll would have probed `orgs_and_projects()` on bootstrap and
+        // registered every accessible project — we verify it didn't by
+        // checking the projects map stays empty until we register one.
+        let repo = crate::Repo::open_or_create(test_repo_path()).await.unwrap();
+        let datum = crate::datum_cloud::DatumCloudClient::with_repo(
+            crate::datum_cloud::ApiEnv::Staging,
+            repo,
+        )
+        .await
+        .unwrap();
+        let provider = Arc::new(TestProvider {
+            endpoint_id: "test-endpoint".to_string(),
+        });
+        let runner: ProjectRunner = Arc::new(|_project_id, _datum, _provider, cancel| {
+            tokio::spawn(async move {
+                cancel.cancelled().await;
+            })
+        });
+        let agent = HeartbeatAgent::new_with_runner(datum, provider, runner);
+
+        agent.start_manual().await;
+        // Give any background bootstrap a chance to run; manual mode
+        // shouldn't have spawned one, but if it did this would expose it.
+        tokio::task::yield_now().await;
+        assert_eq!(
+            agent.inner.projects.lock().await.len(),
+            0,
+            "manual mode must not auto-enroll any project"
+        );
+
+        agent.register_project("explicit-project").await;
+        assert_eq!(
+            agent.inner.projects.lock().await.len(),
+            1,
+            "register_project still works in manual mode"
+        );
+
+        // start_manual is idempotent (matches start()'s contract): a
+        // second call is a no-op rather than tearing down and replacing.
+        agent.start_manual().await;
+        assert_eq!(agent.inner.projects.lock().await.len(), 1);
+    }
+
     #[test]
     fn renewal_interval_in_range() {
         for lease_duration_seconds in [1, 2, 10, 60] {