v0.5.1: queue/release_pending, run_phase mcp_config, workflow_status paused/pending

Additive protocol fold-ins surfaced by v0.5.0 production use; all changes
are backward-compatible.

animus-queue-protocol (0.1.0 -> 0.2.0):
- METHOD_QUEUE_RELEASE_PENDING ("queue/release_pending") returns an
  Assigned entry to Pending without canceling it. Fills the gap that
  previously forced the daemon to call queue/completion(cancelled) when
  it discovered a subject was already being worked on by another
  in-flight lease.
- QueueReleasePendingParams { entry_id, reason }
- QueueReleasePendingResponse { entry_id, status }
- New error code QUEUE_ENTRY_NOT_ASSIGNED (-32208); data SHOULD include
  the actual entry status.

animus-workflow-runner-protocol (0.1.0 -> 0.2.0):
- WorkflowPhaseRunRequest.mcp_config: Option<serde_json::Value> mirrors
  WorkflowExecuteRequest.mcp_config so phase-level retries can pass MCP
  server config to the agent runner.
- workflow_status module: PAUSED ("paused") + PENDING ("pending")
  constants previously collapsed to "running" on the wire.
- workflow_status::Parsed + workflow_status::parse() parse helper with
  Unknown(String) fallback documenting the additive-vocabulary contract:
  consumers default-match unknown statuses to Running semantics.

animus-control-protocol:
- Fix pre-existing build break under --all-features: test helper
  sample_event() referenced Subject / SubjectChangedEvent fields that
  do not exist in animus-subject-protocol (native_status,
  status_metadata, attachments, previous_native_status,
  previous_dispatch_label). Strip the stale field assignments so cargo
  clippy --all-targets --all-features passes on the v0.5 branch.

Author: Shooksie

animus-control-protocol/src/client.rs

@@ -939,12 +939,7 @@ mod imp {
                     created_at: Utc::now(),
                     updated_at: Utc::now(),
                     custom: Default::default(),
-                    native_status: None,
-                    status_metadata: serde_json::Value::Null,
-                    attachments: vec![],
                 },
-                previous_native_status: None,
-                previous_dispatch_label: None,
             }
         }
 

animus-queue-protocol/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "animus-queue-protocol"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "MIT"
 authors = ["Launchapp.dev"]

animus-queue-protocol/src/lib.rs

@@ -26,7 +26,7 @@ use serde::{Deserialize, Serialize};
 pub const KIND: &str = "queue";
 
 /// Per-crate semver protocol version.
-pub const PROTOCOL_VERSION: &str = "0.1.0";
+pub const PROTOCOL_VERSION: &str = "0.2.0";
 
 /// Add a dispatch to the queue.
 pub const METHOD_QUEUE_ENQUEUE: &str = "queue/enqueue";
@@ -51,6 +51,11 @@ pub const METHOD_QUEUE_MARK_ASSIGNED: &str = "queue/mark_assigned";
 /// Notify the queue that a workflow has reached a terminal state so the
 /// queue can prune the corresponding assigned entry.
 pub const METHOD_QUEUE_COMPLETION: &str = "queue/completion";
+/// Return an Assigned entry back to Pending without canceling it (used
+/// when the daemon discovers the subject is already being worked on by
+/// another in-flight lease). Distinct from [`METHOD_QUEUE_RELEASE`] which
+/// targets a Held entry.
+pub const METHOD_QUEUE_RELEASE_PENDING: &str = "queue/release_pending";
 
 // =====================================================================
 // Status vocabulary
@@ -248,6 +253,24 @@ pub struct QueueMarkAssignedRequest {
     pub workflow_id: Option<String>,
 }
 
+/// Request for [`METHOD_QUEUE_RELEASE_PENDING`].
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
+pub struct QueueReleasePendingParams {
+    /// Entry id to return to Pending.
+    pub entry_id: String,
+    /// Audit reason describing why the entry is being released back.
+    pub reason: String,
+}
+
+/// Response for [`METHOD_QUEUE_RELEASE_PENDING`].
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
+pub struct QueueReleasePendingResponse {
+    /// Entry id whose status was changed.
+    pub entry_id: String,
+    /// New status — always [`status::PENDING`] on success.
+    pub status: String,
+}
+
 /// Request for [`METHOD_QUEUE_COMPLETION`].
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct QueueCompletionRequest {
@@ -303,6 +326,10 @@ pub mod error_codes {
     pub const QUEUE_LEASE_WORKFLOW_ID_COUNT_MISMATCH: i32 = -32206;
     /// Project root mismatch.
     pub const PROJECT_BINDING_MISMATCH: i32 = -32207;
+    /// Entry was not in Assigned status (e.g., `release_pending` on a
+    /// pending or held entry). The error `data` payload SHOULD include the
+    /// entry's actual status.
+    pub const QUEUE_ENTRY_NOT_ASSIGNED: i32 = -32208;
 }
 
 #[cfg(test)]
@@ -321,6 +348,25 @@ mod tests {
         assert_eq!(back, r);
     }
 
+    #[test]
+    fn release_pending_round_trips() {
+        let p = QueueReleasePendingParams {
+            entry_id: "ent_1".into(),
+            reason: "duplicate-in-flight".into(),
+        };
+        let v = serde_json::to_value(&p).unwrap();
+        let back: QueueReleasePendingParams = serde_json::from_value(v).unwrap();
+        assert_eq!(back, p);
+
+        let r = QueueReleasePendingResponse {
+            entry_id: "ent_1".into(),
+            status: status::PENDING.into(),
+        };
+        let v = serde_json::to_value(&r).unwrap();
+        let back: QueueReleasePendingResponse = serde_json::from_value(v).unwrap();
+        assert_eq!(back, r);
+    }
+
     #[test]
     fn mutation_response_omits_not_found_when_false() {
         let r = QueueMutationResponse {

animus-workflow-runner-protocol/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "animus-workflow-runner-protocol"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "MIT"
 authors = ["Launchapp.dev"]

animus-workflow-runner-protocol/src/lib.rs

@@ -39,25 +39,76 @@ pub const METHOD_WORKFLOW_RUN_PHASE: &str = "workflow/run_phase";
 
 /// Per-crate semver protocol version. Reported via
 /// [`animus_plugin_protocol::KindCapability::crate_version`].
-pub const PROTOCOL_VERSION: &str = "0.1.0";
+pub const PROTOCOL_VERSION: &str = "0.2.0";
 
 // =====================================================================
 // Status vocabulary (referenced from string fields below).
 // =====================================================================
 
 /// Allowed values for [`WorkflowExecuteResult::workflow_status`].
+///
+/// Additive vocabulary policy: consumers MUST default-match unknown status
+/// strings to [`RUNNING`] semantics so older clients continue to behave
+/// safely when newer runners emit values they have not learned yet. New
+/// constants since v0.2.0: [`PAUSED`] and [`PENDING`].
 pub mod workflow_status {
     /// Workflow completed all phases successfully.
     pub const COMPLETED: &str = "completed";
     /// Workflow is still running (returned only when a single phase was
     /// requested or the workflow paused mid-stream).
     pub const RUNNING: &str = "running";
+    /// Workflow is paused for a manual gate; the host MUST NOT advance it.
+    /// Added in protocol v0.2.0.
+    pub const PAUSED: &str = "paused";
+    /// Workflow is queued but has not yet started. Added in protocol
+    /// v0.2.0.
+    pub const PENDING: &str = "pending";
     /// Workflow failed in a terminal way.
     pub const FAILED: &str = "failed";
     /// Workflow was escalated to a human reviewer.
     pub const ESCALATED: &str = "escalated";
     /// Workflow was cancelled by the host or by an upstream signal.
     pub const CANCELLED: &str = "cancelled";
+
+    /// Parsed workflow status, including an `Unknown` fallback so callers
+    /// can default-match forward-compatible wire values without losing the
+    /// original string.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub enum Parsed {
+        /// [`COMPLETED`]
+        Completed,
+        /// [`RUNNING`]
+        Running,
+        /// [`PAUSED`]
+        Paused,
+        /// [`PENDING`]
+        Pending,
+        /// [`FAILED`]
+        Failed,
+        /// [`ESCALATED`]
+        Escalated,
+        /// [`CANCELLED`]
+        Cancelled,
+        /// Wire value not recognized by this version of the protocol crate.
+        /// Consumers SHOULD treat this as [`Parsed::Running`] for safety.
+        Unknown(String),
+    }
+
+    /// Parse a wire status string into [`Parsed`]. Unknown strings round-
+    /// trip via [`Parsed::Unknown`] rather than erroring; this is the
+    /// additive-vocabulary contract.
+    pub fn parse(s: &str) -> Parsed {
+        match s {
+            COMPLETED => Parsed::Completed,
+            RUNNING => Parsed::Running,
+            PAUSED => Parsed::Paused,
+            PENDING => Parsed::Pending,
+            FAILED => Parsed::Failed,
+            ESCALATED => Parsed::Escalated,
+            CANCELLED => Parsed::Cancelled,
+            other => Parsed::Unknown(other.to_string()),
+        }
+    }
 }
 
 /// Allowed values for [`PhaseResultSnapshot::status`] /
@@ -283,6 +334,11 @@ pub struct WorkflowPhaseRunRequest {
     /// Phase routing config (opaque).
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub phase_routing: Option<Value>,
+    /// Opaque MCP runtime config — same shape as
+    /// [`WorkflowExecuteRequest::mcp_config`]. Lets phase-level retries
+    /// pass MCP server config to the agent runner.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mcp_config: Option<Value>,
 }
 
 /// Result of [`METHOD_WORKFLOW_RUN_PHASE`].
@@ -396,6 +452,47 @@ mod tests {
         assert_eq!(back.workflow_ref.as_deref(), Some("standard"));
     }
 
+    #[test]
+    fn workflow_status_parse_recognizes_v02_additions() {
+        use workflow_status::{parse, Parsed};
+        assert_eq!(parse("paused"), Parsed::Paused);
+        assert_eq!(parse("pending"), Parsed::Pending);
+        assert_eq!(parse("running"), Parsed::Running);
+        assert_eq!(parse("completed"), Parsed::Completed);
+        match parse("future-value") {
+            Parsed::Unknown(s) => assert_eq!(s, "future-value"),
+            other => panic!("expected Unknown, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn phase_run_request_carries_mcp_config() {
+        let req = WorkflowPhaseRunRequest {
+            execution_cwd: "/tmp".into(),
+            workflow_id: "wf_1".into(),
+            workflow_ref: "standard".into(),
+            subject_id: "TASK-1".into(),
+            subject_title: "t".into(),
+            subject_description: "d".into(),
+            phase_id: "impl".into(),
+            phase_attempt: 0,
+            phase_timeout_secs: None,
+            model_override: None,
+            tool_override: None,
+            task_complexity: None,
+            rework_context: None,
+            pipeline_vars: HashMap::new(),
+            dispatch_input: None,
+            schedule_input: None,
+            phase_routing: None,
+            mcp_config: Some(serde_json::json!({"servers": []})),
+        };
+        let v = serde_json::to_value(&req).unwrap();
+        assert!(v.get("mcp_config").is_some());
+        let back: WorkflowPhaseRunRequest = serde_json::from_value(v).unwrap();
+        assert_eq!(back.mcp_config, req.mcp_config);
+    }
+
     #[test]
     fn phase_event_round_trips() {
         let e = PhaseEvent::Decision {