cardinal-ai 0.0.1 → 0.2.4

data/app/controllers/application_controller.rb

@@ -0,0 +1,7 @@
+class ApplicationController < ActionController::Base
+  # Only allow modern browsers supporting webp images, web push, badges, import maps, CSS nesting, and CSS :has.
+  allow_browser versions: :modern
+
+  # Changes to the importmap will invalidate the etag for HTML responses
+  stale_when_importmap_changes
+end

data/app/controllers/boards_controller.rb

@@ -0,0 +1,5 @@
+class BoardsController < ApplicationController
+  def show
+    @board = Board.includes(columns: :cards).first!
+  end
+end

data/app/controllers/cards_controller.rb

@@ -0,0 +1,129 @@
+class CardsController < ApplicationController
+  before_action :set_card, only: [:show, :update, :move, :approve, :destroy]
+
+  def new
+    @board = Board.first!
+    @parent = @board.cards.find_by(id: params[:parent_id])
+  end
+
+  def create
+    board = Board.first!
+    column = board.columns.inbox.order(:position).first || board.columns.first
+    parent = board.cards.find_by(id: params.dig(:card, :parent_id))
+    card = board.cards.create!(column:, parent:, **card_params)
+    card.log!("status_change", actor: "user", text: parent ? "Card created as a child of ##{parent.number} #{parent.title}" : "Card created")
+    parent&.log!("status_change", actor: "user", text: "Child card added: #{card.title}")
+    redirect_to root_path
+  end
+
+  # Rarely needed, deliberately buried in the card modal. A working card must
+  # be cancelled first — no killing live agents by deleting their card.
+  def destroy
+    if @card.working?
+      redirect_to card_path(@card)
+      return
+    end
+    workspace_path = Agent::Workspace::Local.new(@card).path
+    @card.destroy!
+    FileUtils.rm_rf(workspace_path)
+    redirect_to root_path
+  end
+
+  def show
+    @zoom = params[:zoom].presence_in(%w[conversation activity debug]) || "conversation"
+    @events = case @zoom
+              when "conversation" then @card.events.conversation
+              when "activity" then @card.events.activity
+              else @card.events
+              end
+
+    # A frame navigation (opening the modal from the board) only needs the modal
+    # frame. A direct visit — bookmark, reload, or history restore of /cards/:id —
+    # must render the whole board with the modal already open behind it.
+    unless turbo_frame_request?
+      @board = @card.board
+      render "boards/show"
+    end
+  end
+
+  def update
+    attrs = card_params
+    attrs.delete(:title) if params[:autosave] && attrs[:title].blank? # mid-edit blank, not a delete
+    # branch_name and pr_url lock once set (by the user or the agent) — never
+    # let a later edit clobber a value that work may already depend on.
+    attrs.delete(:branch_name) if @card.branch_name.present?
+    attrs.delete(:pr_url) if @card.pr_url.present?
+    @card.update!(attrs)
+    log_changelog!
+
+    respond_to do |format|
+      # Explicitly patch the board face in this tab too — Turbo suppresses a
+      # tab's own refresh broadcasts, so the morph won't cover the originator.
+      # Autosave must NOT replace the modal (it would steal focus mid-typing).
+      format.turbo_stream do
+        streams = [turbo_stream.replace(helpers.dom_id(@card), partial: "cards/card", locals: { card: @card })]
+        unless params[:autosave]
+          @zoom = "conversation"
+          @events = @card.events.conversation
+          streams << turbo_stream.replace("modal", template: "cards/show", formats: [:html])
+        end
+        render turbo_stream: streams
+      end
+      format.html { redirect_to card_path(@card) }
+    end
+  end
+
+  # Review verdicts (§3, §14.2). Approve is reversible — the merge happens as
+  # Done's entry rule when the human drags the card there.
+  def approve
+    if @card.in_review?
+      @card.update!(status: "approved")
+      @card.log!("status_change", actor: "user", text: "Work approved — drag to Done to ship")
+    end
+    redirect_to card_path(@card)
+  end
+
+  def move
+    from_column = @card.column
+    to_column = @card.board.columns.find(params[:column_id])
+    result = CardTransition.new(@card, to_column: to_column, position: params[:position]&.to_i).call
+    if result.success?
+      # Fresh markup for the affected columns: Turbo suppresses this tab's own
+      # refresh broadcasts, so without this the dragged card keeps its stale
+      # face (no queued ghosting, no ticker bump) until a job-thread broadcast.
+      render turbo_stream: [from_column, to_column].uniq.map { |col|
+        turbo_stream.replace(helpers.dom_id(col), partial: "columns/column", locals: { column: col.reload })
+      }
+    else
+      render json: { error: result.error }, status: :unprocessable_entity
+    end
+  end
+
+  private
+
+  def set_card
+    @card = Board.first!.cards.find_by!(number: params[:id])
+  end
+
+  def card_params
+    attrs = params.require(:card).permit(:title, :description, :tags, :branch_name, :pr_url)
+    attrs[:tags] = attrs[:tags].to_s.split(",").map(&:strip).reject(&:blank?) if attrs.key?(:tags)
+    attrs.to_h.symbolize_keys
+  end
+
+  # Changelog in the activity timeline (the mechanism already exists). A burst
+  # of autosaves coalesces into one entry instead of one per pause-in-typing.
+  def log_changelog!
+    changed = @card.previous_changes.keys & %w[title description tags branch_name pr_url]
+    return if changed.empty?
+
+    last = @card.events.order(:id).last
+    if last&.kind == "status_change" && last.payload["changelog"] && last.created_at > 10.minutes.ago
+      fields = (Array(last.payload["fields"]) | changed)
+      last.update!(payload: last.payload.merge("fields" => fields, "text" => "Details edited: #{fields.join(", ")}"))
+    else
+      @card.log!("status_change", actor: "user", changelog: true, fields: changed,
+                 text: "Details edited: #{changed.join(", ")}")
+    end
+  end
+end

data/app/controllers/columns_controller.rb

@@ -0,0 +1,130 @@
+class ColumnsController < ApplicationController
+  before_action :set_column, only: [:edit, :update, :destroy]
+
+  def create
+    board = Board.first!
+    attrs = params.require(:column).permit(:name, :archetype)
+    # Inbox is the board's single intake and can't be created a second time
+    # (card #17) — refuse it even from a crafted request, and default any
+    # blank/invalid archetype to a non-special stage rather than inbox.
+    archetype = (attrs[:archetype].presence_in(Column::ARCHETYPES - %w[inbox])) || "planning"
+    board.columns.create!(
+      name: attrs[:name],
+      archetype: archetype,
+      position: (board.columns.maximum(:position) || -1) + 1,
+      policy: {}
+    )
+    redirect_to root_path
+  end
+
+  def edit
+  end
+
+  # The gear modal is the entire policy admin surface (§1, §14.3).
+  def update
+    attrs = params.require(:column).permit(
+      :name, :archetype, :instructions, :model, :effort,
+      :concurrency_limit, :max_turns, :timeout_minutes, :plan_approval,
+      :on_entry_text, :on_entry_json, :color, :custom_color, :arrivals, :ai,
+      accepts_from: []
+    )
+
+    policy = @column.policy.dup
+    %w[instructions model effort].each { |k| policy[k] = attrs[k].presence }
+    policy["color"] = attrs[:custom_color] == "1" && attrs[:color].to_s.match?(/\A#\h{6}\z/) ? attrs[:color] : nil
+    %w[concurrency_limit max_turns timeout_minutes].each do |k|
+      policy[k] = attrs[k].present? ? attrs[k].to_i : nil
+    end
+    policy["plan_approval"] = attrs[:plan_approval] == "1"
+    policy["arrivals"] = attrs[:arrivals].presence_in(%w[top bottom])
+    policy["ai"] = (attrs[:ai] == "1") if attrs.key?(:ai) # inbox forms omit it — never AI anyway
+    # Accept policy (card #15): store allowed source column ids as strings.
+    # EXPLICIT ONLY — an empty list means the column accepts from nowhere.
+    policy["accepts_from"] = attrs[:accepts_from].to_a.map(&:to_s).reject(&:blank?).presence
+
+    # Archetype is a TEMPLATE: switching it re-stamps rules + instructions
+    # from the new archetype (the submitted fields belong to the old one).
+    new_archetype = @column.inbox? ? "inbox" : (attrs[:archetype].presence_in(Column::ARCHETYPES - %w[inbox]) || @column.archetype)
+    @archetype_changed = new_archetype != @column.archetype
+    if @archetype_changed
+      template = Column::ARCHETYPE_TEMPLATES.fetch(new_archetype, {})
+      %w[on_entry on_entry_text instructions].each { |k| policy[k] = template[k] }
+    end
+
+    # Rules: plain English is the source of truth (compiled on change); the
+    # advanced JSON editor applies only when the English box is empty.
+    if !@archetype_changed && attrs[:on_entry_text].present?
+      if attrs[:on_entry_text].strip != policy["on_entry_text"].to_s.strip
+          begin
+          policy["on_entry"] = Rules::Compiler.compile(attrs[:on_entry_text])
+        rescue Rules::Compiler::Error => e
+          return column_error(e.message)
+        end
+      end
+      policy["on_entry_text"] = attrs[:on_entry_text].strip
+    elsif !@archetype_changed && attrs[:on_entry_json].present?
+      begin
+        policy["on_entry"] = JSON.parse(attrs[:on_entry_json])
+        policy.delete("on_entry_text")
+      rescue JSON::ParserError => e
+        return column_error("on_entry is not valid JSON: #{e.message.truncate(120)}")
+      end
+    elsif !@archetype_changed
+      policy.delete("on_entry")
+      policy.delete("on_entry_text")
+    end
+
+    @column.update!(
+      name: attrs[:name].presence || @column.name,
+      archetype: new_archetype,
+      policy: policy.compact
+    )
+
+    if params[:autosave]
+      # Silent save: patch the board's column section + clear any prior error.
+      # No modal replace — it would steal focus mid-edit.
+      streams = [
+        turbo_stream.replace(helpers.dom_id(@column), partial: "columns/column", locals: { column: @column.reload }),
+        turbo_stream.update("column-form-errors", "")
+      ]
+      # A re-stamped archetype must re-render the modal (its fields changed
+      # server-side); focus loss is fine — the user just picked from a select.
+      streams << turbo_stream.replace("modal", template: "columns/edit", formats: [:html]) if @archetype_changed
+      render turbo_stream: streams
+    else
+      redirect_to root_path
+    end
+  end
+
+  # Autosave-friendly error: surface in the modal without re-rendering the form.
+  def column_error(message)
+    if params[:autosave]
+      render turbo_stream: turbo_stream.update(
+        "column-form-errors",
+        helpers.tag.p("#{message} — this field was NOT saved.", class: "form-error")
+      ), status: :unprocessable_entity
+    else
+      @json_error = message
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    if @column.inbox?
+      # The Tasks/inbox column is the board's intake — cards enter the flow here
+      # to be triaged. It can never be deleted (card #17).
+      @json_error = "The Tasks column is the board's intake and can't be deleted."
+      render :edit, status: :unprocessable_entity
+    elsif @column.cards.none?
+      @column.destroy!
+      redirect_to root_path
+    else
+      @json_error = "Column still has cards — move them first."
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  private
+
+  def set_column = @column = Column.find(params[:id])
+end

data/app/controllers/messages_controller.rb

@@ -0,0 +1,25 @@
+class MessagesController < ApplicationController
+  def create
+    card = Board.first!.cards.find_by!(number: params[:card_id])
+    text = params.require(:message)[:text]
+    parked_run = card.runs.where(status: "needs_input").order(:id).last
+
+    if parked_run
+      # Answer / plan feedback: goes back into the same agent session.
+      kind = parked_run.phase == "plan" ? "user_message" : "answer"
+      card.log!(kind, actor: "user", run: parked_run, text: text)
+      ResumeRunJob.perform_later(parked_run.id, text)
+    elsif card.column.review? && %w[in_review approved].include?(card.status)
+      # Review is entirely human: feedback IS the conversation. A message on a
+      # card under review marks it changes_requested; dragging it back to a
+      # work column carries the feedback into the next run's briefing.
+      card.log!("user_message", actor: "user", text: text)
+      card.update!(status: "changes_requested")
+      card.log!("status_change", actor: "user", text: "Changes requested — drag the card back to a work column when ready")
+    else
+      card.log!("user_message", actor: "user", text: text)
+      AssistantReplyJob.perform_later(card) if card.column.planning? && card.column.ai?
+    end
+    redirect_to card_path(card)
+  end
+end

data/app/controllers/runs_controller.rb

@@ -0,0 +1,58 @@
+class RunsController < ApplicationController
+  before_action :set_run
+
+  # Kill switch (cardinal.md §9): TERM the agent subprocess; sweeper and the
+  # runner's failure path keep the records honest.
+  def cancel
+    if run.running? && (pid = run.agent_session.config["pid"])
+      Process.kill("TERM", pid) rescue Errno::ESRCH
+    end
+    if run.running? || run.needs_input?
+      run.update!(status: "cancelled", finished_at: Time.current)
+      card.update!(status: "failed")
+      card.log!("status_change", actor: "user", run: run, text: "Run cancelled by user")
+    end
+    redirect_to card_path(card)
+  end
+
+  # Plan-approval gate (§4): one click sends the agent from plan to execute.
+  def approve
+    if run.needs_input? && run.phase == "plan"
+      card.log!("plan_approved", actor: "user", run: run, text: "Plan approved")
+      ResumeRunJob.perform_later(run.id, "", approve: true)
+    end
+    redirect_to card_path(card)
+  end
+
+  # Restart a run that parked or failed on its turn budget / timeout. Mirrors
+  # Column#kick_queue's branch: resume the saved session for a fresh budget, or
+  # (no session left) re-queue for a clean run.
+  def restart
+    if run.restartable?
+      if run.needs_input?
+        card.log!("progress", actor: "user", run: run, text: "Restarting run — resuming with a fresh turn budget")
+        ResumeRunJob.perform_later(run.id, "")
+      elsif run.external_session_id.present?
+        # Failed but the session survived: flip back to needs_input so
+        # ResumeRunJob's guard passes, then resume it.
+        run.update!(status: "needs_input", finished_at: nil)
+        card.update!(status: "needs_input")
+        card.log!("progress", actor: "user", run: run, text: "Restarting failed run — resuming the saved session with a fresh turn budget")
+        ResumeRunJob.perform_later(run.id, "")
+      else
+        # No session to resume: a clean run from the queue.
+        card.update!(status: "queued")
+        card.log!("progress", actor: "user", run: run, text: "Restarting failed run — starting a fresh run")
+        StartRunJob.perform_later(card.id)
+      end
+    end
+    redirect_to card_path(card)
+  end
+
+  private
+
+  attr_reader :run
+
+  def set_run = @run = Run.find(params[:id])
+  def card = run.card
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,35 @@
+module ApplicationHelper
+  # Curated model choices for column policies. A custom value already saved on
+  # the column stays selectable.
+  def model_options(current)
+    options = [
+      ["(inherit default)", ""],
+      ["Haiku 4.5 — fastest, cheapest", "claude-haiku-4-5-20251001"],
+      ["Sonnet 4.6 — balanced, recommended for workers", "claude-sonnet-4-6"],
+      ["Opus 4.8 — most capable", "claude-opus-4-8"],
+      ["Fable 5 — frontier, expensive", "claude-fable-5"]
+    ]
+    options << [current, current] if current.present? && options.none? { |_, v| v == current }
+    options
+  end
+
+  # Timeline text is Markdown (agents write it constantly). escape_html turns
+  # any raw HTML in the text into visible text instead of live DOM — an agent
+  # pasting `<div class=...>` inside a code fence must never restyle the page.
+  MARKDOWN = Redcarpet::Markdown.new(
+    Redcarpet::Render::HTML.new(escape_html: true, hard_wrap: true, safe_links_only: true),
+    fenced_code_blocks: true, tables: true, autolink: true,
+    strikethrough: true, no_intra_emphasis: true, lax_spacing: true
+  )
+
+  def render_markdown(text)
+    MARKDOWN.render(text.to_s).html_safe
+  end
+
+  def info_tip(text)
+    tag.span("i", class: "info",
+             data: { controller: "tooltip", tooltip_text_value: text,
+                     action: "mouseenter->tooltip#show mouseleave->tooltip#hide focus->tooltip#show blur->tooltip#hide" },
+             tabindex: 0)
+  end
+end

data/app/javascript/application.js

@@ -0,0 +1,2 @@
+import "@hotwired/turbo-rails"
+import "controllers"

data/app/javascript/controllers/application.js

@@ -0,0 +1,7 @@
+import { Application } from "@hotwired/stimulus"
+
+const application = Application.start()
+application.debug = false
+window.Stimulus = application
+
+export { application }

data/app/javascript/controllers/autosave_controller.js

@@ -0,0 +1,43 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Silent autosave for the card details form: debounce edits, submit, whisper.
+export default class extends Controller {
+  static targets = ["status", "form"]
+
+  connect() {
+    this.onEnd = (event) => {
+      if (!this.hasStatusTarget) return
+      this.statusTarget.textContent = event.detail?.success === false ? "✗ not saved" : "Saved ✓"
+      clearTimeout(this.fade)
+      this.fade = setTimeout(() => (this.statusTarget.textContent = ""), 1500)
+    }
+    this.element.addEventListener("turbo:submit-end", this.onEnd)
+
+    // A closing modal must not eat a pending debounce — flush immediately.
+    this.onModalClose = () => this.flush()
+    document.addEventListener("cardinal:modal-closing", this.onModalClose)
+  }
+
+  disconnect() {
+    clearTimeout(this.timer)
+    clearTimeout(this.fade)
+    this.element.removeEventListener("turbo:submit-end", this.onEnd)
+    document.removeEventListener("cardinal:modal-closing", this.onModalClose)
+  }
+
+  flush() {
+    if (!this.timer) return
+    clearTimeout(this.timer)
+    this.timer = null
+    this.formTarget.requestSubmit()
+  }
+
+  save() {
+    if (this.hasStatusTarget) this.statusTarget.textContent = "…"
+    clearTimeout(this.timer)
+    this.timer = setTimeout(() => {
+      this.timer = null
+      this.formTarget.requestSubmit()
+    }, 800)
+  }
+}

data/app/javascript/controllers/board_column_controller.js

@@ -0,0 +1,96 @@
+import { Controller } from "@hotwired/stimulus"
+import { Turbo } from "@hotwired/turbo-rails"
+import Sortable from "sortablejs"
+
+// Drag-and-drop for a column's card list. Moving a card PATCHes /cards/:id/move;
+// the server is the authority — a 422 snaps the card back and shows why.
+export default class extends Controller {
+  static values = { hint: String, newUrl: String }
+
+  // A bare click on the column background — not on a card — opens the New Card
+  // composer, mirroring the header's [+]. Cards keep their own click (open
+  // detail); we only act when the click lands on the container itself.
+  newCard(event) {
+    if (event.target !== this.element || !this.hasNewUrlValue) return
+    document.getElementById("modal").src = this.newUrlValue
+  }
+
+  connect() {
+    this.sortable = Sortable.create(this.element, {
+      group: "cards",
+      animation: 150,
+      ghostClass: "card-ghost",
+      onStart: () => {
+        document.body.classList.add("dragging")
+        this.markBlockedColumns()
+      },
+      onEnd: (event) => {
+        document.body.classList.remove("dragging")
+        this.clearBlockedColumns()
+        this.move(event)
+      }
+    })
+  }
+
+  // Accept policies made visible: while dragging, columns that won't take a
+  // card from THIS column gray out with a blocked hint. Server still rules.
+  markBlockedColumns() {
+    const sourceId = this.element.dataset.columnId
+    document.querySelectorAll(".column").forEach(section => {
+      if (section.dataset.colId === sourceId) return // reorder within is always fine
+      const allowed = (section.dataset.accepts || "").split(",").filter(Boolean)
+      if (!allowed.includes(sourceId)) section.classList.add("drop-blocked")
+    })
+  }
+
+  clearBlockedColumns() {
+    document.querySelectorAll(".column.drop-blocked").forEach(s => s.classList.remove("drop-blocked"))
+  }
+
+  disconnect() {
+    this.sortable?.destroy()
+  }
+
+  async move(event) {
+    const cardId = event.item.dataset.cardId
+    const columnId = event.to.dataset.columnId
+    if (event.to === event.from && event.newIndex === event.oldIndex) return
+
+    const response = await fetch(`/cards/${cardId}/move`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "text/vnd.turbo-stream.html, application/json",
+        "X-CSRF-Token": document.querySelector("meta[name='csrf-token']").content
+      },
+      body: JSON.stringify({ column_id: columnId, position: event.newIndex })
+    })
+
+    if (response.ok) {
+      // Server-rendered truth for both columns: instant queued/working
+      // styling, ticker counts, queue positions.
+      Turbo.renderStreamMessage(await response.text())
+    } else {
+      // Server said no: snap the card back where it came from and flash a red
+      // border so the bounce reads as a rejection, not a glitch.
+      event.from.insertBefore(event.item, event.from.children[event.oldIndex])
+      const body = await response.json().catch(() => ({}))
+      this.flashRejected(event.item, body.error)
+    }
+  }
+
+  flashRejected(card, message) {
+    // Surface the reason on hover for the life of the flash; the durable
+    // record lives in the card's event timeline.
+    const priorTitle = card.getAttribute("title")
+    if (message) card.setAttribute("title", message)
+    card.classList.remove("move-rejected")
+    // Force a reflow so re-adding the class restarts the animation.
+    void card.offsetWidth
+    card.classList.add("move-rejected")
+    card.addEventListener("animationend", () => {
+      card.classList.remove("move-rejected")
+      if (message) priorTitle ? card.setAttribute("title", priorTitle) : card.removeAttribute("title")
+    }, { once: true })
+  }
+}

data/app/javascript/controllers/clipboard_controller.js

@@ -0,0 +1,18 @@
+import { Controller } from "@hotwired/stimulus"
+
+// GitHub-style copy button: copies textValue, flashes a checkmark.
+export default class extends Controller {
+  static values = { text: String }
+  static targets = ["button"]
+
+  async copy() {
+    await navigator.clipboard.writeText(this.textValue)
+    const original = this.buttonTarget.textContent
+    this.buttonTarget.textContent = "✓"
+    this.buttonTarget.classList.add("copied")
+    setTimeout(() => {
+      this.buttonTarget.textContent = original
+      this.buttonTarget.classList.remove("copied")
+    }, 1200)
+  }
+}

data/app/javascript/controllers/composer_controller.js

@@ -0,0 +1,10 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Chat composer: Enter sends, Shift+Enter inserts a newline.
+export default class extends Controller {
+  keydown(event) {
+    if (event.key !== "Enter" || event.shiftKey) return
+    event.preventDefault()
+    if (this.element.value.trim() !== "") this.element.form.requestSubmit()
+  }
+}

data/app/javascript/controllers/index.js

@@ -0,0 +1,3 @@
+import { application } from "controllers/application"
+import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading"
+eagerLoadControllersFrom("controllers", application)

data/app/javascript/controllers/modal_controller.js

@@ -0,0 +1,45 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Near-fullscreen card modal rendered into the "modal" turbo-frame.
+// Closes on Esc, backdrop click, or the ✕ button — unless `sticky`, in
+// which case only the explicit close/cancel buttons (and a successful save)
+// dismiss it. Sticky guards the new-card form so a stray click or Esc can't
+// throw away everything you typed.
+export default class extends Controller {
+  static values = { sticky: Boolean }
+
+  connect() {
+    this.escHandler = (e) => { if (e.key === "Escape" && !this.stickyValue) this.close() }
+    document.addEventListener("keydown", this.escHandler)
+  }
+
+  disconnect() {
+    document.removeEventListener("keydown", this.escHandler)
+  }
+
+  backdrop(event) {
+    if (event.target === this.element && !this.stickyValue) this.close()
+  }
+
+  // For _top-targeted forms (create card, deletes): the frame is
+  // turbo-permanent, so it survives the follow-up page render — close it
+  // explicitly once the submission succeeds.
+  closeOnSuccess(event) {
+    if (event.detail.success) this.close()
+  }
+
+  close() {
+    // Let autosave forms flush any pending debounce before the frame clears.
+    document.dispatchEvent(new CustomEvent("cardinal:modal-closing"))
+    const frame = this.element.closest("turbo-frame")
+    frame.removeAttribute("src")
+    frame.innerHTML = ""
+    // Opening a card advances the URL to /cards/:id; closing must return the
+    // address bar to the board. The board is still rendered behind the permanent
+    // frame, so just rewrite the URL — no navigation needed. Back/forward still
+    // work via Turbo's history snapshots.
+    if (window.location.pathname.startsWith("/cards/")) {
+      window.history.pushState({}, "", "/")
+    }
+  }
+}

data/app/javascript/controllers/reveal_controller.js

@@ -0,0 +1,15 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Show/hide dependent settings when a toggle changes (e.g. the column AI
+// checkbox reveals model/effort/budget settings). Autosave still fires via
+// the change event bubbling to the autosave controller.
+export default class extends Controller {
+  static targets = ["toggle", "panel"]
+
+  connect() { this.sync() }
+
+  sync() {
+    const on = this.toggleTarget.checked
+    this.panelTargets.forEach(p => p.classList.toggle("hidden", !on))
+  }
+}