cardinal-ai 0.2.7 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c16d402a271ff7a720232c12b775f43784eadd3268c1ce417fd2939d777be42e
-  data.tar.gz: 808ae0945e6f6104b3ef103468ce78c36406af25c78da223cd380a02336d5ef8
+  metadata.gz: 8ad9a65f2b86ce70952431f7f4c7689ddf6791213f7667d4bf87c2230381bce6
+  data.tar.gz: adc0e789a102a8382516b9b1eecd06fc911476187ce92ed4030e7e020c7c8ccb
 SHA512:
-  metadata.gz: 4bd7c1c24d5969321f07753a3c14e2a09ecc561537dfd6f6365502b07c54aafbf93c22f84ed8a0eec9782ce1b9135606f2bbdf3fd0afc8c21f34d06d87896197
-  data.tar.gz: 84270e725e825a11eb81abd67de4bbec459cc736fc9cf1e43b41e926f4a0df346f7df15f0afa906ec2b669671ae74f7cc0287a1ac0c7eb25d630d120b1da3ad4
+  metadata.gz: 73e01d661c1341d873927ce0504de1f7f7e946f6fa7611bd96d4bdcb39e391fc55cb4f012fc66c67f7cf60e271a56bd11c7ca58a170cb9ff2bb0baebb708be5a
+  data.tar.gz: 1dee5696b49d701fa0f9ef4ee4f9d4b1e4a69c1b3a5d77b3d4f8cfe5379133024fcc853e9b91f89f0078183d0055e2b7b58c78669108b37f89e8614916ec7050

data/app/assets/stylesheets/cardinal.css

@@ -87,6 +87,27 @@ a { color: var(--blue); text-decoration: none; }
   font-size: 13px;
 }
 
+/* Board search & filter (card #51): global box center-top, per-column 🔍. */
+.topbar-center { flex: 1; display: flex; justify-content: center; padding: 0 14px; }
+.global-search {
+  width: min(340px, 38vw); background: var(--surface-2); border: 1px solid var(--border);
+  border-radius: 6px; color: var(--text); padding: 5px 10px;
+}
+.global-search::placeholder, .col-search::placeholder { color: var(--text-dim); }
+.col-tools { display: flex; align-items: center; gap: 6px; }
+.col-search-toggle {
+  background: none; border: 0; padding: 0 2px; cursor: pointer;
+  font-size: 12px; opacity: .55; line-height: 1;
+}
+.col-search-toggle:hover { opacity: 1; }
+.col-search {
+  display: none; margin: 0 0 8px; width: 100%;
+  background: var(--surface-2); border: 1px solid var(--border); border-radius: 6px;
+  color: var(--text); padding: 4px 8px; font-size: 12px;
+}
+.col-search.open { display: block; }
+.filter-hidden { display: none !important; }
+
 .pull-form { display: inline; }
 #repo-pull-status { font-size: 0.85rem; }
 #repo-pull-status .pull-ok  { color: var(--green); }
@@ -216,9 +237,9 @@ body.dragging .drop-hint { display: block; }
 }
 .card-footer:hover .footer-pr { color: var(--blue); }
 .footer-left { min-width: 1px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.footer-right { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }
-.footer-cost { white-space: nowrap; }
-.footer-pr { color: var(--text-dim); }
+.footer-center { min-width: 1px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; text-align: center; }
+.footer-cost { white-space: nowrap; flex-shrink: 0; }
+.footer-pr { color: var(--text-dim); flex-shrink: 0; }
 
 /* Open-card cost tally: sits at the foot of the work panel, live-updating. */
 .work-footer {

data/app/controllers/boards_controller.rb

@@ -60,10 +60,19 @@ class BoardsController < ApplicationController
   def pull
     board = Board.first!
     message, ok = pull_repo(board)
-    render turbo_stream: turbo_stream.update(
+    streams = [turbo_stream.update(
       "repo-pull-status",
       helpers.tag.span(message, class: ok ? "pull-ok" : "pull-err")
-    )
+    )]
+    if @pulled_commits
+      # New code often means new JS (Stimulus controllers, importmap entries)
+      # that an already-open tab will never fetch — Turbo morphs keep the page
+      # alive on stale assets forever. A pull is a deliberate "give me the new
+      # version", so finish the job with a full reload.
+      streams << turbo_stream.append("repo-pull-status",
+        helpers.tag.script("setTimeout(() => window.location.reload(), 1200)".html_safe))
+    end
+    render turbo_stream: streams
   end
 
   private
@@ -87,7 +96,8 @@ class BoardsController < ApplicationController
       count, = Open3.capture2e("git", "-C", repo, "rev-list", "--count", "#{before.strip}..#{after.strip}")
       migrated = run_pending_migrations
       note = migrated.positive? ? " · ran #{helpers.pluralize(migrated, "migration")}" : ""
-      ["Pulled #{helpers.pluralize(count.strip.to_i, "new commit")}#{note}", true]
+      @pulled_commits = true
+      ["Pulled #{helpers.pluralize(count.strip.to_i, "new commit")}#{note} · reloading…", true]
     end
   end
 

data/app/controllers/cards_controller.rb

@@ -1,5 +1,5 @@
 class CardsController < ApplicationController
-  before_action :set_card, only: [:show, :update, :move, :approve, :summarize, :destroy]
+  before_action :set_card, only: [:show, :update, :move, :approve, :summarize, :compact, :destroy]
 
   def new
     @board = Board.first!
@@ -30,11 +30,11 @@ class CardsController < ApplicationController
   end
 
   def show
-    @zoom = params[:zoom].presence_in(%w[conversation activity debug summary]) || "conversation"
+    @zoom = params[:zoom].presence_in(%w[conversation activity debug summary compact]) || "conversation"
     @events = case @zoom
               when "conversation" then @card.events.conversation
               when "activity" then @card.events.activity
-              when "summary" then Event.none # the Summary tab shows the card summary, not events
+              when "summary", "compact" then Event.none # these tabs show a card panel, not events
               else @card.events
               end
 
@@ -56,6 +56,7 @@ class CardsController < ApplicationController
     attrs.delete(:pr_url) if @card.pr_url.present?
     @card.update!(attrs)
     log_changelog!
+    log_config_change!
 
     respond_to do |format|
       # Explicitly patch the board face in this tab too — Turbo suppresses a
@@ -81,7 +82,20 @@ class CardsController < ApplicationController
       @card.update!(status: "approved")
       @card.log!("status_change", actor: "user", text: "Work approved — drag to Done to ship")
     end
-    redirect_to card_path(@card)
+
+    respond_to do |format|
+      # Flash the verdict in place, then let the dismiss controller minimize the
+      # modal. Patch the board face too — Turbo suppresses this tab's own refresh
+      # broadcast, so without this the card keeps its stale status once we close.
+      format.turbo_stream do
+        render turbo_stream: [
+          turbo_stream.replace(helpers.dom_id(@card), partial: "cards/card", locals: { card: @card }),
+          turbo_stream.replace("review-callout", partial: "cards/dismiss_flash",
+                                                  locals: { message: "Approved — closing…" })
+        ]
+      end
+      format.html { redirect_to card_path(@card) }
+    end
   end
 
   # Generate a customer-friendly summary on demand (card #35). Non-blocking,
@@ -97,6 +111,19 @@ class CardsController < ApplicationController
              partial: "cards/summary_panel", locals: { card: @card })
   end
 
+  # Generate a technical "compact" journal on demand (card #34). The AI-readable
+  # mirror of #summarize: flip the card into its "working" state, morph the Compact
+  # panel so the button reflects it, and let CompactJob do the one-shot synthesis
+  # in the background. Skipped when one is already running.
+  def compact
+    unless @card.compact_working?
+      @card.update!(compact_status: "working")
+      CompactJob.perform_later(@card)
+    end
+    render turbo_stream: turbo_stream.replace("card_compact",
+             partial: "cards/compact_panel", locals: { card: @card })
+  end
+
   def move
     from_column = @card.column
     to_column = @card.board.columns.find(params[:column_id])
@@ -120,15 +147,19 @@ class CardsController < ApplicationController
   end
 
   def card_params
-    attrs = params.require(:card).permit(:title, :description, :tags, :branch_name, :pr_url, :summary)
+    attrs = params.require(:card).permit(:title, :description, :tags, :branch_name, :pr_url, :summary, :compact, :model, :effort)
     attrs[:tags] = attrs[:tags].to_s.split(",").map(&:strip).reject(&:blank?) if attrs.key?(:tags)
+    # Blank model/effort from the "Use column default" option mean "no override" —
+    # store nil so effective_* falls back to the column (card #33).
+    attrs[:model] = attrs[:model].presence if attrs.key?(:model)
+    attrs[:effort] = attrs[:effort].presence if attrs.key?(:effort)
     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 summary]
+    changed = @card.previous_changes.keys & %w[title description tags branch_name pr_url summary compact]
     return if changed.empty?
 
     last = @card.events.order(:id).last
@@ -140,4 +171,16 @@ class CardsController < ApplicationController
                  text: "Details edited: #{changed.join(", ")}")
     end
   end
+
+  # A model/effort override is not a routine detail edit — it changes what the
+  # card will spend on. Log each change explicitly with its old→new value (the
+  # "config_change" kind, card #33) instead of coalescing it into the changelog
+  # above, so the timeline records exactly what the money will run on and when.
+  def log_config_change!
+    (@card.previous_changes.keys & %w[model effort]).each do |field|
+      old, new = @card.previous_changes[field].map { |v| v.presence || "column default" }
+      @card.log!("config_change", actor: "user", field: field, old: old, new: new,
+                 text: "#{field.capitalize} changed: #{old} → #{new}")
+    end
+  end
 end

data/app/controllers/runs_controller.rb

@@ -21,7 +21,17 @@ class RunsController < ApplicationController
       card.log!("plan_approved", actor: "user", run: run, text: "Plan approved")
       ResumeRunJob.perform_later(run.id, "", approve: true)
     end
-    redirect_to card_path(card)
+
+    respond_to do |format|
+      # Flash the approval in place, then the dismiss controller minimizes the
+      # modal. The run advances asynchronously (ResumeRunJob), so there's no
+      # synchronous card state to morph here — just confirm and close.
+      format.turbo_stream do
+        render turbo_stream: turbo_stream.replace("plan-callout", partial: "cards/dismiss_flash",
+                                                                  locals: { message: "Plan approved — running…" })
+      end
+      format.html { redirect_to card_path(card) }
+    end
   end
 
   # Restart a run that parked or failed on its turn budget / timeout. Mirrors

data/app/helpers/application_helper.rb

@@ -13,6 +13,16 @@ module ApplicationHelper
     options
   end
 
+  # Model options for a card's per-card override (card #33). Same list as the
+  # column gear, but the blank option reads "Use column default (<model>)" so the
+  # fallback names the concrete model the card runs on when left unset.
+  def card_model_options(card)
+    options = model_options(card.model)
+    default = card.column.model_short.presence
+    options[0] = ["Use column default#{" (#{default})" if default}", ""]
+    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.

data/app/javascript/controllers/dismiss_controller.js

@@ -0,0 +1,23 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Briefly show a confirmation, then minimize the surrounding card modal.
+// Rendered into an approval callout so the user sees the verdict land before
+// the card snaps back to the columns view. On connect we start a timer; when
+// it fires we hand off to the enclosing modal controller's close().
+export default class extends Controller {
+  static values = { delay: { type: Number, default: 1100 } }
+
+  connect() {
+    this.timer = setTimeout(() => this.dismiss(), this.delayValue)
+  }
+
+  disconnect() {
+    clearTimeout(this.timer)
+  }
+
+  dismiss() {
+    const el = this.element.closest("[data-controller~='modal']")
+    if (!el) return
+    this.application.getControllerForElementAndIdentifier(el, "modal")?.close()
+  }
+}

data/app/javascript/controllers/filter_controller.js

@@ -0,0 +1,103 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Board search & filter (card #51): one global query (topbar center) plus
+// optional per-column queries (🔍 in each column header). A card must match
+// both the global query and its own column's query; non-matches hide.
+//
+// Filter state lives HERE, not in the DOM — Turbo morphs and column stream
+// replaces rebuild board markup at will, so a MutationObserver restores input
+// values and re-applies hiding after every re-render.
+export default class extends Controller {
+  static targets = ["global"]
+
+  connect() {
+    this.state = { global: "", cols: {} }
+    this.slash = (e) => {
+      if (e.key === "/" && !e.target.closest("input, textarea, [contenteditable]")) {
+        e.preventDefault()
+        this.globalTarget.focus()
+      }
+    }
+    document.addEventListener("keydown", this.slash)
+    // childList only: our own class/value writes are attribute mutations and
+    // must not re-trigger (no observe loop).
+    this.observer = new MutationObserver(() => this.schedule())
+    this.observer.observe(this.element, { childList: true, subtree: true })
+  }
+
+  disconnect() {
+    document.removeEventListener("keydown", this.slash)
+    this.observer?.disconnect()
+    clearTimeout(this.timer)
+  }
+
+  schedule() {
+    clearTimeout(this.timer)
+    this.timer = setTimeout(() => this.restore(), 60)
+  }
+
+  global(event) {
+    this.state.global = event.target.value
+    this.apply()
+  }
+
+  column(event) {
+    this.state.cols[event.target.dataset.colId] = event.target.value
+    this.apply()
+  }
+
+  toggle(event) {
+    const col = event.currentTarget.closest(".column")
+    const input = col.querySelector(".col-search")
+    if (input.classList.toggle("open")) {
+      input.focus()
+    } else {
+      input.value = ""
+      this.state.cols[col.dataset.colId] = ""
+      this.apply()
+    }
+  }
+
+  // Esc inside a search box clears just that box.
+  clear(event) {
+    if (event.key !== "Escape") return
+    event.target.value = ""
+    if (this.hasGlobalTarget && event.target === this.globalTarget) {
+      this.state.global = ""
+    } else {
+      this.state.cols[event.target.dataset.colId] = ""
+    }
+    event.target.blur()
+    this.apply()
+  }
+
+  // After a morph or column replace rebuilt markup: put state back into any
+  // re-rendered inputs (never fighting one the user is typing in), re-open
+  // column boxes that hold a query, then re-hide.
+  restore() {
+    if (this.hasGlobalTarget && document.activeElement !== this.globalTarget) {
+      this.globalTarget.value = this.state.global
+    }
+    this.element.querySelectorAll(".col-search").forEach(input => {
+      const q = this.state.cols[input.dataset.colId] || ""
+      if (document.activeElement !== input) input.value = q
+      if (q !== "") input.classList.add("open")
+    })
+    this.apply()
+  }
+
+  apply() {
+    const g = this.norm(this.state.global)
+    this.element.querySelectorAll(".card[data-search]").forEach(card => {
+      const colId = card.closest(".column")?.dataset.colId
+      const c = this.norm(this.state.cols[colId])
+      const hay = card.dataset.search
+      const hit = (!g || hay.includes(g)) && (!c || hay.includes(c))
+      card.classList.toggle("filter-hidden", !hit)
+    })
+  }
+
+  norm(value) {
+    return (value || "").trim().toLowerCase()
+  }
+}

data/app/jobs/assistant_reply_job.rb

@@ -45,7 +45,9 @@ class AssistantReplyJob < ApplicationJob
   # assistant's last reply, not just the latest message.
   def converse(card, kickoff:)
     repo = card.board.local_path.presence
-    common = { model: card.column.model.presence || FALLBACK_MODEL,
+    # Effective model honors a per-card override (card #33) — the same
+    # effective_model the worker uses, so one card resolves one model everywhere.
+    common = { model: card.effective_model.presence || FALLBACK_MODEL,
                tools: repo ? "Read,Glob,Grep" : nil,
                cwd: repo, max_turns: MAX_TURNS, with_session: true }
 

data/app/jobs/compact_job.rb

@@ -0,0 +1,97 @@
+# On-demand, AI-readable "compact" of a card (card #34): the technical mirror of
+# SummaryJob. Where Summary compresses a card into a couple of non-technical lines
+# for a customer chat, Compact distills everything that happened — the brief,
+# timeline, runs, final reports, and code commits — into a dense technical journal
+# a *resuming agent* can read instead of re-exploring the repo and re-deriving
+# context. That's the whole point: spend a few tokens now to save many later.
+# Generation is user-triggered only; the result persists on the card and stays
+# fully editable. A prior compact (possibly hand-edited) rides along as context so
+# a regeneration refines rather than discards what the user kept.
+class CompactJob < ApplicationJob
+  queue_as :default
+
+  FALLBACK_MODEL = "claude-haiku-4-5-20251001".freeze
+
+  SYSTEM = <<~SYS.freeze
+    You write a dense, technical engineering journal for an AI agent that will
+    resume work on this card later. Your reader is a machine, not a customer:
+    optimize for signal, not readability. Capture, in compact form, everything a
+    resuming engineer needs so they do NOT have to re-explore the repo or re-derive
+    context — what was built and how, files and components touched, key APIs and
+    libraries used, decisions made and the reasons behind them, issues found,
+    blockers hit, and anything left unfinished or deliberately deferred. Prefer
+    terse structured notes (short headings, bullets, file paths, symbol names) over
+    prose. Omit pleasantries and customer-facing framing. Write only the journal.
+  SYS
+
+  def perform(card)
+    return clear_working(card) unless ClaudeCli.available?
+
+    model = card.board.columns.find_by(archetype: "planning")&.model.presence || FALLBACK_MODEL
+    compact = ClaudeCli.prompt(build_prompt(card), system: SYSTEM, model: model, max_turns: 1)
+
+    card.update!(compact: compact.to_s.strip, compact_generated_at: Time.current, compact_status: nil)
+    card.broadcast_replace_to card, target: "card_compact",
+                              partial: "cards/compact_panel", locals: { card: card }
+  rescue StandardError
+    # A failed generation must not leave the button stuck on "Generating…".
+    clear_working(card)
+  end
+
+  private
+
+  def clear_working(card)
+    card.update!(compact_status: nil)
+    card.broadcast_replace_to card, target: "card_compact",
+                              partial: "cards/compact_panel", locals: { card: card }
+  end
+
+  def build_prompt(card)
+    parts = ["Card ##{card.number}: #{card.title}"]
+    parts << "Tags: #{card.tags.join(", ")}" if card.tags.any?
+    parts << "\nBrief / description:\n#{card.description}" if card.description.present?
+
+    timeline = card.events.activity.filter_map { |e| event_line(e) }
+    parts << "\nWhat happened (technical timeline):\n#{timeline.join("\n")}" if timeline.any?
+
+    reports = card.events.where(kind: "final_report").filter_map(&:text).map(&:strip).reject(&:blank?)
+    parts << "\nFinal reports from runs:\n#{reports.join("\n\n---\n\n")}" if reports.any?
+
+    runs = card.runs.order(:id).map { |r| "- Run ##{r.id}: #{r.status}#{" (#{r.phase})" if r.phase.present?}" }
+    parts << "\nRuns:\n#{runs.join("\n")}" if runs.any?
+
+    commits = commit_lines(card)
+    parts << "\nCode changes (commit messages):\n#{commits.join("\n")}" if commits.any?
+
+    if card.compact.present?
+      parts << "\nThe existing technical compact is below. It may have been edited by hand, " \
+               "so preserve details the user kept and fold in any new work rather than " \
+               "starting from scratch:\n#{card.compact}"
+    end
+
+    parts.join("\n")
+  end
+
+  def event_line(event)
+    text = event.text.to_s.strip
+    return nil if text.blank?
+    "- #{event.actor}: #{text.truncate(600)}"
+  end
+
+  # Commit messages for the card's branch, read from the per-card workspace
+  # checkout when it still exists. The checkout isn't guaranteed to be present
+  # (it's left in place after a run but may be pruned), so this is best-effort —
+  # the timeline already narrates the work when commits are unavailable.
+  def commit_lines(card)
+    return [] if card.branch_name.blank?
+    path = Agent::Workspace::Local.new(card).path
+    return [] unless File.directory?(path.join(".git"))
+
+    base = "origin/#{card.board.default_branch}"
+    out, ok = Open3.capture2e("git", "-C", path.to_s, "log", "--oneline", "--no-decorate", "#{base}..HEAD")
+    return [] unless ok.success?
+    out.lines.map(&:strip).reject(&:blank?).map { |l| "- #{l}" }
+  rescue StandardError
+    []
+  end
+end

data/app/jobs/merge_pr_job.rb

@@ -7,11 +7,17 @@ class MergePrJob < ApplicationJob
     card = Card.find(card_id)
     return if card.pr_url.blank? || card.pr_state == "merged"
     return unless checks_green?(card)
+    return unless mergeable?(card)
 
     # Best-effort undraft — a QA column may already have done it, and gh
     # errors on an already-ready PR; the merge step is the real gate.
     Open3.capture2e("gh", "pr", "ready", card.pr_url)
-    run_step(card, ["gh", "pr", "merge", card.pr_url, "--squash", "--delete-branch"]) or return
+    unless run_step(card, ["gh", "pr", "merge", card.pr_url, "--squash", "--delete-branch"])
+      # The floor (card #55): a card whose merge failed must never sit in
+      # Done claiming done — block it so the attention dropdown surfaces it.
+      card.update!(status: "blocked")
+      return
+    end
 
     card.update!(pr_state: "merged")
     card.log!("status_change", text: "PR squash-merged and branch deleted — shipped 🎉")
@@ -40,6 +46,25 @@ class MergePrJob < ApplicationJob
     false
   end
 
+  # A sibling card's merge can conflict this one after its CI ran (card #55) —
+  # mergeability is a separate axis from checks. Ask before attempting so the
+  # conflict parks with a clean reason instead of a raw gh error. UNKNOWN
+  # (GitHub still computing) and gh hiccups fall through to the merge attempt,
+  # which remains the authority.
+  def mergeable?(card)
+    out, status = Open3.capture2e("gh", "pr", "view", card.pr_url, "--json", "mergeable")
+    return true unless status.success?
+    return true unless JSON.parse(out)["mergeable"] == "CONFLICTING"
+
+    card.log!("error", text: "Merge conflict with #{card.board.default_branch} — not merged. " \
+                             "Another card's merge likely landed first. Drag this card back to " \
+                             "In Progress for a conflict-resolution run, then bring it back here.")
+    card.update!(status: "blocked")
+    false
+  rescue JSON::ParserError
+    true
+  end
+
   def run_step(card, cmd)
     out, status = Open3.capture2e(*cmd)
     return true if status.success?

data/app/jobs/start_run_job.rb

@@ -21,7 +21,9 @@ class StartRunJob < ApplicationJob
       return
     end
 
-    session = card.agent_sessions.create!(status: "provisioning", model: column.model)
+    # Record the model the session actually runs on — the card's effective
+    # (possibly overridden) model, not the raw column default (card #33).
+    session = card.agent_sessions.create!(status: "provisioning", model: card.effective_model)
     run = session.runs.create!(status: "queued", briefing: { "card" => card.title, "column" => column.name })
     Agent::Runner.start(run)
   end

data/app/models/card.rb

@@ -1,4 +1,6 @@
 class Card < ApplicationRecord
+  include ModelLabeling
+
   STATUSES = %w[
     draft discussing queued working needs_input blocked failed
     work_complete in_review changes_requested approved done archived
@@ -23,6 +25,15 @@ class Card < ApplicationRecord
   has_many :agent_sessions, dependent: :destroy
   has_many :runs, through: :agent_sessions
 
+  # Card-face status glyphs. Keyed on status, except `ready_for_approval?`
+  # (a derived plan-park state, not a status) which pre-empts the ❓ below.
+  STATUS_GLYPHS = {
+    "working" => "⚡", "needs_input" => "❓", "failed" => "✖",
+    "work_complete" => "✅", "done" => "✓", "queued" => "⏳",
+    "discussing" => "💬", "in_review" => "👁", "approved" => "👍",
+    "changes_requested" => "🔁"
+  }.freeze
+
   enum :status, STATUSES.index_by(&:itself)
 
   validates :title, presence: true
@@ -42,13 +53,52 @@ class Card < ApplicationRecord
   # A customer-friendly summary is being (re)generated in the background (§card #35).
   def summary_working? = summary_status == "working"
 
+  # A technical "compact" journal is being (re)generated in the background (§card
+  # #34) — the AI-readable context a resuming agent reads to skip re-exploration.
+  def compact_working? = compact_status == "working"
+
   def running? = %w[queued working needs_input].include?(status)
 
+  # The agent has proposed a plan and is parked waiting on the user's approve
+  # click — distinct from a genuine question. Same underlying `needs_input`
+  # status; the plan-phase park is the signal (mirrors the work panel, §detail).
+  # The status guard means the run query only fires for already-parked cards.
+  def ready_for_approval?
+    needs_input? && runs.needs_input.order(:id).last&.phase == "plan"
+  end
+
+  # Card-face glyph: a bell when a plan is awaiting approval, else the plain
+  # per-status mapping.
+  def status_glyph
+    ready_for_approval? ? "🔔" : STATUS_GLYPHS[status]
+  end
+
   # Latest one-line progress event, shown live on the card face (§6).
   def latest_progress
     events.where(kind: "progress").last&.payload&.[]("text")
   end
 
+  # Per-card model/effort override (card #33). Nil fields mean "use the column
+  # default", so existing cards are unaffected. Read fresh at every segment
+  # spawn (start, restart, resume) by the runner and the planning assistant, so
+  # a change takes effect on the next segment — never on an already-running one.
+  def effective_model  = model.presence || column.model
+  def effective_effort = effort.presence || column.effort
+
+  # Does this card override either half of the column's "how much brain" pair?
+  # Drives the de-magic marker on the card face: the board must never hide that
+  # a card will spend on a model other than its column's default.
+  def config_overridden? = model.present? || effort.present?
+
+  # "Opus - High*" — the effective model label for card faces and footers, with
+  # a trailing * when overridden so the override is visible without opening the
+  # card. Nil when no model resolves (AI off / unset), matching Column#model_label.
+  def effective_model_label
+    label = model_label_of(effective_model, effective_effort)
+    return if label.blank?
+    config_overridden? ? "#{label}*" : label
+  end
+
   # Running tally across every run on the card — the closed-card cost footer
   # (card #20). Sums stopped/restarted segments so the total reflects real spend.
   def total_cost = runs.sum(:cost)

data/app/models/column.rb

@@ -1,4 +1,6 @@
 class Column < ApplicationRecord
+  include ModelLabeling
+
   ARCHETYPES = %w[inbox planning execution review terminal].freeze
 
   belongs_to :board
@@ -105,17 +107,11 @@ class Column < ApplicationRecord
   end
 
   # "claude-sonnet-4-6" → "sonnet", for compact chips on card faces.
-  def model_short
-    model.to_s[/claude-([a-z]+)/, 1] || model
-  end
+  def model_short = model_short_of(model)
 
   # "Opus - High" — human label for cost footers (card #20). Effort is optional,
   # so a model with no configured effort renders just "Opus".
-  def model_label
-    return if model.blank?
-    label = model_short.to_s.capitalize
-    effort.present? ? "#{label} - #{effort.to_s.capitalize}" : label
-  end
+  def model_label = model_label_of(model, effort)
 
   validates :name, presence: true
   validates :position, presence: true

data/app/models/concerns/model_labeling.rb

@@ -0,0 +1,20 @@
+# Shared model-name formatting for the two places a model+effort pair is
+# resolved and shown: a Column's own policy and a Card's effective (possibly
+# overridden) config. Kept in one place so a card face and its column can never
+# disagree about how a model reads — the board must not misreport what spends.
+module ModelLabeling
+  extend ActiveSupport::Concern
+
+  # "claude-sonnet-4-6" → "sonnet"; passes through a non-claude name unchanged.
+  def model_short_of(model_name)
+    model_name.to_s[/claude-([a-z]+)/, 1] || model_name.presence
+  end
+
+  # "Opus - High" — human label from a model + optional effort. Effort is
+  # optional, so a model with no effort renders just "Opus". Blank model → nil.
+  def model_label_of(model_name, effort_name)
+    return if model_name.blank?
+    label = model_short_of(model_name).to_s.capitalize
+    effort_name.present? ? "#{label} - #{effort_name.to_s.capitalize}" : label
+  end
+end

data/app/models/event.rb

@@ -1,7 +1,7 @@
 class Event < ApplicationRecord
   KINDS = %w[
     user_message agent_message assistant_message
-    status_change column_move move_rejected plan_proposed plan_approved
+    status_change config_change column_move move_rejected plan_proposed plan_approved
     question answer progress
     tool_call tool_result artifact_created
     run_started run_finished final_report error

data/app/services/agent/runner.rb

@@ -125,8 +125,11 @@ module Agent
         # list itself, not a request in the prompt.
         cmd += ["--tools", "Read,Glob,Grep,Edit,Write"] unless column.shell_access?
       end
-      cmd += ["--model", column.model] if column.model.present?
-      cmd += ["--effort", column.effort] if column.effort.present?
+      # Effective (possibly card-overridden) config, read fresh here at spawn
+      # time — so a mid-run override takes effect on the next segment (start,
+      # restart, resume), never on one already streaming (card #33).
+      cmd += ["--model", card.effective_model] if card.effective_model.present?
+      cmd += ["--effort", card.effective_effort] if card.effective_effort.present?
       cmd += ["--resume", run.external_session_id] if resuming && run.external_session_id.present?
 
       result = {}
@@ -356,7 +359,7 @@ module Agent
         ## Card conversation so far
         #{conversation_excerpt.presence || "(none)"}
 
-        #{"## Column instructions\n#{column.instructions}\n" if column.instructions.present?}
+        #{compact_section}#{"## Column instructions\n#{column.instructions}\n" if column.instructions.present?}
         #{execute_rules}
       PROMPT
     end
@@ -377,7 +380,7 @@ module Agent
         ## Card conversation so far
         #{conversation_excerpt.presence || "(none)"}
 
-        #{"## Column instructions\n#{column.instructions}\n" if column.instructions.present?}
+        #{compact_section}#{"## Column instructions\n#{column.instructions}\n" if column.instructions.present?}
         Explore the repository as needed, then present a short numbered plan-of-attack
         (files you'll touch, approach, how you'll verify) and stop. The user will approve
         or redirect before any changes are made.
@@ -398,6 +401,25 @@ module Agent
       "## Repo brief\n#{brief.strip}\n\n"
     end
 
+    # The user-generated technical "compact" (card #34), if one exists — a dense
+    # journal of prior work on this card written for a resuming agent. Injected so
+    # the agent picks up where the last session left off instead of re-deriving
+    # context. Explicitly framed as technical resume notes, distinct from the
+    # human conversation above and from the customer-facing summary. Empty string
+    # (not nil) when absent, so the heredoc stays clean.
+    def compact_section
+      compact = card.compact.presence or return ""
+      <<~SECTION
+        ## Technical resume context (compact from a prior work session)
+        The notes below were generated (and possibly hand-edited) to capture the
+        technical state of prior work on this card — what was built, decided, and
+        blocked. Treat them as an authoritative shortcut to avoid re-exploring the
+        repo; verify against the actual code before relying on any specific detail.
+        #{compact.strip}
+
+      SECTION
+    end
+
     # The planning assistant's distilled "Ready for execution" brief, if the
     # conversation produced one — the most load-bearing artifact of planning.
     def planning_brief

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

@@ -1,5 +1,6 @@
 <%= turbo_stream_from @board %>
 
+<div data-controller="filter">
 <header class="topbar">
   <div class="topbar-left">
     <h1>Cardinal AI <span class="sep">▸</span> <span id="board-name"><%= @board.name %></span></h1>
@@ -37,6 +38,11 @@
     <% end %>
     <span id="repo-pull-status"></span>
   </div>
+  <div class="topbar-center">
+    <input type="search" id="global-search" class="global-search" placeholder="Search cards…  /"
+           data-filter-target="global"
+           data-action="input->filter#global keydown->filter#clear">
+  </div>
   <div class="topbar-right">
     <button type="button" class="theme-toggle"
             data-controller="theme" data-action="theme#toggle">☀ Light</button>
@@ -108,6 +114,7 @@
     <%= render "columns/column", column: column %>
   <% end %>
 </main>
+</div>
 
 <%= turbo_frame_tag "modal", data: { turbo_permanent: true } do %>
   <%= render "cards/detail" if @card %>

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

@@ -1,11 +1,9 @@
-<article class="card status-<%= card.status %>" id="<%= dom_id(card) %>" data-card-id="<%= card.number %>">
+<article class="card status-<%= card.status %>" id="<%= dom_id(card) %>" data-card-id="<%= card.number %>"
+         data-search="<%= [card.title, "##{card.number}", Array(card.tags).join(" "), card.description.to_s.truncate(400)].join(" ").downcase %>">
   <%= 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>
+      <span class="status-glyph"><%= card.status_glyph %></span>
     </div>
     <% if card.queued? %>
       <% ahead = card.column.cards.where(status: "queued").where("position < ?", card.position).count %>
@@ -23,9 +21,6 @@
     <% 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" %>
@@ -39,15 +34,13 @@
   <% has_cost = card.total_cost.positive? || card.total_output_tokens.positive? %>
   <% if has_cost || card.pr_url.present? %>
     <div class="card-footer">
-      <span class="footer-left"><%= card.column.model_label if has_cost %></span>
-      <span class="footer-right">
-        <% if has_cost %>
-          <span class="footer-cost">$<%= card.total_cost.round(2) %> · <%= card.total_output_tokens %> out</span>
-        <% end %>
-        <% if card.pr_url.present? %>
-          <a class="footer-pr" href="<%= card.pr_url %>" target="_blank" rel="noopener" title="Open the pull request on GitHub">GitHub #<%= card.pr_url[%r{/pull/(\d+)}, 1] %> ↗</a>
-        <% end %>
-      </span>
+      <% if card.pr_url.present? %>
+        <a class="footer-pr" href="<%= card.pr_url %>" target="_blank" rel="noopener" title="Open the pull request on GitHub">GitHub #<%= card.pr_url[%r{/pull/(\d+)}, 1] %> ↗</a>
+      <% else %>
+        <span class="footer-pr"></span>
+      <% end %>
+      <span class="footer-center"><%= "🤖 #{card.effective_model_label}" if has_cost && card.effective_model_label %></span>
+      <span class="footer-cost"><%= "$#{card.total_cost.round(2)}" if has_cost %></span>
     </div>
   <% end %>
 </article>

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

@@ -0,0 +1,28 @@
+<div id="card_compact" class="summary-panel compact-panel" data-controller="autosave">
+  <div class="summary-head">
+    <h3>Technical compact <span class="autosave-status" data-autosave-target="status"></span></h3>
+    <% if card.compact_working? %>
+      <button type="button" class="deep-dive working summary-generate" disabled>
+        <span class="pulse-dot"></span> Generating…
+      </button>
+    <% else %>
+      <%= button_to compact_card_path(card), class: "deep-dive summary-generate",
+            title: "Distill everything this card did into a dense technical journal a resuming agent can read" do %>
+        ✨ <%= card.compact.present? ? "Regenerate" : "Generate compact" %>
+      <% end %>
+    <% end %>
+  </div>
+
+  <p class="hint summary-blurb">A dense, technical journal of what was built, decided, and blocked — the AI reads this to resume work without re-exploring the repo. Fully editable; your edits are respected when you regenerate.</p>
+
+  <%= form_with model: card, class: "summary-form",
+        data: { autosave_target: "form", action: "input->autosave#save change->autosave#save" } do |f| %>
+    <%= hidden_field_tag :autosave, "1" %>
+    <%= f.text_area :compact, rows: 10, placeholder: "No compact yet — click Generate compact, or write your own technical notes.",
+          disabled: card.compact_working? %>
+  <% end %>
+
+  <% if card.compact_generated_at.present? %>
+    <p class="hint summary-stamp">Last generated <%= time_ago_in_words(card.compact_generated_at) %> ago</p>
+  <% end %>
+</div>

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

@@ -31,7 +31,7 @@
       <div class="detail-panes">
         <section class="timeline" data-controller="scroll">
           <nav class="zoom-tabs">
-            <% %w[conversation activity debug summary].each do |zoom| %>
+            <% %w[conversation activity debug summary compact].each do |zoom| %>
               <%= link_to zoom.capitalize, card_path(@card, zoom: zoom),
                           class: ("active" if @zoom == zoom) %>
             <% end %>
@@ -41,6 +41,10 @@
             <div class="timeline-scroll">
               <%= render "cards/summary_panel", card: @card %>
             </div>
+          <% elsif @zoom == "compact" %>
+            <div class="timeline-scroll">
+              <%= render "cards/compact_panel", card: @card %>
+            </div>
           <% else %>
           <div class="timeline-scroll" data-scroll-target="scroller">
             <% if @card.description.present? %>
@@ -123,7 +127,7 @@
               <%= link_to "View Pull Request", @card.pr_url, target: "_blank", rel: "noopener", class: "pr-view-btn" %>
             <% end %>
             <% if @card.in_review? %>
-              <div class="panel-callout callout-plan">
+              <div class="panel-callout callout-plan" id="review-callout">
                 <p><strong>Your verdict.</strong> Check the final report in the timeline.
                 Approve, or just say what's wrong in the conversation — that marks it changes-requested,
                 and dragging the card back to a work column carries your feedback into the next run.</p>
@@ -136,12 +140,44 @@
             <% end %>
           <% end %>
 
+          <%# Per-card model/effort override (card #33). Its own autosave form so a
+              change saves and re-renders the card face (override marker) without
+              replacing this modal mid-interaction. The summary names the effective
+              state even when collapsed — the board must not hide what will spend. %>
+          <div class="model-override" data-controller="autosave">
+            <%= form_with model: @card, data: { autosave_target: "form", action: "change->autosave#save" } do |f| %>
+              <%= hidden_field_tag :autosave, "1" %>
+              <details class="advanced-rules">
+                <summary>
+                  🧠 Model:
+                  <% if @card.config_overridden? %>
+                    <strong>override</strong> (<%= @card.effective_model_label&.delete_suffix("*") || "none" %>)
+                  <% else %>
+                    column default (<%= @card.column.model_label || "none" %>)
+                  <% end %>
+                  <span class="autosave-status" data-autosave-target="status"></span>
+                </summary>
+                <div class="field-row">
+                  <div>
+                    <label>Model <%= info_tip("Overrides the column's model for THIS card only — worker runs and this card's planning replies both. Leave on \"Use column default\" to follow the column.") %></label>
+                    <%= f.select :model, card_model_options(@card), selected: @card.model.to_s %>
+                  </div>
+                  <div>
+                    <label>Effort <%= info_tip("How hard the model thinks per step, for this card only. Higher = smarter but slower and pricier. Leave on default to follow the column.") %></label>
+                    <%= f.select :effort, [["Use column default", ""], "low", "medium", "high", "max"], selected: @card.effort %>
+                  </div>
+                </div>
+                <p class="hint">Overrides this card's model and effort. Only model + effort — budget, timeout, and concurrency are column policy. Takes effect on the next run segment (a run already going finishes on the model it started with).</p>
+              </details>
+            <% end %>
+          </div>
+
           <h3>Work</h3>
           <% runs = @card.runs.order(:id) %>
           <% parked = runs.select(&:needs_input?).last %>
           <% latest = runs.last %>
           <% if parked&.phase == "plan" %>
-            <div class="panel-callout callout-plan">
+            <div class="panel-callout callout-plan" id="plan-callout">
               <p><strong>Plan proposed.</strong> Approve to let the agent execute, or reply in the timeline to redirect.</p>
               <%= button_to "👍 Approve plan", approve_run_path(parked), class: "approve-btn", form_class: "align-right" %>
             </div>
@@ -183,7 +219,7 @@
 
           <% if latest && (latest.cost.positive? || latest.output_tokens.positive?) %>
             <div class="work-footer">
-              <span class="footer-left"><%= @card.column.model_label %></span>
+              <span class="footer-left"><%= "🤖 #{@card.effective_model_label}" if @card.effective_model_label %></span>
               <span class="footer-cost">$<%= latest.cost.round(2) %> · <%= latest.output_tokens %> out</span>
             </div>
           <% end %>

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

@@ -0,0 +1,5 @@
+<%# Momentary confirmation shown in place of an approval callout, then it
+    auto-closes the card modal (see dismiss_controller). %>
+<div class="panel-callout callout-plan" data-controller="dismiss" data-dismiss-delay-value="1100">
+  <p><strong><%= message %></strong></p>
+</div>

data/app/views/columns/_column.html.erb

@@ -8,9 +8,16 @@
                     data: { turbo_frame: "modal" } %>
       <% end %>
     </span>
-    <%= link_to "⚙", edit_column_path(column), class: "gear", title: "Column settings",
-                data: { turbo_frame: "modal" } %>
+    <span class="col-tools">
+      <button type="button" class="col-search-toggle" title="Filter this column"
+              data-action="filter#toggle">🔍</button>
+      <%= link_to "⚙", edit_column_path(column), class: "gear", title: "Column settings",
+                  data: { turbo_frame: "modal" } %>
+    </span>
   </header>
+  <input type="search" class="col-search" placeholder="Filter <%= column.name %>…"
+         data-col-id="<%= column.id %>"
+         data-action="input->filter#column keydown->filter#clear">
   <p class="drop-hint">→ <%= column.drag_hint %></p>
   <div class="cards<%= " cards-clickable" if column.inbox? %>"
        data-controller="board-column"

data/config/routes.rb

@@ -11,6 +11,7 @@ Rails.application.routes.draw do
       patch :move
       post :approve
       post :summarize
+      post :compact
     end
     resources :messages, only: [:create]
   end

data/db/migrate/20260704140000_add_compact_to_cards.rb

@@ -0,0 +1,7 @@
+class AddCompactToCards < ActiveRecord::Migration[8.1]
+  def change
+    add_column :cards, :compact, :text
+    add_column :cards, :compact_generated_at, :datetime
+    add_column :cards, :compact_status, :string
+  end
+end

data/db/migrate/20260704231436_add_model_and_effort_to_cards.rb

@@ -0,0 +1,6 @@
+class AddModelAndEffortToCards < ActiveRecord::Migration[8.1]
+  def change
+    add_column :cards, :model, :string
+    add_column :cards, :effort, :string
+  end
+end

data/lib/cardinal/version.rb

@@ -1,3 +1,3 @@
 module Cardinal
-  VERSION = "0.2.7"
+  VERSION = "0.2.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cardinal-ai
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.9
 platform: ruby
 authors:
 - Jason Ellis
@@ -175,6 +175,8 @@ files:
 - app/javascript/controllers/board_column_controller.js
 - app/javascript/controllers/clipboard_controller.js
 - app/javascript/controllers/composer_controller.js
+- app/javascript/controllers/dismiss_controller.js
+- app/javascript/controllers/filter_controller.js
 - app/javascript/controllers/index.js
 - app/javascript/controllers/modal_controller.js
 - app/javascript/controllers/reveal_controller.js
@@ -185,6 +187,7 @@ files:
 - app/jobs/ai_task_job.rb
 - app/jobs/application_job.rb
 - app/jobs/assistant_reply_job.rb
+- app/jobs/compact_job.rb
 - app/jobs/deep_dive_job.rb
 - app/jobs/mark_pr_ready_job.rb
 - app/jobs/merge_pr_job.rb
@@ -198,6 +201,7 @@ files:
 - app/models/board.rb
 - app/models/card.rb
 - app/models/column.rb
+- app/models/concerns/model_labeling.rb
 - app/models/event.rb
 - app/models/run.rb
 - app/services/agent/runner.rb
@@ -211,7 +215,9 @@ files:
 - app/views/boards/edit.html.erb
 - app/views/boards/show.html.erb
 - app/views/cards/_card.html.erb
+- app/views/cards/_compact_panel.html.erb
 - app/views/cards/_detail.html.erb
+- app/views/cards/_dismiss_flash.html.erb
 - app/views/cards/_summary_panel.html.erb
 - app/views/cards/_tag_picker.html.erb
 - app/views/cards/new.html.erb
@@ -259,6 +265,8 @@ files:
 - db/migrate/20260704000002_add_assistant_session_to_cards.rb
 - db/migrate/20260704120000_add_repo_brief_to_boards.rb
 - db/migrate/20260704130000_add_summary_to_cards.rb
+- db/migrate/20260704140000_add_compact_to_cards.rb
+- db/migrate/20260704231436_add_model_and_effort_to_cards.rb
 - db/queue_schema.rb
 - db/seeds.rb
 - docker/agent/Dockerfile