cardinal-ai 0.0.1 → 0.2.4

data/app/services/agent/workspace.rb

@@ -0,0 +1,138 @@
+module Agent
+  # The worker agent's isolated checkout, behind a strategy factory
+  # (cardinal.md §13, §17):
+  #
+  #   Local     — clone under .cardinal/workspaces/; the agent process runs on
+  #               the host with chdir into the checkout. Process-level
+  #               isolation only. The default.
+  #   Container — same host-side checkout, but the agent runs inside a
+  #               cage-style Docker container that mounts ONLY the checkout.
+  #               Opt in with CARDINAL_WORKSPACE=container (experimental —
+  #               requires a Docker daemon and CARDINAL_AGENT_IMAGE with the
+  #               claude CLI installed; ANTHROPIC_API_KEY is passed through).
+  #
+  # Both strategies share git provisioning: the runner owns clone, branch,
+  # and push — the agent only ever commits.
+  module Workspace
+    def self.provision(card) = strategy.provision(card)
+    def self.attach(card) = strategy.attach(card)
+
+    def self.strategy
+      ENV["CARDINAL_WORKSPACE"] == "container" ? Container : Local
+    end
+
+    class Local
+      ROOT = Rails.root.join(".cardinal", "workspaces")
+
+      attr_reader :card, :path
+
+      def self.provision(card) = new(card).tap(&:provision)
+
+      # Reattach without resetting — used when resuming a parked run whose
+      # local commits aren't pushed yet.
+      def self.attach(card)
+        ws = new(card)
+        File.directory?(ws.path.join(".git")) ? ws : ws.tap(&:provision)
+      end
+
+      def initialize(card)
+        @card = card
+        @path = ROOT.join("card-#{card.number}")
+      end
+
+      def provision
+        FileUtils.mkdir_p(ROOT)
+        unless File.directory?(path.join(".git"))
+          git!(ROOT, "clone", "--quiet", (card.board.local_path.presence || Rails.root).to_s, path.to_s)
+          git!(path, "remote", "set-url", "origin", card.board.repo_url) if card.board.repo_url.present?
+        end
+        salvage_dirty_tree!
+        git!(path, "fetch", "--quiet", "origin")
+        if git?(path, "rev-parse", "--verify", "origin/#{card.branch_name}")
+          git!(path, "checkout", "--quiet", card.branch_name)
+          git!(path, "reset", "--quiet", "--hard", "origin/#{card.branch_name}")
+        elsif git?(path, "rev-parse", "--verify", card.branch_name)
+          # Local-only branch (e.g. WIP salvaged but never pushed): keep it.
+          git!(path, "checkout", "--quiet", card.branch_name)
+        else
+          git!(path, "checkout", "--quiet", "-B", card.branch_name, "origin/#{card.board.default_branch}")
+        end
+        self
+      end
+
+      # A killed run can leave uncommitted edits that block checkout and would
+      # otherwise be silently destroyed. Commit them as WIP on the branch and
+      # push (best effort) so the interrupted work survives onto the PR.
+      def salvage_dirty_tree!
+        return if git_out(path, "status", "--porcelain").strip.empty?
+        git!(path, "add", "-A")
+        git!(path, "commit", "--quiet", "-m", "WIP: salvage uncommitted work from an interrupted run")
+        begin
+          push!
+        rescue RuntimeError
+          nil # offline is fine — the local-branch checkout path keeps the WIP
+        end
+      end
+
+      # How the runner should spawn the agent process for this workspace.
+      def agent_spawn(cmd) = [cmd, { chdir: path.to_s }]
+
+      def head = git_out(path, "rev-parse", "HEAD").strip
+
+      def commits_since(sha)
+        git_out(path, "log", "--oneline", "#{sha}..HEAD").lines.map(&:strip)
+      end
+
+      def ahead_of_default?
+        git_out(path, "rev-list", "--count", "origin/#{card.board.default_branch}..HEAD").strip.to_i.positive?
+      end
+
+      def push!
+        git!(path, "push", "--quiet", "-u", "origin", card.branch_name)
+      end
+
+      private
+
+      def git!(dir, *args)
+        out, status = Open3.capture2e("git", "-C", dir.to_s, *args)
+        raise "git #{args.first} failed: #{out.truncate(300)}" unless status.success?
+        out
+      end
+
+      def git?(dir, *args)
+        _, status = Open3.capture2e("git", "-C", dir.to_s, *args)
+        status.success?
+      end
+
+      def git_out(dir, *args) = git!(dir, *args)
+    end
+
+    # EXPERIMENTAL — written against the cage model; needs a host with Docker
+    # to exercise. Git stays host-side; only the agent process is jailed.
+    class Container < Local
+      WORKDIR = "/workspace/repo"
+
+      def image = ENV.fetch("CARDINAL_AGENT_IMAGE", "cardinal-agent:latest")
+      def container_name = "cardinal-card-#{card.number}"
+
+      def agent_spawn(cmd)
+        docker = ["docker", "run", "--rm", "-i",
+                  "--name", container_name,
+                  "--label", "cardinal=agent",
+                  "-v", "#{path}:#{WORKDIR}",
+                  "-w", WORKDIR]
+        # Value-embedded because the runner nils the key in the client env
+        # (visible in ps on the host — acceptable for the experimental tier).
+        # Instance OAuth token (cardinal up account link) or raw API key —
+        # whichever this instance runs on.
+        docker += ["-e", "ANTHROPIC_API_KEY=#{ENV["ANTHROPIC_API_KEY"]}"] if ENV["ANTHROPIC_API_KEY"].present?
+        docker += ["-e", "CLAUDE_CODE_OAUTH_TOKEN=#{ENV["CLAUDE_CODE_OAUTH_TOKEN"]}"] if ENV["CLAUDE_CODE_OAUTH_TOKEN"].present?
+        [docker + [image] + cmd, {}]
+      end
+
+      def teardown
+        Open3.capture2e("docker", "rm", "-f", container_name)
+      end
+    end
+  end
+end

data/app/services/card_transition.rb

@@ -0,0 +1,97 @@
+# The only code path that moves a card between columns. Validates legality,
+# runs the old column's leave policy and the new column's enter policy, and
+# emits the transition events (§3, §11). Controllers and future automations
+# all call this — never Card#update(column:) directly.
+class CardTransition
+  Result = Data.define(:success?, :card, :error)
+
+  def initialize(card, to_column:, position: nil, actor: "user")
+    @card = card
+    @from = card.column
+    @to = to_column
+    @position = position
+    @actor = actor
+  end
+
+  def call
+    return reposition! if @from == @to
+    return failure("Column belongs to a different board") if @to.board_id != @card.board_id
+    if @card.working? && @from.execution?
+      # An agent process is live — no silent kills (§3). Cancel it first.
+      return failure("##{@card.number} has an active run — cancel it before moving the card")
+    end
+    # Accept policy (card #15): the destination decides which columns may feed
+    # it, forcing cards through a defined workflow rather than any-to-any drops.
+    return rejected! unless @to.accepts?(@from)
+
+    Card.transaction do
+      leave_policy!
+      place_in_column!
+      enter_policy!
+    end
+    Result.new(success?: true, card: @card, error: nil)
+  rescue ActiveRecord::RecordInvalid => e
+    failure(e.message)
+  end
+
+  private
+
+  # Same-column drag = prioritization (§8): top of the column runs first, so
+  # reordering queued cards IS the priority UI. No policies fire, no events.
+  def reposition!
+    ids = @to.cards.where.not(id: @card.id).order(:position).pluck(:id)
+    ids.insert([@position || ids.size, ids.size].min, @card.id)
+    Card.transaction do
+      ids.each_with_index { |id, index| Card.where(id: id).update_all(position: index) }
+      @card.touch # update_all skips callbacks; touch broadcasts to other windows
+    end
+    Result.new(success?: true, card: @card.reload, error: nil)
+  end
+
+  def leave_policy!
+    return unless @from.execution?
+    # Dequeue / abandon parked runs — nothing live is killed (working cards
+    # were already blocked above).
+    @card.runs.where(status: %w[queued needs_input]).each do |run|
+      run.update!(status: "cancelled", finished_at: Time.current)
+    end
+  end
+
+  def place_in_column!
+    # Column arrivals policy: force where newcomers land, regardless of the
+    # drop position. (Reordering within the column stays free-form.)
+    case @to.arrivals
+    when "top"    then @position = 0
+    when "bottom" then @position = nil
+    end
+    @position ||= (@to.cards.maximum(:position) || -1) + 1
+    @to.cards.where("position >= ?", @position).update_all("position = position + 1")
+    @card.update!(column: @to, position: @position, status: entry_status)
+    @card.log!("column_move", actor: @actor,
+               from: @from.name, to: @to.name, text: "Moved from #{@from.name} to #{@to.name}")
+  end
+
+  def enter_policy!
+    Rules.fire_entry(@card, @to)
+  end
+
+  def entry_status
+    case @to.archetype
+    when "inbox"     then "draft"
+    when "planning"  then "discussing"
+    when "execution" then @to.ai? ? "queued" : "working" # no AI = a human is on it
+    when "review"    then "in_review"
+    when "terminal"  then "done"
+    end
+  end
+
+  # A drop the destination's accept policy forbids: nothing moves, but the
+  # attempt is logged to the card's timeline so the bounce isn't silent.
+  def rejected!
+    @card.log!("move_rejected", actor: @actor, from: @from.name, to: @to.name,
+               text: "Blocked: #{@from.name} can't move directly to #{@to.name}")
+    failure("#{@from.name} cannot move directly to #{@to.name}")
+  end
+
+  def failure(message) = Result.new(success?: false, card: @card, error: message)
+end

data/app/services/claude_cli.rb

@@ -0,0 +1,89 @@
+# The single auth path for all of Cardinal's AI (§17): every tier — planning
+# assistant, maintenance agents, rules compiler, worker agents — goes through
+# the claude CLI, so wherever Claude Code is logged in (or an API key is
+# exported), Cardinal works. No separate key provisioning.
+#
+# This module covers the one-shot tiers; worker agents have their own
+# streaming path in Agent::Runner.
+module ClaudeCli
+  class Error < StandardError
+    # Human message in #message; raw technical payload in #detail (shown only
+    # behind a disclosure in the timeline).
+    attr_reader :detail
+
+    def initialize(message, detail: nil)
+      super(message)
+      @detail = detail
+    end
+  end
+
+  # Nested-session guards + creds the model never needs. A blank
+  # ANTHROPIC_API_KEY is removed too (it would shadow CLI session auth).
+  STRIP_ENV = %w[CLAUDECODE CLAUDE_CODE_ENTRYPOINT GH_TOKEN GITHUB_TOKEN].freeze
+
+  WRAP_UP = "You have hit your exploration limit. Using only what you have already " \
+            "learned, give your best complete reply now. Do not use any tools.".freeze
+
+  def self.available?
+    return @available if defined?(@available)
+    @available = system("which claude > /dev/null 2>&1")
+  end
+
+  # tools: comma-separated read-only tool list (e.g. "Read,Glob,Grep") with
+  # cwd pointing at the repo. Default remains tool-less single-turn.
+  # resume: continue an existing claude session (context carries over).
+  # with_session: return [text, session_id] instead of just text, so callers
+  # can keep a continuing conversation (the planning assistant does).
+  def self.prompt(text, system: nil, model: nil, tools: nil, cwd: nil, max_turns: 1,
+                  resume: nil, with_session: false)
+    raise Error.new("claude CLI not found on PATH") unless available?
+
+    json = invoke(text, system:, model:, tools:, cwd:, max_turns:, resume:)
+    if success?(json)
+      return with_session ? [json["result"].to_s, json["session_id"]] : json["result"].to_s
+    end
+
+    # Ran out of turns mid-exploration: resume the same session tool-less and
+    # force an answer from the context it already gathered.
+    if json["subtype"] == "error_max_turns" && json["session_id"].present?
+      wrapped = invoke(WRAP_UP, model:, cwd:, tools: "", max_turns: 2, resume: json["session_id"])
+      if success?(wrapped)
+        return with_session ? [wrapped["result"].to_s, wrapped["session_id"] || json["session_id"]] : wrapped["result"].to_s
+      end
+      raise Error.new("ran out of working turns and couldn't wrap up — try again, or simplify the ask",
+                      detail: wrapped.to_json)
+    end
+
+    raise Error.new(friendly_failure(json), detail: json.to_json)
+  end
+
+  def self.success?(json)
+    json["subtype"] == "success" && !json["is_error"]
+  end
+
+  def self.friendly_failure(json)
+    case json["subtype"]
+    when "error_max_turns"        then "ran out of working turns before finishing"
+    when "error_during_execution" then "hit an internal error while working"
+    else "failed (#{json["subtype"].presence || "unknown error"})"
+    end
+  end
+
+  def self.invoke(text, system: nil, model: nil, tools: nil, cwd: nil, max_turns: 1, resume: nil)
+    cmd = ["claude", "-p", text, "--output-format", "json",
+           "--max-turns", max_turns.to_s, "--tools", tools.presence || ""]
+    cmd += ["--append-system-prompt", system] if system.present?
+    cmd += ["--model", model] if model.present?
+    cmd += ["--resume", resume] if resume.present?
+
+    env = STRIP_ENV.index_with { nil }
+    env["ANTHROPIC_API_KEY"] = nil if ENV["ANTHROPIC_API_KEY"].blank?
+
+    spawn_opts = cwd.present? && Dir.exist?(cwd) ? { chdir: cwd } : {}
+    out, err, status = Open3.capture3(env, *cmd, **spawn_opts)
+    JSON.parse(out)
+  rescue JSON::ParserError
+    raise Error.new("claude produced no readable result (exit #{status&.exitstatus || "?"})",
+                    detail: [err, out].compact_blank.join("\n---\n").truncate(1500))
+  end
+end

data/app/services/rules/compiler.rb

@@ -0,0 +1,55 @@
+module Rules
+  # Turns a plain-English description of a column's on-entry behavior into the
+  # rule actions the dispatcher executes (§17). English is the source of
+  # truth; the compiled JSON is stored alongside it and shown read-only.
+  module Compiler
+    Error = Class.new(StandardError)
+
+    VOCABULARY = <<~DOC.freeze
+      Available actions:
+      - {"action": "assistant_greeting"} — the planning assistant posts an opening message
+      - {"action": "start_agent_run"} — assign a dedicated worker agent to the card and start a run
+      - {"action": "ai_task", "prompt": "...", "model": "optional-model-id"} — a one-shot AI maintenance
+        task; the prompt may use %{title}, %{description}, %{conversation}; its output is posted to the
+        card timeline
+      - {"action": "mark_pr_ready"} — take the card's PR out of draft (ready for review on GitHub)
+      - {"action": "merge_pr"} — mark the card's PR ready, squash-merge it, delete the branch
+      - {"action": "set_status", "status": "..."} — force a card status
+    DOC
+
+    def self.compile(text)
+      raise Error, "Rules compiler needs the claude CLI — use the advanced JSON editor instead." unless ClaudeCli.available?
+
+      raw = ClaudeCli.prompt(
+        text,
+        model: AssistantReplyJob::FALLBACK_MODEL,
+        system: <<~SYS
+          You compile plain-English descriptions of Kanban column automation into JSON rule
+          arrays for the Cardinal board engine.
+
+          #{VOCABULARY}
+          Respond with ONLY the JSON array — no prose, no code fences. If the description
+          asks for something outside the vocabulary, approximate it with an ai_task whose
+          prompt captures the intent.
+        SYS
+      ).strip
+      raw = raw.sub(/\A```(?:json)?\s*/, "").sub(/```\z/, "").strip
+      rules = JSON.parse(raw)
+      validate!(rules)
+      rules
+    rescue JSON::ParserError
+      raise Error, "Compiler returned invalid JSON — try rephrasing, or use the advanced editor."
+    rescue ClaudeCli::Error => e
+      raise Error, "Compiler call failed: #{e.message.truncate(120)}"
+    end
+
+    def self.validate!(rules)
+      raise Error, "Expected a JSON array of rules" unless rules.is_a?(Array)
+      known = %w[assistant_greeting start_agent_run ai_task mark_pr_ready merge_pr set_status]
+      rules.each do |rule|
+        raise Error, "Each rule must be an object with an \"action\"" unless rule.is_a?(Hash) && rule["action"].present?
+        raise Error, "Unknown action #{rule["action"].inspect}" unless known.include?(rule["action"])
+      end
+    end
+  end
+end

data/app/services/rules.rb

@@ -0,0 +1,92 @@
+# Column rules (cardinal.md §17): a column's on_entry policy is a list of rule
+# actions fired when a card lands in it. Archetypes stamp starting rules at
+# creation (templates, not magic) — any column can carry any rules after that,
+# including one-shot AI maintenance tasks.
+module Rules
+  # NOTE: there is deliberately NO runtime fallback to archetype defaults —
+  # archetypes are creation-time templates (Column::ARCHETYPE_TEMPLATES).
+  # A column with no on_entry rules does nothing on entry, visibly.
+
+  # Shown in the gear modal so the archetype's built-in behavior is visible,
+  # not implied (the on-entry box being blank doesn't mean nothing happens).
+  DEFAULT_DESCRIPTIONS = {
+    "inbox"     => "Nothing — cards park here untouched.",
+    "planning"  => "The planning assistant inspects the card and opens the conversation: it reads the title and description, then asks its sharpest clarifying questions to improve the card before execution. Tune its focus with the Instructions field above.",
+    "execution" => "A dedicated worker agent is assigned to the card and a run starts (plan-first if plan approval is on).",
+    "review"    => "Nothing automatic — the card waits for your verdict.",
+    "terminal"  => "The card's PR is squash-merged and its branch deleted. A card with no PR is simply closed — planning can send work straight here to terminate it."
+  }.freeze
+
+  def self.fire_entry(card, column)
+    each_rule(column.policy["on_entry"]) do |rule|
+      apply(rule, card, column)
+    end
+  end
+
+  def self.each_rule(configured, &block)
+    rules = configured.presence || []
+    rules = [rules] if rules.is_a?(Hash) || rules.is_a?(String)
+    rules.map { |r| r.is_a?(String) ? { "action" => r } : r }.each(&block)
+  end
+
+  AI_ACTIONS = %w[assistant_greeting start_agent_run ai_task].freeze
+
+  # Human names for compiled rule actions — so "currently active" behavior is
+  # readable in the gear modal without opening the JSON drawer (no-magic).
+  ACTION_DESCRIPTIONS = {
+    "assistant_greeting" => "the assistant opens the discussion",
+    "start_agent_run"    => "assign a worker agent and start a run",
+    "ai_task"            => "run a one-shot AI task",
+    "mark_pr_ready"      => "take the PR out of draft",
+    "merge_pr"           => "merge the PR and ship",
+    "set_status"         => "set the card's status"
+  }.freeze
+
+  def self.describe(rules)
+    normalized = rules.is_a?(Hash) || rules.is_a?(String) ? [rules] : Array(rules)
+    normalized.map { |r| r.is_a?(String) ? { "action" => r } : r }.map do |rule|
+      base = ACTION_DESCRIPTIONS[rule["action"]] || rule["action"].to_s
+      rule["action"] == "ai_task" && rule["prompt"].present? ? "#{base} (“#{rule["prompt"].truncate(60)}”)" : base
+    end.join("; then ")
+  end
+
+  def self.apply(rule, card, column)
+    if AI_ACTIONS.include?(rule["action"]) && !column.ai?
+      card.log!("status_change", text: "AI is off for #{column.name} — skipped #{rule["action"]}")
+      return
+    end
+
+    case rule["action"]
+    when "assistant_greeting"
+      # Contextual opener: the assistant reads the card and asks targeted
+      # questions (AssistantReplyJob falls back to a canned line without a key).
+      AssistantReplyJob.perform_later(card, kickoff: true)
+    when "start_agent_run"
+      card.update!(branch_name: card.branch_name.presence || card.default_branch_name)
+      card.log!("status_change", text: "Queued for execution on #{card.branch_name}")
+      StartRunJob.perform_later(card.id)
+    when "ai_task"
+      # One-shot maintenance agent: a bounded Messages API call whose prompt
+      # comes from the rule config. No workspace, no session, no tools.
+      AiTaskJob.perform_later(card.id, rule["prompt"].to_s, rule["model"])
+    when "mark_pr_ready"
+      if card.pr_url.present?
+        card.log!("status_change", text: "Taking the PR out of draft…")
+        MarkPrReadyJob.perform_later(card.id)
+      else
+        card.log!("status_change", text: "No PR to mark ready")
+      end
+    when "merge_pr"
+      if card.pr_url.present?
+        card.log!("status_change", text: "Shipping: merging #{card.pr_url}")
+        MergePrJob.perform_later(card.id)
+      else
+        card.log!("status_change", text: "Card finalized (no PR to merge)")
+      end
+    when "set_status"
+      card.update!(status: rule["status"]) if Card::STATUSES.include?(rule["status"])
+    else
+      card.log!("error", text: "Unknown column rule: #{rule["action"].inspect}")
+    end
+  end
+end

data/app/services/run_sweeper.rb

@@ -0,0 +1,53 @@
+# Reliability layer (cardinal.md §11): no run may stay "running" without a
+# live process behind it. The server boots a sweeper thread (see
+# config/initializers/run_sweeper.rb) that fails silent runs and unsticks
+# their cards, then re-kicks execution queues.
+module RunSweeper
+  HEARTBEAT_GRACE = 3.minutes
+
+  def self.sweep
+    fail_dead_runs
+    repair_stuck_cards
+    kick_queues
+  end
+
+  def self.fail_dead_runs
+    Run.where(status: %w[queued running]).find_each do |run|
+      next if alive?(run)
+      next if run.heartbeat_at && run.heartbeat_at > HEARTBEAT_GRACE.ago
+      next if run.heartbeat_at.nil? && run.created_at > HEARTBEAT_GRACE.ago
+
+      run.update!(status: "failed", finished_at: Time.current,
+                  result_summary: "Runner died without finishing (swept)")
+      card = run.card
+      if card.working? || card.queued?
+        card.update!(status: "failed")
+        card.log!("error", run: run, text: "Run ##{run.id} lost its runner process and was marked failed. Retry by dragging the card out and back into the column.")
+      end
+    end
+  end
+
+  # Cards left "working" with no live or recorded run — e.g. a crash between
+  # state writes.
+  def self.repair_stuck_cards
+    Card.where(status: "working").find_each do |card|
+      next unless card.column.ai? # non-AI columns: "working" means a human is
+      next if card.runs.where(status: %w[queued running needs_input]).any? { |r| r.needs_input? || alive?(r) }
+      card.update!(status: "failed")
+      card.log!("error", text: "Card was stuck working with no live run; marked failed.")
+    end
+  end
+
+  def self.kick_queues
+    Column.where(archetype: "execution").find_each(&:kick_queue)
+  end
+
+  def self.alive?(run)
+    pid = run.agent_session&.config&.dig("pid")
+    return false if pid.blank?
+    Process.kill(0, Integer(pid))
+    true
+  rescue Errno::ESRCH, Errno::EPERM, ArgumentError
+    false
+  end
+end

data/app/views/boards/show.html.erb

@@ -0,0 +1,79 @@
+<%= turbo_stream_from @board %>
+
+<header class="topbar">
+  <h1>Cardinal AI <span class="sep">▸</span> <%= @board.name %></h1>
+  <div class="topbar-right">
+    <button type="button" class="theme-toggle"
+            data-controller="theme" data-action="theme#toggle">☀ Light</button>
+    <% if ENV["CARDINAL_AUTH"].present? %>
+      <span class="auth-chip" title="<%= ENV["CARDINAL_AUTH"] == "dedicated" ? "This board runs as its own linked Claude account (.cardinal/claude). Switch with: cardinal login" : "This board inherits the machine's claude login (CARDINAL_INHERIT_AUTH=1)" %>">
+        🔐 <%= ENV["CARDINAL_AUTH"] == "dedicated" ? "board account" : "machine account" %>
+      </span>
+    <% end %>
+    <% attention = @board.attention_cards %>
+    <% working = @board.cards.where(status: "working").order(:updated_at) %>
+    <% queued = @board.cards.where(status: "queued").order(:position) %>
+    <% if attention.any? || working.any? || queued.any? %>
+      <details class="attention">
+        <summary>
+          <% if attention.any? %><span class="attn-part">⚠ <%= attention.size %> need you</span><% end %>
+          <% if working.any? %><span class="attn-part working-part"><span class="pulse-dot"></span> <%= working.size %> working</span><% end %>
+          <% if queued.any? %><span class="attn-part">⏳ <%= queued.size %> queued</span><% end %>
+        </summary>
+        <div class="attention-list">
+          <% if attention.any? %>
+            <p class="attn-header">Needs you</p>
+            <ul>
+              <% attention.each do |card| %>
+                <li><%= link_to "##{card.number} #{card.title} — #{card.status.humanize.downcase}",
+                                card_path(card), data: { turbo_frame: "modal", turbo_action: "advance" } %></li>
+              <% end %>
+            </ul>
+          <% end %>
+          <% if working.any? %>
+            <p class="attn-header">Working</p>
+            <ul>
+              <% working.each do |card| %>
+                <li class="attn-working">
+                  <span class="pulse-dot"></span>
+                  <%= link_to card_path(card), data: { turbo_frame: "modal", turbo_action: "advance" } do %>
+                    #<%= card.number %> <%= card.title %><span class="hint"> — <%= card.latest_progress&.truncate(60) || "starting…" %></span>
+                  <% end %>
+                </li>
+              <% end %>
+            </ul>
+          <% end %>
+          <% if queued.any? %>
+            <p class="attn-header">Queued</p>
+            <ul>
+              <% queued.each_with_index do |card, index| %>
+                <li><%= link_to "##{card.number} #{card.title} — #{index.zero? ? "next up" : "#{index} ahead"}",
+                                card_path(card), data: { turbo_frame: "modal", turbo_action: "advance" } %></li>
+              <% end %>
+            </ul>
+          <% end %>
+        </div>
+      </details>
+    <% end %>
+    <details class="new-column">
+      <summary>+ Column</summary>
+      <%= form_with url: columns_path, class: "new-column-form" do |f| %>
+        <%= f.text_field "column[name]", placeholder: "Column name", required: true %>
+<%# Inbox is the board's single intake — it can't be created a second time (card #17). %>
+        <%= f.select "column[archetype]",
+              (Column::ARCHETYPES - %w[inbox]).map { |a| [a.capitalize, a] }, selected: "planning" %>
+        <%= f.submit "Add" %>
+      <% end %>
+    </details>
+  </div>
+</header>
+
+<main class="board">
+  <% @board.columns.each do |column| %>
+    <%= render "columns/column", column: column %>
+  <% end %>
+</main>
+
+<%= turbo_frame_tag "modal", data: { turbo_permanent: true } do %>
+  <%= render "cards/detail" if @card %>
+<% end %>

data/app/views/cards/_card.html.erb

@@ -0,0 +1,48 @@
+<article class="card status-<%= card.status %>" id="<%= dom_id(card) %>" data-card-id="<%= card.number %>">
+  <%= link_to card_path(card), class: "card-link", data: { turbo_frame: "modal", turbo_action: "advance" } do %>
+    <div class="card-title">
+      <%= card.title %>
+      <span class="status-glyph"><%= { "working" => "⚡", "needs_input" => "❓", "failed" => "✖",
+                                       "work_complete" => "✅", "done" => "✓", "queued" => "⏳",
+                                       "discussing" => "💬", "in_review" => "👁", "approved" => "👍",
+                                       "changes_requested" => "🔁" }[card.status] %></span>
+    </div>
+    <% if card.queued? %>
+      <% ahead = card.column.cards.where(status: "queued").where("position < ?", card.position).count %>
+      <p class="card-progress">⏳ queued<%= ahead.positive? ? " — #{ahead} ahead" : " — next up" %></p>
+    <% elsif card.working? && card.column.ai? %>
+      <p class="card-progress working-line"><span class="spinner"></span> <%= card.latest_progress || "agent starting…" %></p>
+    <% elsif card.latest_progress && card.running? %>
+      <p class="card-progress">▸ <%= card.latest_progress %></p>
+    <% elsif card.approved? %>
+      <p class="card-progress approved-text">👍 approved — drag to Done to ship</p>
+    <% elsif card.changes_requested? %>
+      <p class="card-progress attention-text">🔁 changes requested</p>
+    <% elsif card.needs_attention? %>
+      <p class="card-progress attention-text"><%= card.status.humanize %></p>
+    <% end %>
+    <div class="card-meta">
+      <% card.tags.each do |tag| %><span class="tag"><%= tag %></span><% end %>
+      <% if card.running? && card.column.ai? && card.column.model %>
+        <span class="chip agent-chip">🤖 <%= card.column.model_short %><%= " · #{card.column.effort}" if card.column.effort %></span>
+      <% end %>
+      <% if card.awaiting_assistant? %>
+        <span class="chip agent-chip thinking-chip">🪶 <span class="typing-dots mini"><span></span><span></span><span></span></span></span>
+      <% elsif card.discussing? && card.events.conversation.last&.actor == "assistant" %>
+        <span class="chip agent-chip">🪶 replied</span>
+      <% end %>
+      <% if (card.running? || card.needs_attention?) && (last_run = card.runs.order(:id).last) && (last_run.cost.to_f.positive? || last_run.output_tokens.positive?) %>
+        <span class="chip">$<%= last_run.cost.round(2) %><%= " · #{(last_run.output_tokens / 1000.0).round(1)}k out" if card.working? %></span>
+      <% end %>
+      <% if card.parent_id %><span class="chip">↑ sub</span><% end %>
+      <% if card.children.any? %><span class="chip">↳ <%= card.children.where(status: %w[done archived]).count %>/<%= card.children.count %></span><% end %>
+      <% if card.branch_name && card.pr_url.blank? %><span class="chip branch">🌿 <%= card.branch_name.delete_prefix("cardinal/") %></span><% end %>
+    </div>
+  <% end %>
+  <% if card.pr_url %>
+    <a class="card-footer" href="<%= card.pr_url %>" target="_blank" rel="noopener" title="Open the pull request on GitHub">
+      <span class="footer-left"><%# future: Asana / Trello / linked-ticket slot %></span>
+      <span class="footer-pr">GitHub #<%= card.pr_url[%r{/pull/(\d+)}, 1] %> ↗</span>
+    </a>
+  <% end %>
+</article>