feat: remote agent backend providers

crates/sprout-acp/src/main.rs

@@ -123,6 +123,32 @@ async fn main() -> Result<()> {
         }
     }
 
+    // ── Step 2d: Query agent owner (with retry) ─────────────────────────────
+    // Owner lookup is critical for !shutdown — a transient failure here would
+    // permanently disable remote shutdown for this process. Retry a few times
+    // with backoff so a brief relay hiccup doesn't leave us uncontrollable.
+    // Owner lookup: try at startup, but if it fails the shutdown handler will
+    // retry lazily when a candidate !shutdown message arrives. This means a
+    // relay outage during startup doesn't permanently disable remote shutdown.
+    let mut owner_pubkey: Option<String> = {
+        let profile_url = format!("/api/users/{pubkey_hex}/profile");
+        match rest_client_for_presence.get_json(&profile_url).await {
+            Ok(v) => v
+                .get("agent_owner_pubkey")
+                .and_then(|v| v.as_str())
+                .map(String::from),
+            Err(e) => {
+                tracing::warn!("startup owner lookup failed (will retry lazily): {e}");
+                None
+            }
+        }
+    };
+    if let Some(ref owner) = owner_pubkey {
+        tracing::info!("agent owner: {owner}");
+    } else {
+        tracing::info!("no agent owner set at startup — will resolve lazily on !shutdown");
+    }
+
     // ── Step 3: Discover channels and build subscription rules ────────────────
     let channel_info_map = relay
         .discover_channels()
@@ -432,6 +458,54 @@ async fn main() -> Result<()> {
                                 tracing::debug!(channel_id = %sprout_event.channel_id, "dropping self-authored event");
                                 continue;
                             }
+
+                            // ── Shutdown command handling ─────────────────────
+                            // Check: kind:9, content "!shutdown", from owner, mentions THIS agent.
+                            let is_shutdown = kind_u32 == KIND_STREAM_MESSAGE
+                                && sprout_event.event.content.trim() == "!shutdown"
+                                && sprout_event.event.tags.iter().any(|t| {
+                                    t.as_slice().first().map(|s| s.as_str()) == Some("p")
+                                        && t.as_slice().get(1).map(|s| s.as_str()) == Some(pubkey_hex.as_str())
+                                });
+                            if is_shutdown {
+                                // Lazy owner resolution: if we don't have the owner
+                                // yet (startup lookup failed), try now. This ensures
+                                // a relay outage during startup doesn't permanently
+                                // disable remote shutdown.
+                                if owner_pubkey.is_none() {
+                                    let profile_url = format!("/api/users/{pubkey_hex}/profile");
+                                    match rest_client_for_presence.get_json(&profile_url).await {
+                                        Ok(v) => {
+                                            owner_pubkey = v
+                                                .get("agent_owner_pubkey")
+                                                .and_then(|v| v.as_str())
+                                                .map(String::from);
+                                            if let Some(ref o) = owner_pubkey {
+                                                tracing::info!("lazy owner resolution succeeded: {o}");
+                                            }
+                                        }
+                                        Err(e) => {
+                                            tracing::warn!("lazy owner lookup failed: {e}");
+                                        }
+                                    }
+                                }
+                                if let Some(ref owner) = owner_pubkey {
+                                    if sprout_event.event.pubkey.to_hex() == *owner {
+                                        tracing::info!(
+                                            channel_id = %sprout_event.channel_id,
+                                            sender = %sprout_event.event.pubkey.to_hex(),
+                                            "shutdown command from owner — exiting gracefully"
+                                        );
+                                        let _ = shutdown_tx.send(());
+                                        continue;
+                                    }
+                                }
+                                // Not from owner — fall through to normal prompt handling.
+                                // Don't drop it — it's a regular message that happens to
+                                // contain "!shutdown" from a non-owner.
+                            }
+                            // ── End shutdown command handling ──────────────────
+
                             let matched = filter::match_event(&sprout_event.event, sprout_event.channel_id, &rules, &pubkey_hex).await;
                             let prompt_tag = match matched {
                                 Some(m) => m.prompt_tag,

crates/sprout-admin/src/main.rs

@@ -88,18 +88,63 @@ async fn mint_token(
 
     let pubkey_bytes = pubkey.serialize().to_vec();
 
-    db.ensure_user(&pubkey_bytes).await?;
+    // ── Enforce shutdown-required scopes (before any DB writes) ─────────────
+    // Two triggers, same as the relay path:
+    // 1. Explicit --owner-pubkey (bootstrap mint)
+    // 2. Agent already has an owner in the DB (re-mint must preserve controllability)
+    // Fail closed: DB lookup error → assume owned → enforce scopes.
+    let has_existing_owner = match db.get_agent_channel_policy(&pubkey_bytes).await {
+        Ok(Some((_, Some(_)))) => true,
+        Ok(_) => false,
+        Err(e) => {
+            eprintln!("warning: owner lookup failed (assuming owned): {e}");
+            true // fail closed
+        }
+    };
+    if owner_pubkey.is_some() || has_existing_owner {
+        let required = [
+            "users:read",
+            "messages:read",
+            "messages:write",
+            "channels:read",
+        ];
+        for r in &required {
+            if !scopes.iter().any(|s| s == r) {
+                anyhow::bail!("owned agents require the '{r}' scope for agent controllability");
+            }
+        }
+    }
 
-    // Set agent owner if --owner-pubkey was provided
-    if let Some(ref owner_hex) = owner_pubkey {
+    // ── Validate owner_pubkey (before any DB writes) ─────────────────────────
+    let validated_owner = if let Some(ref owner_hex) = owner_pubkey {
         let owner_bytes =
             hex::decode(owner_hex).map_err(|e| anyhow::anyhow!("invalid owner pubkey hex: {e}"))?;
         if owner_bytes.len() != 32 {
             anyhow::bail!("owner pubkey must be 32 bytes (64 hex chars)");
         }
-        // Ensure owner's user row exists (FK constraint requires it)
+        Some(owner_bytes)
+    } else {
+        None
+    };
+
+    // ── DB writes (all validation passed) ────────────────────────────────────
+    db.ensure_user(&pubkey_bytes).await?;
+
+    if let Some(owner_bytes) = validated_owner {
         db.ensure_user(&owner_bytes).await?;
-        db.set_agent_owner(&pubkey_bytes, &owner_bytes).await?;
+        let was_set = db.set_agent_owner(&pubkey_bytes, &owner_bytes).await?;
+        if !was_set {
+            let existing = db
+                .get_agent_channel_policy(&pubkey_bytes)
+                .await?
+                .and_then(|(_, owner)| owner);
+            if existing.as_deref() != Some(owner_bytes.as_slice()) {
+                anyhow::bail!(
+                    "agent already has a different owner — refusing to mint token for non-owner"
+                );
+            }
+            eprintln!("note: agent already owned by the requested pubkey — proceeding");
+        }
     }
 
     let raw_token = generate_token();

crates/sprout-core/src/kind.rs

@@ -71,6 +71,10 @@ pub const KIND_TYPING_INDICATOR: u32 = 20002;
 
 // Stream messaging
 /// NIP-29 group chat message kind. V1 used kind:10001 (replaceable range — wrong), then 40001.
+///
+/// Agent shutdown convention: the agent's owner sends a kind:9 message with content
+/// `"!shutdown"` and a `#p` tag mentioning the agent. The harness exits gracefully.
+/// This is a convention, not a new event kind — uses regular stream messages.
 pub const KIND_STREAM_MESSAGE: u32 = 9;
 /// V1 used kind:10002 (replaceable range — wrong).
 pub const KIND_STREAM_MESSAGE_V2: u32 = 40002;

crates/sprout-db/src/channel.rs

@@ -646,6 +646,15 @@ async fn get_channel_tx(
     row_to_channel_record(row)
 }
 
+/// A channel entry returned as part of a bot member record.
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct BotChannelEntry {
+    /// Channel display name.
+    pub name: String,
+    /// Channel UUID (as string from the DB).
+    pub id: String,
+}
+
 /// Bot member record — a user with role=bot, with their channel memberships aggregated.
 #[derive(Debug, Clone)]
 pub struct BotMemberRecord {
@@ -657,8 +666,8 @@ pub struct BotMemberRecord {
     pub agent_type: Option<String>,
     /// Optional JSON capabilities descriptor.
     pub capabilities: Option<serde_json::Value>,
-    /// Comma-separated channel names (from string_agg).
-    pub channel_names: String,
+    /// Channel entries with both name and UUID, from json_agg.
+    pub channels: Vec<BotChannelEntry>,
 }
 
 /// User record for bulk lookup.
@@ -747,15 +756,16 @@ pub async fn get_accessible_channels(
         .collect()
 }
 
-/// Returns all bot-role members with their aggregated channel names.
+/// Returns all bot-role members with their channel memberships.
 ///
-/// Channel names are returned as a comma-separated string from string_agg.
+/// Channels are returned as a JSON array of `{name, id}` objects via `json_agg`,
+/// preserving the 1:1 name↔UUID pairing. No separate string_agg ordering issues.
 /// Members with no active channel memberships are excluded (INNER JOIN on channels).
 pub async fn get_bot_members(pool: &PgPool) -> Result<Vec<BotMemberRecord>> {
     let rows = sqlx::query(
         r#"
         SELECT cm.pubkey, u.display_name, u.agent_type, u.capabilities,
-               string_agg(DISTINCT c.name, ',' ORDER BY c.name) AS channel_names
+               COALESCE(json_agg(DISTINCT jsonb_build_object('name', c.name, 'id', c.id::text)), '[]') AS channels_json
         FROM channel_members cm
         LEFT JOIN users u ON cm.pubkey = u.pubkey
         JOIN channels c ON cm.channel_id = c.id AND c.deleted_at IS NULL
@@ -770,14 +780,17 @@ pub async fn get_bot_members(pool: &PgPool) -> Result<Vec<BotMemberRecord>> {
     let mut out = Vec::with_capacity(rows.len());
     for row in rows {
         let capabilities: Option<serde_json::Value> = row.try_get("capabilities")?;
+        let channels_json: serde_json::Value = row
+            .try_get::<serde_json::Value, _>("channels_json")
+            .unwrap_or(serde_json::Value::Array(vec![]));
+        let channels: Vec<BotChannelEntry> =
+            serde_json::from_value(channels_json).unwrap_or_default();
         out.push(BotMemberRecord {
             pubkey: row.try_get("pubkey")?,
             display_name: row.try_get("display_name")?,
             agent_type: row.try_get("agent_type")?,
             capabilities,
-            channel_names: row
-                .try_get::<Option<String>, _>("channel_names")?
-                .unwrap_or_default(),
+            channels,
         });
     }
     Ok(out)

crates/sprout-db/src/lib.rs

@@ -491,8 +491,9 @@ impl Db {
         user::search_users(&self.pool, query, limit).await
     }
 
-    /// Set the owner pubkey for an agent user.
-    pub async fn set_agent_owner(&self, agent_pubkey: &[u8], owner_pubkey: &[u8]) -> Result<()> {
+    /// Atomically set agent owner — only if no owner is currently assigned.
+    /// Returns Ok(true) if set, Ok(false) if an owner already exists.
+    pub async fn set_agent_owner(&self, agent_pubkey: &[u8], owner_pubkey: &[u8]) -> Result<bool> {
         user::set_agent_owner(&self.pool, agent_pubkey, owner_pubkey).await
     }