reopen --as-draft: closed cards reopen as paused drafts, not armed

Kanban placement family fix (Portolan kanban-ux-rework/placement-pipeline-
invariants): the gestures that move a closed card onto a planning context
mean 'plan this again,' not 'run it now,' so they must not write
status:active (the sole dispatch gate — a naive reopen both misplaced the
card and auto-spawned a worker).

- shuttle-ctl: `reopen --as-draft` → status:open, verdict + closed-at
  cleared.
- Actions mapping: closed + drafts → reopen-draft (all kinds, including a
  cyclical role's awaiting run — parking a role is not a compost verdict);
  closed + awaitingReview → close-awaiting-review (revoke verdict, stay in
  review — reopen used to arm it and snap it to In flight);
  open + drafts → pause (reopen used to arm a draft dropped back on
  Drafts from the timeline/stash).
- Transition: reopen-draft shells `reopen --as-draft` offline.

Portolan's no-snap-back property suite (KanbanGestures.property.test.ts)
models this mapping clause-for-clause; change them together.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: cailmdaley

cmd/shuttle/lifecycle.go

@@ -285,6 +285,8 @@ until they are reopened.`,
 	},
 }
 
+var reopenAsDraft bool
+
 var reopenCmd = &cobra.Command{
 	Use:   "reopen <fiber>",
 	Short: "Requeue a closed or reviewed fiber back into active work",
@@ -293,7 +295,12 @@ card re-enters the in-flight loop. status:active is the sole dispatch gate
 (slice 5: no enabled flag).
 
 This is the canonical reopen path for Kanban requeues from Awaiting review,
-Tempered, or Composted back to In flight.`,
+Tempered, or Composted back to In flight.
+
+With --as-draft, sets status = open instead: the card reopens as a PAUSED
+DRAFT — visible on the board, never auto-dispatched. This is the verb behind
+the kanban's "drag a closed card onto Drafts / a future date / the stash"
+gestures, where the user means "plan this again," not "run it now."`,
 	Args: cobra.ExactArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
 		path, _, _ := resolveFiber(args[0])
@@ -306,19 +313,23 @@ Tempered, or Composted back to In flight.`,
 			return err
 		}
 
+		status := "active"
+		if reopenAsDraft {
+			status = "open"
+		}
 		statusBefore := f.Status()
-		f.SetStatus("active")
+		f.SetStatus(status)
 		f.SetTempered(nil)
 		f.ClearClosedAt()
 		if err := f.WriteBlock(f.Block); err != nil {
 			return fmt.Errorf("writing fiber: %w", err)
 		}
 
-		fmt.Printf("reopened %s (status: active)\n", args[0])
+		fmt.Printf("reopened %s (status: %s)\n", args[0], status)
 		if statusBefore == "" {
-			fmt.Println("  status: active (set; was missing)")
-		} else if statusBefore != "active" {
-			fmt.Printf("  status: %s → active\n", statusBefore)
+			fmt.Printf("  status: %s (set; was missing)\n", status)
+		} else if statusBefore != status {
+			fmt.Printf("  status: %s → %s\n", statusBefore, status)
 		}
 		fmt.Println("  cleared: tempered, closed-at")
 		return nil
@@ -676,6 +687,8 @@ func init() {
 	rootCmd.AddCommand(pauseCmd)
 	rootCmd.AddCommand(resumeCmd)
 	rootCmd.AddCommand(closeCmd)
+	reopenCmd.Flags().BoolVar(&reopenAsDraft, "as-draft", false,
+		"reopen to status: open (a paused draft, not auto-dispatched) instead of status: active")
 	rootCmd.AddCommand(reopenCmd)
 	rootCmd.AddCommand(setOutcomeCmd)
 	rootCmd.AddCommand(acceptCmd)

cmd/shuttle/lifecycle_test.go

@@ -1450,6 +1450,48 @@ Body.
 	}
 }
 
+func TestReopenCmd_AsDraftReopensToOpenNotArmed(t *testing.T) {
+	host, cleanup := withTempHost(t)
+	defer cleanup()
+
+	// --as-draft is the kanban's "plan this again" verb: a closed card dragged
+	// to Drafts / a future date / the stash reopens as a PAUSED DRAFT
+	// (status:open, verdict + closed-at cleared) — never status:active, which
+	// is the dispatch gate and would auto-spawn a worker (the slides
+	// snap-back; Portolan kanban-ux-rework/placement-pipeline-invariants).
+	path := writeFiber(t, host, "slides", `---
+name: Slides
+status: closed
+tempered: true
+closed-at: 2026-06-01T09:30:00Z
+shuttle:
+  kind: oneshot
+---
+
+Body.
+`)
+
+	reopenAsDraft = true
+	defer func() { reopenAsDraft = false }()
+	if err := reopenCmd.RunE(reopenCmd, []string{"slides"}); err != nil {
+		t.Fatalf("RunE: %v", err)
+	}
+
+	text := readFiberText(t, path)
+	if !strings.Contains(text, "status: open") {
+		t.Fatalf("expected status: open after reopen --as-draft:\n%s", text)
+	}
+	if strings.Contains(text, "status: active") {
+		t.Fatalf("reopen --as-draft must NOT arm the dispatch gate:\n%s", text)
+	}
+	if strings.Contains(text, "tempered") {
+		t.Fatalf("reopen --as-draft should clear the verdict:\n%s", text)
+	}
+	if strings.Contains(text, "closed-at") || strings.Contains(text, "closed_at") {
+		t.Fatalf("reopen --as-draft should clear closed-at:\n%s", text)
+	}
+}
+
 func TestCloseCmd_OneshotWritesNoReviewBlock(t *testing.T) {
 	host, cleanup := withTempHost(t)
 	defer cleanup()

lib/shuttle/actions.ex

@@ -10,14 +10,15 @@ defmodule Shuttle.Actions do
   @type action_id ::
           :pause
           | :reopen
+          | :reopen_draft
           | :accept_run
           | :dispatch_ad_hoc
           | :close_awaiting_review
           | :close_tempered
           | :close_composted
 
   @transition_targets ~w(drafts inFlight queued active awaitingReview tempered composted)
-  @action_ids ~w(pause reopen accept-run dispatch-ad-hoc close-awaiting-review close-tempered close-composted)
+  @action_ids ~w(pause reopen reopen-draft accept-run dispatch-ad-hoc close-awaiting-review close-tempered close-composted)
 
   @spec actions_for(map(), boolean()) :: [map()]
   def actions_for(fiber, running? \\ false) when is_map(fiber) do
@@ -97,8 +98,10 @@ defmodule Shuttle.Actions do
       # pending a human verdict" — felt-native, no `review.state`. Only a
       # STANDING role re-arms (a oneshot closes for good). The verdict gestures:
       # inFlight/tempered = keep it (accept-run → advance the schedule),
-      # drafts/composted = reject (close-composted), awaitingReview = no-op (a
-      # same-column drop stays in review). This clause MUST precede the generic
+      # composted = reject (close-composted), drafts = park the role as a
+      # paused draft (reopen-draft — stopping a role for now is not the same
+      # verdict as composting it), awaitingReview = no-op (a same-column drop
+      # stays in review). This clause MUST precede the generic
       # `status == "closed"` clauses below — those resolve a closed fiber to
       # reopen/close, which would TERMINATE the role instead of re-arming it
       # (the slice-1 entanglement). Tempered-true and composted (tempered:false)
@@ -108,24 +111,36 @@ defmodule Shuttle.Actions do
         :accept_run
 
       status == "closed" and cyclical?(shuttle) and untempered?(fiber) and
-          target in ["drafts", "composted"] ->
+          target == "composted" ->
         :close_composted
 
       status == "closed" and cyclical?(shuttle) and untempered?(fiber) and
           target == "awaitingReview" ->
         :close_awaiting_review
 
-      # A closed fiber's only forward move is reopen (which clears closed_at /
-      # tempered); shuttle-ctl refuses a direct pause/close on an already-closed
-      # fiber. Portolan's un-temper sequence drags through inFlight first for
-      # the other open-lifecycle targets, so every non-close target collapses to
-      # reopen here. The close columns re-close with the chosen verdict. This
-      # group now catches oneshot termini and tempered/composted standing
-      # termini; the awaiting (closed + untempered + standing) case is handled
-      # above and never reaches here.
-      status == "closed" and target in ["drafts", "inFlight", "awaitingReview"] ->
+      # A closed fiber dragged to Drafts reopens AS A DRAFT (status:open,
+      # verdict cleared — `shuttle reopen --as-draft`): the gesture means
+      # "plan this again," not "run it now," so it must not arm the dispatch
+      # gate. This is also the park-as-draft verb the kanban composes before
+      # a planning-surface drop (timeline date / stash) on a closed card —
+      # the slides snap-back fix (see Portolan
+      # kanban-ux-rework/placement-pipeline-invariants).
+      status == "closed" and target == "drafts" ->
+        :reopen_draft
+
+      # inFlight is the one closed-card target that ARMS: reopen → active.
+      # (The kanban actually launches via force-dispatch, which reopens en
+      # route; this mapping keeps the bare transition coherent.)
+      status == "closed" and target == "inFlight" ->
         :reopen
 
+      # Dragging a tempered/composted card back to Awaiting review revokes the
+      # verdict but keeps the card closed: re-close with tempered cleared.
+      # (Resolving this to reopen — as it once did — armed the card and
+      # snapped it to In flight instead of Awaiting review.)
+      status == "closed" and target == "awaitingReview" ->
+        :close_awaiting_review
+
       status == "closed" and target == "tempered" ->
         :close_tempered
 
@@ -134,9 +149,13 @@ defmodule Shuttle.Actions do
 
       # A draft (`status: open`) is paused/not-yet-armed (slice 5: status is the
       # sole gate, no enabled flag). Dragging it out of drafts arms it via
-      # reopen (→ status:active); a drop back in drafts is a no-op pause. The
-      # close columns close it with the chosen verdict.
-      status == "open" and target in ["drafts", "inFlight"] ->
+      # reopen (→ status:active). A drop ON drafts (reachable from the timeline
+      # / stash surfaces) parks it — pause, an idempotent no-op for an open
+      # fiber — never reopen, which would arm and snap the card to In flight.
+      status == "open" and target == "drafts" ->
+        :pause
+
+      status == "open" and target == "inFlight" ->
         :reopen
 
       # An armed fiber (`status: active`). drafts parks it (pause → status:open).
@@ -166,6 +185,7 @@ defmodule Shuttle.Actions do
 
   defp invocation(:pause), do: %{verb: "pause"}
   defp invocation(:reopen), do: %{verb: "reopen"}
+  defp invocation(:reopen_draft), do: %{verb: "reopen", as_draft: true}
   defp invocation(:accept_run), do: %{verb: "accept"}
   defp invocation(:dispatch_ad_hoc), do: %{verb: "dispatch", ad_hoc: true}
   defp invocation(:close_awaiting_review), do: %{verb: "close"}

lib/shuttle/transition.ex

@@ -144,6 +144,13 @@ defmodule Shuttle.Transition do
 
   defp invoke_action(fiber_id, "reopen", host), do: run_offline(["reopen", fiber_id], host)
 
+  # reopen-draft: status:open + verdict cleared — a paused draft, NOT armed.
+  # The kanban's "drag a closed card to Drafts" verb, and the park-as-draft
+  # half it composes before a planning-surface drop on a closed card (the
+  # slides snap-back fix; see Portolan kanban-ux-rework/placement-pipeline-invariants).
+  defp invoke_action(fiber_id, "reopen-draft", host),
+    do: run_offline(["reopen", fiber_id, "--as-draft"], host)
+
   # accept-run goes through the in-process lifecycle path so the felt-document
   # re-arm happens atomically against poll cycles, not the Go `shuttle-ctl
   # accept` (which can race a concurrent poll's document read).

lib/shuttle_web/controllers/lifecycle_controller.ex

@@ -21,7 +21,7 @@ defmodule ShuttleWeb.LifecycleController do
 
   alias Shuttle.{FeltStores, LifecycleService, OriginRouter}
 
-  @allowed ~w(install pause resume repeat pin accept set-model set-outcome uninstall)
+  @allowed ~w(install pause resume repeat pin accept set-model set-agent set-outcome uninstall)
 
   def create(conn, params) do
     case OriginRouter.route(Map.get(params, "origin")) do
@@ -87,7 +87,7 @@ defmodule ShuttleWeb.LifecycleController do
   end
 
   defp execute(action, %{"fiber" => fiber} = params)
-       when action in ~w(pause set-model set-outcome uninstall) do
+       when action in ~w(pause set-model set-agent set-outcome uninstall) do
     with {:ok, fiber_id} <- fiber_address(fiber) do
       action
       |> args_for(%{params | "fiber" => fiber_id})
@@ -156,6 +156,31 @@ defmodule ShuttleWeb.LifecycleController do
   defp args_for("set-model", %{"fiber" => fiber, "agent" => agent}),
     do: {:ok, ["set-model", fiber, agent]}
 
+  # set-agent composes base agent × effort × chrome in one validated write.
+  # The agent positional is optional (omit to mutate only axes); effort and
+  # chrome are forwarded only when present so an unspecified axis is left
+  # untouched. Chrome renders `--chrome` / `--chrome=false` (cobra reads
+  # Changed), and effort passes through verbatim — including `--effort ""` to
+  # clear back to the harness default.
+  defp args_for("set-agent", %{"fiber" => fiber} = params) do
+    args = ["set-agent", fiber]
+    args = if(is_binary(params["agent"]) and params["agent"] != "", do: args ++ [params["agent"]], else: args)
+
+    args =
+      case params do
+        %{"effort" => effort} when is_binary(effort) -> args ++ ["--effort", effort]
+        _ -> args
+      end
+
+    args =
+      case params do
+        %{"chrome" => chrome} when is_boolean(chrome) -> args ++ ["--chrome=#{chrome}"]
+        _ -> args
+      end
+
+    {:ok, args}
+  end
+
   # The outcome string round-trips as a single argv element, so multi-line
   # values (block scalars) survive without stdin piping. set-outcome refuses a
   # block-less fiber and runs `ensure_owned_here`, so a misrouted edit surfaces

test/shuttle/actions_test.exs

@@ -38,7 +38,10 @@ defmodule Shuttle.ActionsTest do
     assert {:ok, %{id: "close-composted", invocation: %{verb: "close", tempered: false}}} =
              Actions.resolve_transition(fiber, "composted")
 
-    assert {:ok, %{id: "close-composted"}} = Actions.resolve_transition(fiber, "drafts")
+    # Drafts parks the role as a paused draft — a "stop for now," not a
+    # compost verdict (reopen-draft → status:open, never armed).
+    assert {:ok, %{id: "reopen-draft", invocation: %{verb: "reopen", as_draft: true}}} =
+             Actions.resolve_transition(fiber, "drafts")
 
     assert {:ok, %{id: "close-awaiting-review"}} =
              Actions.resolve_transition(fiber, "awaitingReview")
@@ -229,11 +232,18 @@ defmodule Shuttle.ActionsTest do
       assert {:ok, %{id: "close-composted", invocation: %{verb: "close", tempered: false}}} =
                Actions.resolve_transition(fiber, "composted")
 
-      # The open-lifecycle columns still reopen (clears closed_at / tempered);
-      # accept-run must NOT appear for a closed role that already has a verdict.
-      for target <- ~w(drafts inFlight awaitingReview) do
-        assert {:ok, %{id: "reopen"}} = Actions.resolve_transition(fiber, target)
-      end
+      # The open-lifecycle columns clear the verdict, each with the meaning of
+      # its own column: inFlight arms (reopen → active), drafts parks as a
+      # paused draft (reopen-draft → open), awaitingReview re-closes with the
+      # verdict cleared (back to review). accept-run must NOT appear for a
+      # closed role that already has a verdict.
+      assert {:ok, %{id: "reopen"}} = Actions.resolve_transition(fiber, "inFlight")
+
+      assert {:ok, %{id: "reopen-draft", invocation: %{verb: "reopen", as_draft: true}}} =
+               Actions.resolve_transition(fiber, "drafts")
+
+      assert {:ok, %{id: "close-awaiting-review"}} =
+               Actions.resolve_transition(fiber, "awaitingReview")
 
       available = Actions.actions_for(fiber) |> Enum.map(& &1.id)
       refute "accept-run" in available

test/shuttle_web/controllers/lifecycle_controller_test.exs

@@ -109,6 +109,48 @@ defmodule ShuttleWeb.LifecycleControllerTest do
              "set-outcome\ntests/outcome-edit\n--outcome\nBlocked: waiting on ADS token\nsecond line\n"
   end
 
+  # set-agent composes base agent × effort × chrome in one validated write.
+  # The agent positional is optional and the axes ride as flags; chrome always
+  # renders explicitly (`--chrome=true|false`) so a toggle-off is unambiguous,
+  # and effort passes through verbatim.
+  test "set-agent forwards agent plus effort and chrome axes to shuttle-ctl" do
+    root =
+      System.tmp_dir!()
+      |> Path.join("shuttle-lifecycle-set-agent-#{System.unique_integer([:positive])}")
+
+    store = Path.join(root, "loom")
+    fiber_dir = Path.join([store, ".felt", "tests", "axes-edit"])
+    File.mkdir_p!(fiber_dir)
+    File.write!(Path.join(fiber_dir, "axes-edit.md"), "---\nname: Axes edit\n---\n\n")
+
+    args_file = install_fake_shuttle_ctl!()
+    old_loom_homes = System.get_env("LOOM_HOMES")
+    System.put_env("LOOM_HOMES", store)
+
+    on_exit(fn ->
+      restore_env("LOOM_HOMES", old_loom_homes)
+      File.rm_rf(root)
+    end)
+
+    conn =
+      post(
+        api_conn(),
+        "/api/v1/lifecycle",
+        Jason.encode!(%{
+          "action" => "set-agent",
+          "fiber" => "tests/axes-edit",
+          "agent" => "claude-opus",
+          "effort" => "xhigh",
+          "chrome" => true
+        })
+      )
+
+    assert conn.status == 200
+
+    assert File.read!(args_file) ==
+             "set-agent\ntests/axes-edit\nclaude-opus\n--effort\nxhigh\n--chrome=true\n"
+  end
+
   test "accept for standing roles re-arms from the doc and evicts runtime frontmatter" do
     root =
       System.tmp_dir!()