scheduled prompts: edit existing schedule (closes #474)

hive-ag3nt/prompts/manager.md

@@ -14,6 +14,7 @@ Tools (hyperhive surface):
 - `mcp__hyperhive__request_schedule_prompt(targets, body, first_fire_at_unix, interval_seconds?, description?)` — queue an approval for the operator to add a scheduled prompt. On approve hive-c0re inserts a schedule row and the worker fans `body` out to each agent in `targets` at `first_fire_at_unix` (recurring every `interval_seconds` if set, one-shot when absent). Even self-targeted schedules go through approval — the existing `remind` tool stays the quick no-approval self-wake path. Catch-up clamp: long downtime fires ONCE per recurring row on resume (skipped count surfaces in per-target `last_result`), not N stacked pulses.
 - `mcp__hyperhive__cancel_schedule(id, targets?)` — cancel a schedule. Omit `targets` / pass empty to cancel the whole schedule; pass a list to cancel just those recipients (the schedule keeps firing for any remaining active targets, auto-cancels when every target is gone). Authorization: you can cancel schedules you own OR any owned by a sub-agent in your subtree per topology.json.
 - `mcp__hyperhive__fire_schedule_now(id)` — fire a scheduled prompt out of band. Runs the per-target fan-out once immediately. Recurring schedules keep their cadence intact (the manual fire is additive); one-shot schedules are CONSUMED by the manual fire (cancelled afterwards). Same authorization as `cancel_schedule`.
+- `mcp__hyperhive__edit_schedule(id, body?, description?, interval_seconds?, next_fire_at_unix?)` — partial-update a schedule's mutable fields (#474). Pass only the fields you want to change. Targets stay immutable (cancel + new schedule is the workaround). Refuses cancelled rows. Same authorization as `cancel_schedule`. Note: clearing fields (e.g. flipping recurring→one-shot) is operator-only via the dashboard PATCH — the agent surface only supports positive sets.
 - `mcp__hyperhive__list_schedules()` — snapshot every schedule in the queue (active + cancelled-but-not-reaped). Returns id, owner, body, target set with per-target `last_fired_at` + `last_result`, `next_fire_at_unix`, recurring `interval_seconds`. Use to look up an id before cancelling, or to audit upcoming wake-ups across the swarm.
 - `mcp__hyperhive__get_logs(agent, lines?)` — fetch recent journal lines for a sub-agent container. Use to diagnose MCP-server registration failures, startup crashes, or harness issues you can't see from inside. Pass the plain logical agent name; `lines` defaults to 50 (capped at 500).
 - `mcp__hyperhive__ask(question, options?, multi?, ttl_seconds?, to?)` — surface a structured question to the operator (default, or `to: "operator"`) OR a sub-agent (`to: "<agent-name>"`). Returns immediately with a question id; the answer arrives later as a system `question_answered { id, question, answer, answerer }` event in your inbox. Options are advisory: the dashboard always lets the operator type a free-text answer in addition. Set `multi: true` to render options as checkboxes (operator can pick multiple); the answer comes back as `, `-separated. Set `ttl_seconds` to auto-cancel after a deadline (capped at 6h server-side) — on expiry the answer is `[expired]` and `answerer` is `"ttl-watchdog"`. Do not poll inside the same turn — finish the current work and react when the event lands.

hive-ag3nt/src/mcp.rs

@@ -981,6 +981,33 @@ pub struct CancelScheduleArgs {
     pub targets: Option<Vec<String>>,
 }
 
+#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
+pub struct EditScheduleArgs {
+    /// Schedule id from a prior `list_schedules` call or the
+    /// approval-resolved event for a `request_schedule_prompt`.
+    pub id: i64,
+    /// New body text. Omit to keep the existing one.
+    #[serde(default)]
+    pub body: Option<String>,
+    /// New description. Omit to keep the existing one. (To CLEAR
+    /// the description, use the dashboard PATCH endpoint
+    /// directly — the agent surface intentionally keeps the args
+    /// flat / non-nullable to dodge the doubly-wrapped Option
+    /// schemars quirk; clearing fields is rare and operator-side.)
+    #[serde(default)]
+    pub description: Option<String>,
+    /// Recurring interval in seconds. Omit to keep the existing
+    /// cadence; pass an explicit value to set a new one. Toggling
+    /// recurring↔one-shot (clearing the interval) is operator-only
+    /// for the same reason as `description` above.
+    #[serde(default)]
+    pub interval_seconds: Option<u64>,
+    /// New absolute unix timestamp for the next fire. Omit to
+    /// leave the schedule on its current cadence.
+    #[serde(default)]
+    pub next_fire_at_unix: Option<i64>,
+}
+
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
 pub struct GetLogsArgs {
     /// Logical agent name to fetch logs for (e.g. `gui`, `hm1nd`).
@@ -1327,6 +1354,44 @@ impl ManagerServer {
         .await
     }
 
+    #[tool(
+        description = "Edit an existing scheduled prompt's mutable fields (#474). Pass only \
+        the fields you want to change — anything omitted keeps its current value. Editable: \
+        `body`, `description`, `interval_seconds` (positive only via this tool; flipping \
+        recurring→one-shot is operator-only via the dashboard), `next_fire_at_unix`. \
+        Targets are immutable: per-target last-result history is keyed on them. To change \
+        the recipient list, cancel and submit a new schedule. \n\n\
+        Authorization mirrors `cancel_schedule` / `fire_schedule_now`: you can edit your \
+        own schedules + any owned by a sub-agent in your subtree per topology.json. \
+        Refuses cancelled schedules (the row's terminal — submit a fresh one)."
+    )]
+    async fn edit_schedule(&self, Parameters(args): Parameters<EditScheduleArgs>) -> String {
+        let log = format!("{args:?}");
+        run_tool_envelope("edit_schedule", log, async move {
+            let id = args.id;
+            let (resp, retries) = self
+                .dispatch(hive_sh4re::ManagerRequest::EditSchedule {
+                    id: args.id,
+                    body: args.body,
+                    // The agent-side args use plain Option<T>; the
+                    // manager wire type's `Some(None)` ("set to
+                    // null") cases stay operator-exclusive, so we
+                    // promote agent-supplied values into
+                    // `Some(Some(v))` and omit when the agent
+                    // didn't pass a value.
+                    description: args.description.map(Some),
+                    interval_seconds: args.interval_seconds.map(Some),
+                    next_fire_at_unix: args.next_fire_at_unix,
+                })
+                .await;
+            annotate_retries(
+                format_ack(resp, "edit_schedule", format!("edited #{id}")),
+                retries,
+            )
+        })
+        .await
+    }
+
     #[tool(
         description = "List every scheduled prompt in the queue (active + cancelled but \
         not yet reaped). Returns the full snapshot — schedule id, owner, body, target set \