Make client CodeForge deserialization forward-compatible (fixes repo-less run "environment not found") (#15456)

<!-- warp:pr-description-artifacts start -->
<!-- warp:pr-description-artifacts end -->

## Description
Fixes a staging bug found while testing REMOTE-2965
(forge-less/repo-less factories, warp-server#15763): dispatching a run
against a repo-less (`code_forge: NONE`) environment failed with a
misleading `Environment '<id>' not found` error, even though the
environment demonstrably existed server-side (visible in the legacy Oz
web UI).

**Root cause**: `cloud_object_models::CodeForge` only recognizes
`GITHUB` and `GITLAB`. `AmbientAgentEnvironment.code_forge` is
`Option<CodeForge>`, and serde's `default` only covers an *absent* field
— a *present* but unrecognized string (`"NONE"`, which the server
correctly sends for a repo-less environment) is a hard deserialization
error for the whole environment object. The sync layer never
materializes that environment locally, so the later
`CloudAmbientAgentEnvironment::get_by_id` lookup in
`AgentDriver::resolve_environment` comes back empty and gets reported as
"not found" — a client-side sync failure, not a server 404.

**The actual defect isn't that `NONE` was missing** — it's that the
client cannot survive the server introducing any forge value it doesn't
yet know about. Multi-forge support is coming and will add more values,
so this exact failure mode would recur. The fix:
- Adds an explicit `CodeForge::None` variant for the repo-less case.
- Adds a `#[serde(other)] Unknown` catch-all, the pattern this crate
already uses for the same problem elsewhere (see `ActionPermission`,
`WriteToPtyPermission`, `ComputerUsePermission`, `RunAgentsPermission`
in `ai_execution_profile.rs`), so a forge value newer than this client
build degrades to "no usable forge" (`host()` returns `""`) instead of
failing deserialization or silently defaulting to GitHub — which would
send an old client off to authenticate against the wrong host.
- `repository_forge_for_repo` (per-repository forge resolution) now
returns `Option<RepositoryForge>` instead of assuming every repository's
forge is resolvable. `AmbientAgentEnvironment::effective_repos()` copies
the container's forge onto any repository that omits its own, so a
repository can legitimately carry `None`/`Unknown` today (repo-less
environment) or in the future (a forge value newer than this client).
`repository_clone_requests` now returns a new
`PrepareEnvironmentError::UnsupportedRepositoryForge` for such a
repository — checked before head-override matching, so it fails fast
with a clear error rather than either panicking or silently building a
clone request with an empty host. `head_override_matches_repo`
correspondingly never matches an override against a repository whose
forge can't be resolved.

The actual repo-cloning/setup-command logic (`prepare_environment_impl`)
already handles an empty `source_repos` list correctly (the pre-existing
legacy zero-repo path), so once the environment deserializes, run
execution against a repo-less environment needs no further change.

## Linked Issue
Linear REMOTE-2965 (no GitHub issue). Follow-up to warp-server#15763.

## Testing
- [x] Reproduced the exact defects with unit tests first
(`deserialize_environment_with_unrecognized_forge_still_succeeds` fails
without the `Unknown` catch-all;
`clone_requests_reject_a_repository_with_an_unrecognized_forge` panicked
against an earlier revision of this PR that treated an unresolvable
repository forge as impossible), then fixed each.
- Added unit tests in
`crates/cloud_object_models/src/cloud_environment_tests.rs`:
- `deserialize_repo_less_environment_resolves_to_none_forge` — a
`code_forge: "NONE"` environment deserializes and resolves to
`CodeForge::None` with no repositories.
- `deserialize_environment_with_unrecognized_forge_still_succeeds` — a
made-up future forge value (`"BITBUCKET"`) still lets the whole
environment deserialize, resolving to `CodeForge::Unknown` rather than
failing or silently becoming `GitHub`.
- `none_and_unknown_forges_have_no_clonable_host` — pins that neither
degrades to `github.com`.
- Added unit tests in
`app/src/ai/agent_sdk/driver/environment_tests.rs`:
- `clone_requests_reject_a_repository_with_an_unrecognized_forge` —
building clone requests for an `Unknown`-forge repository returns
`UnsupportedRepositoryForge` instead of panicking.
-
`clone_requests_reject_an_unrecognized_forge_repository_even_with_unrelated_overrides`
— same, but with a head override present for a different,
resolvable-forge repository in the same environment, proving this path
is reachable via ordinary override handling.
-
`head_override_validation_treats_an_unrecognized_forge_repository_as_never_matching`
— `validate_repository_head_overrides` reports such a repository as "not
declared" instead of panicking when an override names it.
- `cargo test -p cloud_object_models` — all green. `cargo test -p warp
--lib ai::agent_sdk` — 529 of 530 pass; the one failure
(`api_key::tests::resolve_api_key_identifier_errors_for_ambiguous_name_matches`)
blocks on an interactive TTY prompt in this sandbox and is unrelated to
this change.
- `cargo clippy -p cloud_object_models --all-targets --all-features --
-D warnings` and `cargo clippy -p warp --lib -- -D warnings` — clean.
`./script/format` — clean.
- Not manually tested with `./script/run`: the observable failure only
reproduces inside an actual dispatched cloud/local agent run against a
repo-less environment, which requires live dispatch infrastructure this
environment doesn't have. The unit tests above reproduce the actual
defects (deserialization, then clone-request building) directly, which
is the level `rust-unit-tests` recommends for a deterministic, non-UI
bug like this one.

## Agent Mode
- [x] Warp Agent Mode - This PR was created via Warp's AI Agent Mode

CHANGELOG-NONE

---------

Co-authored-by: warp-agent-staging[bot] <240773466+warp-agent-staging[bot]@users.noreply.github.com>

Author: warp-agent-staging[bot]

app/src/ai/agent_sdk/driver/environment.rs

@@ -56,6 +56,10 @@ pub enum PrepareEnvironmentError {
         first_owner: String,
         second_owner: String,
     },
+    #[error(
+        "Repository {repo_name} has a code forge this client build doesn't support; update Warp to a version that does"
+    )]
+    UnsupportedRepositoryForge { repo_name: String },
     #[error("Terminal driver error while preparing environment: {source}")]
     TerminalDriver { source: AgentDriverError },
 }
@@ -299,7 +303,7 @@ async fn prepare_environment_impl(
         setup_events
             .record_result(SetupStep::EnvironmentRepoClone, async {
                 clone_checkout_requests(
-                    &repository_clone_requests(source_repos, repository_head_overrides),
+                    &repository_clone_requests(source_repos, repository_head_overrides)?,
                     working_dir,
                     spawner,
                 )
@@ -465,14 +469,19 @@ fn record_codebase_indexing(
     });
 }
 
-fn repository_forge_for_repo(repo: &SourceRepo) -> RepositoryForge {
+// `None` covers both a repo-less container forge and one this client build
+// doesn't recognize. Unlike `None`, a future server can assign the latter to
+// a real repository before this client updates, so callers must treat it as
+// an ordinary "can't clone this" outcome rather than an invariant violation.
+fn repository_forge_for_repo(repo: &SourceRepo) -> Option<RepositoryForge> {
     match repo.code_forge.unwrap_or_default() {
-        CodeForge::GitHub => RepositoryForge::GitHub,
-        CodeForge::GitLab => RepositoryForge::GitLab,
+        CodeForge::GitHub => Some(RepositoryForge::GitHub),
+        CodeForge::GitLab => Some(RepositoryForge::GitLab),
+        CodeForge::None | CodeForge::Unknown => None,
     }
 }
 fn head_override_matches_repo(head_override: &RepositoryHeadOverride, repo: &SourceRepo) -> bool {
-    head_override.code_forge == repository_forge_for_repo(repo)
+    Some(head_override.code_forge) == repository_forge_for_repo(repo)
         && head_override.repo_owner == repo.owner
         && head_override.repo_name == repo.repo
 }
@@ -495,16 +504,25 @@ struct RepositoryCloneRequest {
 fn repository_clone_requests(
     repos: &[SourceRepo],
     overrides: &[RepositoryHeadOverride],
-) -> Vec<RepositoryCloneRequest> {
+) -> Result<Vec<RepositoryCloneRequest>, PrepareEnvironmentError> {
     repos
         .iter()
         .cloned()
         .map(|repo| {
+            // A repository this client can't identify a host for can never
+            // clone; fail clearly here rather than attempt one with an empty
+            // host, which would otherwise be the only signal something is
+            // wrong.
+            if repository_forge_for_repo(&repo).is_none() {
+                return Err(PrepareEnvironmentError::UnsupportedRepositoryForge {
+                    repo_name: format!("{}/{}", repo.owner, repo.repo),
+                });
+            }
             let checkout = match head_override_for_repo(overrides, &repo) {
                 Some(head_override) => Some(head_override.head.clone()),
                 None => repo.checkout_ref.clone().map(RepositoryHeadRef::Branch),
             };
-            RepositoryCloneRequest { repo, checkout }
+            Ok(RepositoryCloneRequest { repo, checkout })
         })
         .collect()
 }
@@ -661,7 +679,12 @@ pub(super) async fn clone_repos(
     working_dir: &Path,
     spawner: &ModelSpawner<TerminalDriver>,
 ) -> Result<(), PrepareEnvironmentError> {
-    clone_checkout_requests(&repository_clone_requests(repos, &[]), working_dir, spawner).await
+    clone_checkout_requests(
+        &repository_clone_requests(repos, &[])?,
+        working_dir,
+        spawner,
+    )
+    .await
 }
 
 async fn clone_checkout_requests(

app/src/ai/agent_sdk/driver/environment_tests.rs

@@ -344,7 +344,7 @@ fn head_overrides_replace_checkout_ref_only_for_matching_repos() {
         branch_head_override(RepositoryForge::GitHub, "warpdotdev", "unused", "develop"),
     ];
 
-    let prepared = repository_clone_requests(&repos, &overrides);
+    let prepared = repository_clone_requests(&repos, &overrides).unwrap();
 
     assert_eq!(
         prepared[0].checkout,
@@ -358,6 +358,84 @@ fn head_overrides_replace_checkout_ref_only_for_matching_repos() {
     );
 }
 
+#[test]
+fn clone_requests_reject_a_repository_with_an_unrecognized_forge() {
+    // An environment forge value newer than this client build (see
+    // CodeForge::Unknown) can still be assigned to a real repository by a
+    // newer server. Building clone requests for it must fail clearly rather
+    // than panic or silently attempt a clone with no host.
+    let repos = vec![SourceRepo::new(
+        CodeForge::Unknown,
+        "warpdotdev".to_string(),
+        "warp".to_string(),
+    )];
+
+    let error = repository_clone_requests(&repos, &[]).unwrap_err();
+
+    assert!(matches!(
+        error,
+        PrepareEnvironmentError::UnsupportedRepositoryForge { repo_name }
+            if repo_name == "warpdotdev/warp"
+    ));
+}
+
+#[test]
+fn clone_requests_reject_an_unrecognized_forge_repository_even_with_unrelated_overrides() {
+    // A head override targeting a different, supported-forge repository must
+    // not mask the unsupported repository elsewhere in the same environment:
+    // every repository is checked, not just the ones an override names.
+    let repos = vec![
+        SourceRepo::new(
+            CodeForge::GitHub,
+            "warpdotdev".to_string(),
+            "warp".to_string(),
+        ),
+        SourceRepo::new(
+            CodeForge::Unknown,
+            "warpdotdev".to_string(),
+            "warp-server".to_string(),
+        ),
+    ];
+    let overrides = vec![commit_head_override(
+        RepositoryForge::GitHub,
+        "warpdotdev",
+        "warp",
+        "0123456789abcdef0123456789abcdef01234567",
+    )];
+
+    let error = repository_clone_requests(&repos, &overrides).unwrap_err();
+
+    assert!(matches!(
+        error,
+        PrepareEnvironmentError::UnsupportedRepositoryForge { repo_name }
+            if repo_name == "warpdotdev/warp-server"
+    ));
+}
+
+#[test]
+fn head_override_validation_treats_an_unrecognized_forge_repository_as_never_matching() {
+    // No head override can target a repository whose forge this client can't
+    // represent; validation must reject it as "not declared" (an override
+    // that names a repository the environment doesn't have) rather than
+    // panicking while checking whether it matches.
+    let environment = environment_with_repos(vec![SourceRepo::new(
+        CodeForge::Unknown,
+        "warpdotdev".to_string(),
+        "warp".to_string(),
+    )]);
+    let override_for_it = commit_head_override(
+        RepositoryForge::GitHub,
+        "warpdotdev",
+        "warp",
+        "0123456789abcdef0123456789abcdef01234567",
+    );
+
+    let error =
+        validate_repository_head_overrides(&environment.effective_repos(), &[override_for_it])
+            .expect_err("an unrecognized-forge repository can never match an override");
+    assert!(error.to_string().contains("not declared"));
+}
+
 #[test]
 fn repository_head_override_validation_rejects_duplicates_and_mismatches() {
     let environment = environment_with_repos(vec![SourceRepo::new(
@@ -439,7 +517,7 @@ fn applied_head_overrides_are_threaded_through_the_existing_clone_command() {
         "develop",
     )];
     let command = build_parallel_clone_command(
-        &repository_clone_requests(&repos, &overrides),
+        &repository_clone_requests(&repos, &overrides).unwrap(),
         ShellType::Bash,
     );
 
@@ -468,7 +546,7 @@ fn applied_commit_override_uses_sha_only_fetch() {
         "0123456789abcdef0123456789abcdef01234567",
     )];
     let command = build_parallel_clone_command(
-        &repository_clone_requests(&repos, &overrides),
+        &repository_clone_requests(&repos, &overrides).unwrap(),
         ShellType::Bash,
     );
 

crates/cloud_object_models/src/cloud_environment.rs

@@ -16,13 +16,26 @@ pub enum CodeForge {
     GitHub,
     #[serde(rename = "GITLAB")]
     GitLab,
+    /// Explicit "no code forge" container value: a repo-less environment
+    /// that clones nothing and relies entirely on `setup_commands`.
+    #[serde(rename = "NONE")]
+    None,
+    // Catches a forge value this client build doesn't recognize yet (e.g. the
+    // server adds one before this client updates), so the rest of the
+    // environment still deserializes instead of the whole object failing.
+    #[serde(other)]
+    Unknown,
 }
 
 impl CodeForge {
+    /// The clonable host for this forge, empty for `None`/`Unknown` since
+    /// neither identifies one; callers must not fall back to `github.com`
+    /// for either, which would authenticate against the wrong host.
     pub const fn host(self) -> &'static str {
         match self {
             CodeForge::GitHub => "github.com",
             CodeForge::GitLab => "gitlab.com",
+            CodeForge::None | CodeForge::Unknown => "",
         }
     }
 }
@@ -32,6 +45,8 @@ impl fmt::Display for CodeForge {
         match self {
             CodeForge::GitHub => write!(f, "GitHub"),
             CodeForge::GitLab => write!(f, "GitLab"),
+            CodeForge::None => write!(f, "None"),
+            CodeForge::Unknown => write!(f, "Unknown"),
         }
     }
 }

crates/cloud_object_models/src/cloud_environment_tests.rs

@@ -109,6 +109,47 @@ fn source_repo_checkout_ref_round_trips_and_is_optional() {
     assert_eq!(parsed.checkout_ref, None);
 }
 
+#[test]
+fn deserialize_repo_less_environment_resolves_to_none_forge() {
+    let json = serde_json::json!({
+        "name": "repo-less-env",
+        "code_forge": "NONE",
+        "github_repos": [],
+        "source_repos": [],
+        "setup_commands": ["echo hello"]
+    });
+
+    let env: AmbientAgentEnvironment = serde_json::from_value(json).unwrap();
+
+    assert_eq!(env.effective_code_forge(), CodeForge::None);
+    assert!(env.effective_repos().is_empty());
+}
+
+#[test]
+fn deserialize_environment_with_unrecognized_forge_still_succeeds() {
+    // A forge value this client build doesn't know about yet (e.g. the
+    // server introduces a new one before this client updates) must not fail
+    // deserialization of the whole environment.
+    let json = serde_json::json!({
+        "name": "future-forge-env",
+        "code_forge": "BITBUCKET",
+        "github_repos": [],
+        "setup_commands": ["echo hello"]
+    });
+
+    let env: AmbientAgentEnvironment = serde_json::from_value(json).unwrap();
+
+    assert_eq!(env.effective_code_forge(), CodeForge::Unknown);
+}
+
+#[test]
+fn none_and_unknown_forges_have_no_clonable_host() {
+    // Neither identifies a real host; a caller falling back to GitHub's host
+    // for either would authenticate against the wrong one.
+    assert_eq!(CodeForge::None.host(), "");
+    assert_eq!(CodeForge::Unknown.host(), "");
+}
+
 #[test]
 fn deserialize_gitlab_environment_uses_authoritative_source_repos() {
     let json = serde_json::json!({