fix(test): recover after Linear's "conflict on insert" on projects create

Linear's API has a transient failure mode where `*Create` mutations commit
server-side but return "conflict on insert" to the client. The existing
`run_lineark_with_retry` helper retries the same request body, which is
counterproductive — Linear's content-hash idempotency keeps returning the
same conflict, so every retry fails the same way. CI's Tests (Online) job
has been flaking on this for at least the last several PRs (#140 hit it
before the work in #141 even started).

When we see "conflict on insert", read the entity back by name instead of
retrying. The entity is already in Linear's database; we just need its
post-create state. Both `*Create` and `read` responses share the shape
that downstream test assertions care about (`id`, `name`, full details),
so the synthesized response is interchangeable.

Limited to `projects` for now since `projects read` accepts both UUIDs
and names. `issues read` only accepts identifier/UUID; the one issues
caller of this helper would need a search-and-filter recovery path
that's bigger than this fix.

Author: flipbit03

crates/lineark/tests/online.rs

@@ -30,7 +30,19 @@ fn run_lineark_with_retry(args: &[&str]) -> std::process::Output {
             return output;
         }
         let stderr = String::from_utf8_lossy(&output.stderr);
-        // Only retry on transient "conflict on insert" errors from the Linear API.
+        // Linear's API has a transient failure mode where `*Create` mutations
+        // commit server-side but return "conflict on insert" to the client.
+        // Retrying the same request body is futile — the server's content-hash
+        // idempotency keeps returning the same conflict. Recover instead by
+        // reading back the just-created entity by its name; if found, return
+        // that as a synthetic success.
+        if stderr.contains("conflict on insert") {
+            if let Some(recovered) = recover_after_create_conflict(args) {
+                return recovered;
+            }
+        }
+        // Non-conflict errors (or unrecoverable conflicts) bubble up after
+        // the loop exhausts.
         if !stderr.contains("conflict on insert") {
             return output;
         }
@@ -42,6 +54,60 @@ fn run_lineark_with_retry(args: &[&str]) -> std::process::Output {
         .expect("failed to execute lineark")
 }
 
+/// On a `*Create` "conflict on insert" error, the entity is usually already
+/// in Linear's database — the server just lost the response. Read it back by
+/// the unique name/title we just sent and return the read response as a
+/// stand-in for the original create response. Both responses have the shape
+/// callers care about (`id`, `name`, plus full entity details), so the test
+/// assertions that follow continue to work.
+///
+/// Returns `None` when the args don't match a recognized create pattern, the
+/// resource has no read-by-name path, or the read itself fails — leaving the
+/// caller free to bubble the original conflict error.
+fn recover_after_create_conflict(args: &[&str]) -> Option<std::process::Output> {
+    // Locate the `<resource> create <name>` triple.
+    let create_pos = args.iter().position(|&a| a == "create")?;
+    let resource = *args.get(create_pos.checked_sub(1)?)?;
+    let name = *args.get(create_pos + 1)?;
+
+    // Pull the auth token + format from earlier in the args so the read uses
+    // the same identity and serialization as the original call.
+    let token_pos = args.iter().position(|&a| a == "--api-token")?;
+    let token = *args.get(token_pos + 1)?;
+    let format = args
+        .iter()
+        .position(|&a| a == "--format")
+        .and_then(|i| args.get(i + 1))
+        .copied()
+        .unwrap_or("json");
+
+    // Only resources whose `read` subcommand accepts a human-readable name
+    // can recover this way. Projects qualify (`projects read` resolves names
+    // and UUIDs); issues take an identifier or UUID, so a title-based recovery
+    // path would need a search + filter step we don't yet have.
+    if resource != "projects" {
+        return None;
+    }
+
+    let read = lineark()
+        .args([
+            "--api-token",
+            token,
+            "--format",
+            format,
+            resource,
+            "read",
+            name,
+        ])
+        .output()
+        .ok()?;
+    if read.status.success() {
+        Some(read)
+    } else {
+        None
+    }
+}
+
 /// Helper: create a fresh test team via the SDK.
 fn create_test_team() -> TestTeam {
     let client = Client::from_token(test_token()).unwrap();