Files
crank/docs/epic-1-completion/evidence/agent-red.patch
T

907 lines
30 KiB
Diff

diff --git a/apps/admin-api/tests/integration.rs b/apps/admin-api/tests/integration.rs
index eb3215b..a6ff2f7 100644
--- a/apps/admin-api/tests/integration.rs
+++ b/apps/admin-api/tests/integration.rs
@@ -1,5 +1,6 @@
mod integration {
mod agent_catalog;
+ mod agent_catalog_edit;
mod auth_rate_limit;
mod common;
mod community_access_usage;
diff --git a/apps/admin-api/tests/integration/agent_catalog_edit.rs b/apps/admin-api/tests/integration/agent_catalog_edit.rs
new file mode 100644
index 0000000..1986044
--- /dev/null
+++ b/apps/admin-api/tests/integration/agent_catalog_edit.rs
@@ -0,0 +1,889 @@
+use super::common::*;
+
+use crank_core::{Workspace, WorkspaceId, WorkspaceStatus};
+use crank_registry::{CreateWorkspaceRequest, PostgresRegistry};
+use serde_json::{Value, json};
+use serial_test::serial;
+use time::OffsetDateTime;
+
+const DEFAULT_WORKSPACE_ID: &str = "ws_default";
+
+fn binding(operation_id: &str, tool_name: &str, tool_title: &str) -> Value {
+ json!({
+ "operation_id": operation_id,
+ "operation_version": 1,
+ "tool_name": tool_name,
+ "tool_title": tool_title,
+ "tool_description_override": null,
+ "enabled": true
+ })
+}
+
+async fn create_draft_operation(
+ client: &reqwest::Client,
+ base_url: &TestServer,
+ upstream: &str,
+ name: &str,
+) -> String {
+ let operation = assert_success_json(
+ client
+ .post(format!("{base_url}/operations"))
+ .json(&test_operation_payload(upstream, name))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+ operation["operation_id"].as_str().unwrap().to_owned()
+}
+
+async fn create_published_operation(
+ client: &reqwest::Client,
+ base_url: &TestServer,
+ upstream: &str,
+ name: &str,
+) -> String {
+ let operation_id = create_draft_operation(client, base_url, upstream, name).await;
+ let etag = operation_etag(client, base_url, &operation_id).await;
+ assert_success_json(
+ client
+ .post(format!("{base_url}/operations/{operation_id}/publish"))
+ .header(reqwest::header::IF_MATCH, etag)
+ .json(&json!({ "version": 1 }))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+ operation_id
+}
+
+async fn create_published_agent(
+ client: &reqwest::Client,
+ base_url: &TestServer,
+ slug: &str,
+ operation_id: &str,
+ tool_name: &str,
+) -> (String, Value) {
+ let agent = assert_success_json(
+ client
+ .post(format!("{base_url}/agents"))
+ .json(&json!({
+ "slug": slug,
+ "display_name": slug,
+ "description": "agent catalog edit fixture",
+ "instructions": { "system_prompt": "Use only published bindings" },
+ "tool_selection_policy": {}
+ }))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+ let agent_id = agent["agent_id"].as_str().unwrap().to_owned();
+
+ let etag = agent_etag(client, base_url, &agent_id).await;
+ assert_success_json(
+ client
+ .post(format!("{base_url}/agents/{agent_id}/bindings"))
+ .header(reqwest::header::IF_MATCH, etag)
+ .json(&json!([binding(operation_id, tool_name, "Base Tool")]))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+
+ let etag = agent_etag(client, base_url, &agent_id).await;
+ assert_success_json(
+ client
+ .post(format!("{base_url}/agents/{agent_id}/publish"))
+ .header(reqwest::header::IF_MATCH, etag)
+ .json(&json!({ "version": 1 }))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+
+ let published_v1 = assert_success_json(
+ client
+ .get(format!("{base_url}/agents/{agent_id}/versions/1"))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+
+ (agent_id, published_v1)
+}
+
+async fn agent_version_count(db: &PostgresRegistry, agent_id: &str) -> i64 {
+ sqlx::query_scalar("select count(*) from agent_versions where agent_id = $1")
+ .bind(agent_id)
+ .fetch_one(db.pool())
+ .await
+ .unwrap()
+}
+
+async fn assert_no_durable_draft(
+ client: &reqwest::Client,
+ db: &PostgresRegistry,
+ base_url: &TestServer,
+ agent_id: &str,
+ published_v1: &Value,
+) {
+ let summary = assert_success_json(
+ client
+ .get(format!("{base_url}/agents/{agent_id}"))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+ assert_eq!(
+ summary["current_draft_version"], 1,
+ "a rejected edit must not fork a Draft Version: {summary}"
+ );
+ assert_eq!(summary["latest_published_version"], 1, "{summary}");
+ assert_eq!(summary["status"], "published", "{summary}");
+ assert_eq!(
+ agent_version_count(db, agent_id).await,
+ 1,
+ "a rejected edit must not persist a new Agent Version row"
+ );
+
+ let published_after = assert_success_json(
+ client
+ .get(format!("{base_url}/agents/{agent_id}/versions/1"))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+ assert_eq!(
+ &published_after, published_v1,
+ "the Published snapshot and its bindings must stay unchanged after a rejected edit"
+ );
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[serial]
+async fn published_agent_first_edit_forks_one_draft_and_keeps_published_snapshot() {
+ let registry = test_registry().await;
+ let db = registry.clone();
+ let storage_root = test_storage_root("agent_catalog_edit_first");
+ let upstream_base_url = spawn_upstream_server().await;
+ let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
+ let client = authorized_client(&base_url).await;
+
+ let operation_id =
+ create_published_operation(&client, &base_url, &upstream_base_url, "edit_first_tool").await;
+ let (agent_id, published_v1) = create_published_agent(
+ &client,
+ &base_url,
+ "edit-first",
+ &operation_id,
+ "edit_first_tool",
+ )
+ .await;
+
+ let summary_before = assert_success_json(
+ client
+ .get(format!("{base_url}/agents/{agent_id}"))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+ assert_eq!(summary_before["current_draft_version"], 1);
+ assert_eq!(summary_before["latest_published_version"], 1);
+ assert_eq!(summary_before["status"], "published");
+
+ let desired_policy = json!({
+ "mode": "search",
+ "groups": [{
+ "id": "crm-group",
+ "name": "CRM",
+ "description": "CRM tools",
+ "tool_names": ["edit_first_tool"]
+ }],
+ "search": { "max_results": 5 }
+ });
+
+ let edit_etag = agent_etag(&client, &base_url, &agent_id).await;
+ let response = client
+ .post(format!("{base_url}/agents/{agent_id}/bindings"))
+ .header(reqwest::header::IF_MATCH, edit_etag)
+ .json(&json!({
+ "bindings": [binding(&operation_id, "edit_first_tool", "Edited Tool")],
+ "tool_selection_policy": desired_policy
+ }))
+ .send()
+ .await
+ .unwrap();
+ let status = response.status();
+ let body = response.json::<Value>().await.unwrap();
+ assert_eq!(
+ status,
+ reqwest::StatusCode::OK,
+ "the first edit of a Published Agent must fork and save under the original If-Match: {body}"
+ );
+ assert_eq!(body["version"], 2, "{body}");
+
+ let summary_after = assert_success_json(
+ client
+ .get(format!("{base_url}/agents/{agent_id}"))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+ assert_eq!(summary_after["current_draft_version"], 2, "{summary_after}");
+ assert_eq!(
+ summary_after["latest_published_version"], 1,
+ "{summary_after}"
+ );
+ assert_eq!(summary_after["status"], "published", "{summary_after}");
+
+ assert_eq!(
+ agent_version_count(&db, &agent_id).await,
+ 2,
+ "the first edit must create exactly one additional Draft Version"
+ );
+
+ let draft = assert_success_json(
+ client
+ .get(format!("{base_url}/agents/{agent_id}/versions/2"))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+ assert_eq!(draft["status"], "draft", "{draft}");
+ assert_eq!(
+ draft["snapshot"]["instructions"],
+ published_v1["snapshot"]["instructions"]
+ );
+ assert_eq!(draft["bindings"].as_array().unwrap().len(), 1, "{draft}");
+ assert_eq!(draft["bindings"][0]["tool_title"], "Edited Tool", "{draft}");
+ assert_eq!(
+ draft["snapshot"]["tool_selection_policy"]["mode"], "search",
+ "{draft}"
+ );
+ assert_eq!(
+ draft["snapshot"]["tool_selection_policy"]["search"]["max_results"], 5,
+ "{draft}"
+ );
+
+ let published_after = assert_success_json(
+ client
+ .get(format!("{base_url}/agents/{agent_id}/versions/1"))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+ assert_eq!(
+ published_after, published_v1,
+ "the Published v1 snapshot must not change when the Draft is forked"
+ );
+
+ let next_etag = agent_etag(&client, &base_url, &agent_id).await;
+ let second_response = client
+ .post(format!("{base_url}/agents/{agent_id}/bindings"))
+ .header(reqwest::header::IF_MATCH, next_etag)
+ .json(&json!({
+ "bindings": [binding(&operation_id, "edit_first_tool", "Edited Again")],
+ "tool_selection_policy": desired_policy
+ }))
+ .send()
+ .await
+ .unwrap();
+ let second_status = second_response.status();
+ let second_body = second_response.text().await.unwrap();
+ assert_eq!(
+ second_status,
+ reqwest::StatusCode::OK,
+ "a subsequent valid edit on the Draft must succeed: {second_body}"
+ );
+ assert_eq!(
+ agent_version_count(&db, &agent_id).await,
+ 2,
+ "a subsequent valid edit must stay on the existing Draft v2"
+ );
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[serial]
+async fn rejected_invalid_policy_leaves_no_durable_draft() {
+ let registry = test_registry().await;
+ let db = registry.clone();
+ let storage_root = test_storage_root("agent_catalog_edit_invalid_policy");
+ let upstream_base_url = spawn_upstream_server().await;
+ let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
+ let client = authorized_client(&base_url).await;
+
+ let operation_id =
+ create_published_operation(&client, &base_url, &upstream_base_url, "edit_policy_tool")
+ .await;
+ let (agent_id, published_v1) = create_published_agent(
+ &client,
+ &base_url,
+ "edit-policy",
+ &operation_id,
+ "edit_policy_tool",
+ )
+ .await;
+
+ let etag = agent_etag(&client, &base_url, &agent_id).await;
+ let response = client
+ .post(format!("{base_url}/agents/{agent_id}/bindings"))
+ .header(reqwest::header::IF_MATCH, etag)
+ .json(&json!({
+ "bindings": [],
+ "tool_selection_policy": {
+ "mode": "direct",
+ "groups": [{
+ "id": "group-1",
+ "name": "Group",
+ "description": "groups require search mode",
+ "tool_names": []
+ }]
+ }
+ }))
+ .send()
+ .await
+ .unwrap();
+ let status = response.status();
+ let body = response.text().await.unwrap();
+ assert_eq!(
+ status,
+ reqwest::StatusCode::BAD_REQUEST,
+ "a grouping policy in direct mode must be rejected: {body}"
+ );
+
+ assert_no_durable_draft(&client, &db, &base_url, &agent_id, &published_v1).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[serial]
+async fn rejected_unpublished_operation_leaves_no_durable_draft() {
+ let registry = test_registry().await;
+ let db = registry.clone();
+ let storage_root = test_storage_root("agent_catalog_edit_draft_op");
+ let upstream_base_url = spawn_upstream_server().await;
+ let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
+ let client = authorized_client(&base_url).await;
+
+ let live_operation =
+ create_published_operation(&client, &base_url, &upstream_base_url, "edit_live_tool").await;
+ let (agent_id, published_v1) = create_published_agent(
+ &client,
+ &base_url,
+ "edit-draft-op",
+ &live_operation,
+ "edit_live_tool",
+ )
+ .await;
+
+ let draft_operation =
+ create_draft_operation(&client, &base_url, &upstream_base_url, "edit_draft_tool").await;
+
+ let etag = agent_etag(&client, &base_url, &agent_id).await;
+ let response = client
+ .post(format!("{base_url}/agents/{agent_id}/bindings"))
+ .header(reqwest::header::IF_MATCH, etag)
+ .json(&json!([binding(
+ &draft_operation,
+ "edit_draft_tool",
+ "Draft Tool"
+ )]))
+ .send()
+ .await
+ .unwrap();
+ let status = response.status();
+ let body = response.text().await.unwrap();
+ assert_eq!(
+ status,
+ reqwest::StatusCode::UNPROCESSABLE_ENTITY,
+ "binding an unpublished Operation must be rejected: {body}"
+ );
+ let body: Value = serde_json::from_str(&body).unwrap();
+ assert_eq!(
+ body["error"]["code"], "agent_binding_not_published",
+ "{body}"
+ );
+
+ assert_no_durable_draft(&client, &db, &base_url, &agent_id, &published_v1).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[serial]
+async fn rejected_archived_operation_leaves_no_durable_draft() {
+ let registry = test_registry().await;
+ let db = registry.clone();
+ let storage_root = test_storage_root("agent_catalog_edit_archived_op");
+ let upstream_base_url = spawn_upstream_server().await;
+ let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
+ let client = authorized_client(&base_url).await;
+
+ let live_operation = create_published_operation(
+ &client,
+ &base_url,
+ &upstream_base_url,
+ "edit_live_tool_arch",
+ )
+ .await;
+ let (agent_id, published_v1) = create_published_agent(
+ &client,
+ &base_url,
+ "edit-archived-op",
+ &live_operation,
+ "edit_live_tool_arch",
+ )
+ .await;
+
+ let archived_operation =
+ create_published_operation(&client, &base_url, &upstream_base_url, "edit_archived_tool")
+ .await;
+ let operation_etag = operation_etag(&client, &base_url, &archived_operation).await;
+ let archived = client
+ .post(format!(
+ "{base_url}/operations/{archived_operation}/archive"
+ ))
+ .header(reqwest::header::IF_MATCH, operation_etag)
+ .send()
+ .await
+ .unwrap();
+ let archived_status = archived.status();
+ let archived_body = archived.text().await.unwrap();
+ assert!(archived_status.is_success(), "{archived_body}");
+
+ let etag = agent_etag(&client, &base_url, &agent_id).await;
+ let response = client
+ .post(format!("{base_url}/agents/{agent_id}/bindings"))
+ .header(reqwest::header::IF_MATCH, etag)
+ .json(&json!([binding(
+ &archived_operation,
+ "edit_archived_tool",
+ "Archived Tool"
+ )]))
+ .send()
+ .await
+ .unwrap();
+ let status = response.status();
+ let body = response.text().await.unwrap();
+ assert_eq!(
+ status,
+ reqwest::StatusCode::UNPROCESSABLE_ENTITY,
+ "binding an archived Operation must be rejected: {body}"
+ );
+ let body: Value = serde_json::from_str(&body).unwrap();
+ assert_eq!(
+ body["error"]["code"], "agent_binding_archived_operation",
+ "{body}"
+ );
+
+ assert_no_durable_draft(&client, &db, &base_url, &agent_id, &published_v1).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[serial]
+async fn rejected_foreign_operation_leaves_no_durable_draft() {
+ let registry = test_registry().await;
+ let db = registry.clone();
+ let storage_root = test_storage_root("agent_catalog_edit_foreign_op");
+ let upstream_base_url = spawn_upstream_server().await;
+ let base_url = spawn_admin_api(build_test_app(registry.clone(), storage_root)).await;
+ let client = authorized_client(&base_url).await;
+
+ let live_operation = create_published_operation(
+ &client,
+ &base_url,
+ &upstream_base_url,
+ "edit_live_tool_foreign",
+ )
+ .await;
+ let (agent_id, published_v1) = create_published_agent(
+ &client,
+ &base_url,
+ "edit-foreign-op",
+ &live_operation,
+ "edit_live_tool_foreign",
+ )
+ .await;
+
+ let foreign_workspace = WorkspaceId::new("ws_agent_edit_foreign");
+ let now = OffsetDateTime::now_utc();
+ db.create_workspace(CreateWorkspaceRequest {
+ workspace: &Workspace {
+ id: foreign_workspace.clone(),
+ slug: "agent-edit-foreign".to_owned(),
+ display_name: "Agent Edit Foreign".to_owned(),
+ status: WorkspaceStatus::Active,
+ settings: json!({}),
+ created_at: now,
+ updated_at: now,
+ },
+ })
+ .await
+ .unwrap();
+
+ let foreign_service = test_service(
+ db.clone(),
+ test_storage_root("agent_catalog_edit_foreign_service"),
+ test_auth_settings(),
+ test_secret_crypto(),
+ );
+ let foreign_operation = foreign_service
+ .create_operation(
+ &foreign_workspace,
+ test_operation_payload(&upstream_base_url, "edit_foreign_tool"),
+ )
+ .await
+ .unwrap();
+ let foreign_operation_id = foreign_operation.operation_id;
+
+ let etag = agent_etag(&client, &base_url, &agent_id).await;
+ let response = client
+ .post(format!("{base_url}/agents/{agent_id}/bindings"))
+ .header(reqwest::header::IF_MATCH, etag)
+ .json(&json!([binding(
+ &foreign_operation_id,
+ "edit_foreign_tool",
+ "Foreign Tool"
+ )]))
+ .send()
+ .await
+ .unwrap();
+ let status = response.status();
+ let body = response.text().await.unwrap();
+ assert_eq!(
+ status,
+ reqwest::StatusCode::NOT_FOUND,
+ "binding an Operation from another workspace must be rejected: {body}"
+ );
+ let body: Value = serde_json::from_str(&body).unwrap();
+ assert_eq!(
+ body["error"]["code"], "agent_binding_scope_denied",
+ "{body}"
+ );
+
+ assert_no_durable_draft(&client, &db, &base_url, &agent_id, &published_v1).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[serial]
+async fn concurrent_first_edits_with_same_etag_have_one_winner() {
+ let registry = test_registry().await;
+ let db = registry.clone();
+ let storage_root = test_storage_root("agent_catalog_edit_concurrent");
+ let upstream_base_url = spawn_upstream_server().await;
+ let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
+ let client = authorized_client(&base_url).await;
+
+ let operation_id =
+ create_published_operation(&client, &base_url, &upstream_base_url, "edit_race_tool").await;
+ let (agent_id, published_v1) = create_published_agent(
+ &client,
+ &base_url,
+ "edit-race",
+ &operation_id,
+ "edit_race_tool",
+ )
+ .await;
+
+ // Single original precondition taken once from the Published state.
+ let original_etag = agent_etag(&client, &base_url, &agent_id).await;
+ let endpoint = format!("{base_url}/agents/{agent_id}/bindings");
+ let payload_a = json!([binding(&operation_id, "edit_race_tool", "Race Winner A")]);
+ let payload_b = json!([binding(&operation_id, "edit_race_tool", "Race Winner B")]);
+
+ let spawn_edit = |payload: Value, etag: String, endpoint: String| {
+ let client = client.clone();
+ tokio::spawn(async move {
+ let response = client
+ .post(endpoint)
+ .header(reqwest::header::IF_MATCH, etag)
+ .json(&payload)
+ .send()
+ .await
+ .unwrap();
+ let status = response.status();
+ let body = response.json::<Value>().await.unwrap();
+ (status, body)
+ })
+ };
+
+ let first = spawn_edit(payload_a, original_etag.clone(), endpoint.clone());
+ let second = spawn_edit(payload_b, original_etag, endpoint);
+ let (first, second) = tokio::join!(first, second);
+ let results = vec![first.unwrap(), second.unwrap()];
+
+ let successes = results
+ .iter()
+ .filter(|(status, _)| status.is_success())
+ .count();
+ let conflicts = results
+ .iter()
+ .filter(|(status, _)| *status == reqwest::StatusCode::CONFLICT)
+ .count();
+ assert_eq!(
+ successes, 1,
+ "exactly one concurrent first edit must win: {results:?}"
+ );
+ assert_eq!(
+ conflicts, 1,
+ "the losing concurrent first edit must report a stable conflict: {results:?}"
+ );
+
+ let conflict_body = results
+ .iter()
+ .find(|(status, _)| *status == reqwest::StatusCode::CONFLICT)
+ .map(|(_, body)| body)
+ .unwrap();
+ assert_eq!(
+ conflict_body["error"]["code"], "agent_stale_revision",
+ "{conflict_body}"
+ );
+
+ let summary = assert_success_json(
+ client
+ .get(format!("{base_url}/agents/{agent_id}"))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+ assert_eq!(summary["current_draft_version"], 2, "{summary}");
+ assert_eq!(summary["latest_published_version"], 1, "{summary}");
+ assert_eq!(
+ agent_version_count(&db, &agent_id).await,
+ 2,
+ "the losing concurrent edit must not fork a second Draft"
+ );
+
+ let published_after = assert_success_json(
+ client
+ .get(format!("{base_url}/agents/{agent_id}/versions/1"))
+ .send()
+ .await
+ .unwrap(),
+ )
+ .await;
+ assert_eq!(published_after, published_v1);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[serial]
+async fn first_edit_after_operation_archive_leaves_no_durable_draft() {
+ let registry = test_registry().await;
+ let db = registry.clone();
+ let storage_root = test_storage_root("agent_catalog_edit_archive_ordering");
+ let upstream_base_url = spawn_upstream_server().await;
+ let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
+ let client = authorized_client(&base_url).await;
+
+ let live_operation =
+ create_published_operation(&client, &base_url, &upstream_base_url, "edit_order_live").await;
+ let (agent_id, published_v1) = create_published_agent(
+ &client,
+ &base_url,
+ "edit-order",
+ &live_operation,
+ "edit_order_live",
+ )
+ .await;
+
+ let archived_operation = create_published_operation(
+ &client,
+ &base_url,
+ &upstream_base_url,
+ "edit_order_archived",
+ )
+ .await;
+ let operation_etag = operation_etag(&client, &base_url, &archived_operation).await;
+ let archived = client
+ .post(format!(
+ "{base_url}/operations/{archived_operation}/archive"
+ ))
+ .header(reqwest::header::IF_MATCH, operation_etag)
+ .send()
+ .await
+ .unwrap();
+ let archived_status = archived.status();
+ let archived_body = archived.text().await.unwrap();
+ assert!(archived_status.is_success(), "{archived_body}");
+
+ let etag = agent_etag(&client, &base_url, &agent_id).await;
+ let response = client
+ .post(format!("{base_url}/agents/{agent_id}/bindings"))
+ .header(reqwest::header::IF_MATCH, etag)
+ .json(&json!([binding(
+ &archived_operation,
+ "edit_order_archived",
+ "Archived Order Tool"
+ )]))
+ .send()
+ .await
+ .unwrap();
+ let status = response.status();
+ let body = response.text().await.unwrap();
+ assert!(
+ status.is_client_error(),
+ "a first edit that references an archived Operation must be rejected: {status}: {body}"
+ );
+
+ assert_no_durable_draft(&client, &db, &base_url, &agent_id, &published_v1).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[serial]
+async fn first_edit_rejects_when_operation_archives_during_save() {
+ let registry = test_registry().await;
+ let db = registry.clone();
+ let storage_root = test_storage_root("agent_catalog_edit_archive_race");
+ let upstream_base_url = spawn_upstream_server().await;
+ let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
+ let client = authorized_client(&base_url).await;
+
+ let live_operation =
+ create_published_operation(&client, &base_url, &upstream_base_url, "edit_race_live").await;
+ let (agent_id, published_v1) = create_published_agent(
+ &client,
+ &base_url,
+ "edit-archive-race",
+ &live_operation,
+ "edit_race_live",
+ )
+ .await;
+
+ let target_operation =
+ create_published_operation(&client, &base_url, &upstream_base_url, "edit_race_target")
+ .await;
+
+ // Read the edit precondition before taking the Operation lock; Agent detail
+ // may itself inspect bound Operations.
+ let etag_response = client
+ .get(format!("{base_url}/agents/{agent_id}"))
+ .send()
+ .await
+ .unwrap();
+ let etag_status = etag_response.status();
+ let etag = etag_response
+ .headers()
+ .get(reqwest::header::ETAG)
+ .and_then(|value| value.to_str().ok())
+ .map(str::to_owned);
+ let etag_body = etag_response.text().await.unwrap();
+ assert_eq!(
+ etag_status,
+ reqwest::StatusCode::OK,
+ "reading the Agent ETag before the archive race must succeed: {etag_body}"
+ );
+ let etag = etag.expect("Agent detail must expose an ETag");
+
+ // Use an independent pool for the holder and pg_stat_activity monitor. The
+ // fixture registry has one connection, which the request needs to reach the
+ // Operation lock wait.
+ let lock_registry =
+ PostgresRegistry::connect_with_options((*db.pool().connect_options()).clone())
+ .await
+ .unwrap();
+
+ // Hold the target Operation row lock from a separate connection so the edit
+ // transaction cannot complete its binding write until the archive wins.
+ let mut holder = lock_registry.pool().begin().await.unwrap();
+ sqlx::query("select id from operations where workspace_id = $1 and id = $2 for update")
+ .bind(DEFAULT_WORKSPACE_ID)
+ .bind(&target_operation)
+ .fetch_one(&mut *holder)
+ .await
+ .unwrap();
+ let holder_pid: i32 = sqlx::query_scalar("select pg_backend_pid()")
+ .fetch_one(&mut *holder)
+ .await
+ .unwrap();
+ let edit_client = client.clone();
+ let endpoint = format!("{base_url}/agents/{agent_id}/bindings");
+ let edit_target = target_operation.clone();
+ let edit = tokio::spawn(async move {
+ let response = edit_client
+ .post(endpoint)
+ .header(reqwest::header::IF_MATCH, etag)
+ .json(&json!([binding(
+ &edit_target,
+ "edit_race_target",
+ "Archive Race Tool"
+ )]))
+ .send()
+ .await
+ .unwrap();
+ let status = response.status();
+ let body = response.text().await.unwrap();
+ (status, body)
+ });
+
+ // Wait for PostgreSQL to report the request blocked by this exact holder.
+ // If the request completes first (the baseline CAS path), keep going so the
+ // durable-draft assertion below reports that regression directly.
+ let lock_wait = async {
+ loop {
+ if edit.is_finished() {
+ return false;
+ }
+ let blocked: bool = sqlx::query_scalar(
+ "select exists (
+ select 1
+ from pg_stat_activity
+ where wait_event_type = 'Lock'
+ and $1 = any(pg_blocking_pids(pid))
+ and query ilike '%select status from operations%'
+ )",
+ )
+ .bind(holder_pid)
+ .fetch_one(lock_registry.pool())
+ .await
+ .unwrap();
+ if blocked {
+ return true;
+ }
+ tokio::task::yield_now().await;
+ }
+ };
+ let saw_operation_lock_wait =
+ match tokio::time::timeout(std::time::Duration::from_secs(10), lock_wait).await {
+ Ok(saw_wait) => saw_wait,
+ Err(_) => {
+ edit.abort();
+ holder.rollback().await.unwrap();
+ let _ = edit.await;
+ panic!("timed out waiting for the edit to block on the held Operation row lock");
+ }
+ };
+
+ sqlx::query(
+ "update operations
+ set status = 'archived', updated_at = now()
+ where workspace_id = $1 and id = $2",
+ )
+ .bind(DEFAULT_WORKSPACE_ID)
+ .bind(&target_operation)
+ .execute(&mut *holder)
+ .await
+ .unwrap();
+ holder.commit().await.unwrap();
+
+ let (status, body) = edit.await.unwrap();
+ assert!(
+ status.is_client_error(),
+ "an edit racing an Operation archive must be rejected: {status}: {body}"
+ );
+
+ assert_no_durable_draft(&client, &db, &base_url, &agent_id, &published_v1).await;
+ assert!(
+ saw_operation_lock_wait,
+ "a corrected save path must wait on the holder's Operation row lock before archive commits"
+ );
+}