cardinal-ai 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: decfcea83bc4294b6cf14e947fa1586dee954dfaa30250b67df7d1c29377c191
-  data.tar.gz: f6718005edcdeda0d1608d13d93211c7785af98ca2297ef418d96457724c6d1d
+  metadata.gz: ea33d976c3ebc53402438e5dae5e6b480842034e1a77a1c58142d62ad1f347e2
+  data.tar.gz: 7571417a375ab611c9345a6b2d7ab6cea33233e668d90414edae44ea2d116048
 SHA512:
-  metadata.gz: 7c106ef6387b43103682e495071e3dfa1d04701eea84c2192f9c67c132ae623a5fa9614294e7e59606e0fad300cf9147008013906d6d9981799e4e3ea0740c89
-  data.tar.gz: 1e2b72553d1bd2c6fd678bd7a3bd8c49c5ec6acc902026546d51d7e0fa9fe783803285e4f2933319f52f1193f1850cf3dc516fb6439b402ef97daa78393f96e3
+  metadata.gz: db9ec21facb032331fd8686f772e1c1313e0e84388f675eb723e92847c0c7638325d2af5ff8d392f2536c292d0929a79f64e53f040ef1206bb74097477c1f9e1
+  data.tar.gz: c290a471053fc66929db5fe9b3219bb49dc85f2b953b4a33beab0878e261d7ed4e815dc5b1b57ca9f8346f2ba9a7e73f7607a30f1af08e09a6665311dfdd6811

data/app/assets/stylesheets/cardinal.css

@@ -52,6 +52,7 @@ a { color: var(--blue); text-decoration: none; }
 }
 .topbar h1 { font-size: 16px; margin: 0; font-weight: 600; }
 .topbar h1 .sep { color: var(--accent); margin: 0 4px; }
+.topbar-left { display: flex; align-items: center; gap: 12px; }
 .topbar-right { display: flex; align-items: center; gap: 14px; }
 
 .theme-toggle {
@@ -60,6 +61,29 @@ a { color: var(--blue); text-decoration: none; }
 }
 .theme-toggle:hover { color: var(--text); border-color: var(--text-dim); }
 
+/* Repo deep dive button (card #12). Inline color/border come from the board's
+   staleness gradient (grey → red over 10 commits); .stale-critical flashes to
+   nag a refresh once the brief is too far behind HEAD to trust. */
+.topbar-right form.button_to { display: inline-flex; margin: 0; }
+.deep-dive {
+  display: inline-flex; align-items: center; gap: 6px;
+  background: transparent; border: 1px solid var(--border); border-radius: 6px;
+  color: var(--text-dim); font-weight: 600; padding: 5px 10px; line-height: 1;
+  cursor: pointer; white-space: nowrap;
+}
+.deep-dive:hover:not(:disabled) { filter: brightness(1.25); }
+.deep-dive:disabled { cursor: default; opacity: .8; }
+.deep-dive.stale-critical { animation: stale-flash 1.1s ease-in-out infinite; }
+@keyframes stale-flash {
+  0%, 100% { opacity: 1; box-shadow: 0 0 0 0 rgba(212, 51, 51, .55); }
+  50%      { opacity: .7; box-shadow: 0 0 0 3px rgba(212, 51, 51, 0); }
+}
+
+.pull-form { display: inline; }
+#repo-pull-status { font-size: 0.85rem; }
+#repo-pull-status .pull-ok  { color: var(--green); }
+#repo-pull-status .pull-err { color: var(--red); }
+
 .attention summary {
   cursor: pointer;
   color: var(--amber);
@@ -154,6 +178,10 @@ button, input[type="submit"] {
 body.dragging .drop-hint { display: block; }
 .ticker { font-size: 11px; color: var(--text-dim); margin: 0 4px 8px; }
 
+.column-footer { margin-top: 8px; padding-top: 8px; border-top: 1px solid var(--border); font-size: 11px; color: var(--text-dim); }
+.footer-row { display: flex; justify-content: space-between; gap: 8px; padding: 1px 4px; }
+.footer-value { font-variant-numeric: tabular-nums; color: var(--text); }
+
 .cards { min-height: 40px; display: flex; flex-direction: column; gap: 8px; flex: 1; overflow-y: auto; }
 .cards-clickable { cursor: pointer; }
 .agent-chip { color: var(--blue); }
@@ -509,6 +537,22 @@ body.dragging .drop-hint { display: block; }
 [data-theme="light"] .card-footer { background: #e2e5ea; border-top-color: rgba(0, 0, 0, .1); }
 
 /* Accept-policy visibility while dragging + rejected-drop flash */
-.column.drop-blocked { opacity: .45; }
+.column.drop-blocked { opacity: .35; filter: grayscale(.5) brightness(.7); transition: opacity .15s, filter .15s; }
 .column.drop-blocked .drop-hint { color: var(--red); }
 .column.drop-blocked .drop-hint::before { content: "✗ won't accept from here — "; }
+
+.hidden { display: none !important; }
+
+/* The reveal wrappers must be invisible to the form's flex layout — their
+   children should behave as direct .card-edit flex items (full width). */
+.card-edit [data-controller="reveal"],
+.card-edit [data-reveal-target="panel"] { display: contents; }
+.card-edit textarea, .card-edit input[type="text"] { width: 100%; }
+
+.default-rule.active-rule { border-left-color: var(--green); }
+
+.archetype-locked {
+  font-size: 13px; color: var(--text-dim); margin: 0;
+  padding: 6px 10px; background: var(--surface-2);
+  border: 1px solid var(--border); border-radius: 6px;
+}

data/app/controllers/boards_controller.rb

@@ -2,4 +2,54 @@ class BoardsController < ApplicationController
   def show
     @board = Board.includes(columns: :cards).first!
   end
+
+  # Kick off the repo deep dive (card #12). Non-blocking: flip the board into
+  # its "Working" state, morph the topbar so the button reflects it, and let
+  # DeepDiveJob do the read-only exploration in the background. Ignored if a
+  # dive is already running.
+  def deep_dive
+    board = Board.first!
+    unless board.brief_working?
+      board.update!(brief_status: "working")
+      board.broadcast_refresh_to board
+      DeepDiveJob.perform_later(board)
+    end
+    redirect_to root_path
+  end
+
+  # Cards reaching Done merge PRs on GitHub, so the checkout Cardinal runs
+  # against falls behind. The topbar Pull button fast-forwards it. --ff-only
+  # on purpose: never invent merge commits or rebase local work — if the tree
+  # has diverged, say so and let the human sort it out in a real terminal.
+  def pull
+    board = Board.first!
+    message, ok = pull_repo(board)
+    render turbo_stream: turbo_stream.update(
+      "repo-pull-status",
+      helpers.tag.span(message, class: ok ? "pull-ok" : "pull-err")
+    )
+  end
+
+  private
+
+  def pull_repo(board)
+    repo = board.local_path.presence
+    return ["No local repo path on this board", false] unless repo && Dir.exist?(File.join(repo, ".git"))
+
+    before, = Open3.capture2e("git", "-C", repo, "rev-parse", "HEAD")
+    out, status = Open3.capture2e("git", "-C", repo, "pull", "--ff-only")
+    unless status.success?
+      # Surface git's own reason (diverged, offline, auth) — the last
+      # non-blank line is usually the one that matters.
+      return [out.lines.map(&:strip).reject(&:blank?).last.to_s.truncate(120), false]
+    end
+
+    after, = Open3.capture2e("git", "-C", repo, "rev-parse", "HEAD")
+    if before.strip == after.strip
+      ["Already up to date", true]
+    else
+      count, = Open3.capture2e("git", "-C", repo, "rev-list", "--count", "#{before.strip}..#{after.strip}")
+      ["Pulled #{helpers.pluralize(count.strip.to_i, "new commit")}", true]
+    end
+  end
 end

data/app/controllers/columns_controller.rb

@@ -25,8 +25,8 @@ class ColumnsController < ApplicationController
     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,
-      accepts_from: []
+      :on_entry_text, :on_entry_json, :color, :custom_color, :arrivals, :ai,
+      :footer_text, accepts_from: []
     )
 
     policy = @column.policy.dup
@@ -37,41 +37,84 @@ class ColumnsController < ApplicationController
     end
     policy["plan_approval"] = attrs[:plan_approval] == "1"
     policy["arrivals"] = attrs[:arrivals].presence_in(%w[top bottom])
-    # Accept policy (card #15): store allowed source column ids as strings;
-    # blank means accept from any column (backward-compatible default).
+    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 attrs[:on_entry_text].present?
+    if !@archetype_changed && attrs[:on_entry_text].present?
       if attrs[:on_entry_text].strip != policy["on_entry_text"].to_s.strip
-        begin
+          begin
           policy["on_entry"] = Rules::Compiler.compile(attrs[:on_entry_text])
         rescue Rules::Compiler::Error => e
-          @json_error = e.message
-          return render :edit, status: :unprocessable_entity
+          return column_error(e.message)
         end
       end
       policy["on_entry_text"] = attrs[:on_entry_text].strip
-    elsif attrs[:on_entry_json].present?
+    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
-        @json_error = "on_entry is not valid JSON: #{e.message.truncate(120)}"
-        return render :edit, status: :unprocessable_entity
+        return column_error("on_entry is not valid JSON: #{e.message.truncate(120)}")
       end
-    else
+    elsif !@archetype_changed
       policy.delete("on_entry")
       policy.delete("on_entry_text")
     end
 
+    # Footer (card #18): one row per line as "Label | compute". A blank compute
+    # is a static label; a compute must be one Column knows how to aggregate.
+    begin
+      policy["footer"] = parse_footer(attrs[:footer_text])
+    rescue ArgumentError => e
+      return column_error(e.message)
+    end
+
     @column.update!(
       name: attrs[:name].presence || @column.name,
-      archetype: attrs[:archetype].presence_in(Column::ARCHETYPES) || @column.archetype,
+      archetype: new_archetype,
       policy: policy.compact
     )
-    redirect_to root_path
+
+    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
@@ -91,5 +134,21 @@ class ColumnsController < ApplicationController
 
   private
 
+  # "Label | compute" lines → [{"label" =>, "compute" =>}]. Returns nil when
+  # empty so the key is dropped by policy.compact. Raises ArgumentError on an
+  # unknown compute key, mirroring the on_entry validation path.
+  def parse_footer(text)
+    rows = text.to_s.lines.filter_map do |line|
+      next if line.strip.blank?
+      label, compute = line.split("|", 2).map(&:strip)
+      compute = compute.to_s
+      if compute.present? && !Column::FOOTER_COMPUTES.include?(compute)
+        raise ArgumentError, "Footer compute \"#{compute}\" is not one of: #{Column::FOOTER_COMPUTES.join(', ')}"
+      end
+      { "label" => label.to_s, "compute" => compute.presence }.compact
+    end
+    rows.presence
+  end
+
   def set_column = @column = Column.find(params[:id])
 end

data/app/controllers/messages_controller.rb

@@ -18,7 +18,7 @@ class MessagesController < ApplicationController
       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?
+      AssistantReplyJob.perform_later(card) if card.column.planning? && card.column.ai?
     end
     redirect_to card_path(card)
   end

data/app/helpers/application_helper.rb

@@ -26,6 +26,14 @@ module ApplicationHelper
     MARKDOWN.render(text.to_s).html_safe
   end
 
+  # Render a column's stored footer config (array of {label, compute} hashes)
+  # back into the "Label | compute" line format the gear textarea edits.
+  def footer_config_text(column)
+    Array(column.footer).map do |row|
+      [row["label"], row["compute"].presence].compact.join(" | ")
+    end.join("\n")
+  end
+
   def info_tip(text)
     tag.span("i", class: "info",
              data: { controller: "tooltip", tooltip_text_value: text,

data/app/javascript/controllers/autosave_controller.js

@@ -5,24 +5,39 @@ export default class extends Controller {
   static targets = ["status", "form"]
 
   connect() {
-    this.onEnd = () => {
+    this.onEnd = (event) => {
       if (!this.hasStatusTarget) return
-      this.statusTarget.textContent = "Saved ✓"
+      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.formTarget.requestSubmit(), 800)
+    this.timer = setTimeout(() => {
+      this.timer = null
+      this.formTarget.requestSubmit()
+    }, 800)
   }
 }

data/app/javascript/controllers/board_column_controller.js

@@ -37,9 +37,9 @@ export default class extends Controller {
   markBlockedColumns() {
     const sourceId = this.element.dataset.columnId
     document.querySelectorAll(".column").forEach(section => {
-      const accepts = section.dataset.accepts
-      if (!accepts || section.dataset.colId === sourceId) return
-      if (!accepts.split(",").includes(sourceId)) section.classList.add("drop-blocked")
+      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")
     })
   }
 

data/app/javascript/controllers/modal_controller.js

@@ -29,6 +29,8 @@ export default class extends Controller {
   }
 
   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 = ""

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))
+  }
+}

data/app/jobs/deep_dive_job.rb

@@ -0,0 +1,64 @@
+# Opt-in repo deep dive (card #12): a one-shot, read-only agent (the same
+# cheap ClaudeCli tier the planning assistant uses — Read/Glob/Grep, no
+# workspace) that maps the board's repo into a compact "repo brief". The brief
+# is written to .cardinal/repo-brief.md and injected into every worker prompt,
+# converting the per-run exploration tax into a one-time cost.
+class DeepDiveJob < ApplicationJob
+  queue_as :default
+
+  # Enough turns to walk the tree and read a handful of key files, not enough
+  # to wander. ClaudeCli wraps up from context if it hits the cap.
+  MAX_TURNS = 30
+  FALLBACK_MODEL = "claude-haiku-4-5-20251001".freeze
+
+  PROMPT = <<~PROMPT.freeze
+    Map this repository as a concise "repo brief" for other AI agents who will
+    work in it. The whole point is to save tokens later, so be dense and skip
+    the obvious — every line must earn its place.
+
+    Explore with your read-only tools, then output ONLY flat markdown with these
+    sections (drop any that genuinely don't apply):
+
+    ## Overview
+    One short paragraph: what this project is and its shape.
+    ## Directory Structure
+    The top-level directories and what each is for (one line each).
+    ## Key Directories
+    The few places most work actually happens, and what lives there.
+    ## Build & Test
+    The exact commands to install, build, run, and test.
+    ## Key Conventions
+    Naming, patterns, and idioms an agent must follow to match the codebase.
+    ## Tech Stack
+    Languages, frameworks, and notable libraries with their role.
+    ## Gotchas
+    Non-obvious traps, footguns, and constraints worth knowing before editing.
+
+    Do not include a preamble, closing remarks, or anything outside these sections.
+  PROMPT
+
+  def perform(board)
+    repo = board.local_path.presence
+    return clear_working(board) unless ClaudeCli.available? && repo
+
+    sha = board.head_sha
+    model = board.columns.find_by(archetype: "planning")&.model.presence || FALLBACK_MODEL
+
+    brief = ClaudeCli.prompt(PROMPT, model:, tools: "Read,Glob,Grep", cwd: repo, max_turns: MAX_TURNS)
+
+    File.write(board.brief_path, brief.to_s)
+    board.update!(brief_sha: sha, brief_generated_at: Time.current,
+                  brief_model: model, brief_status: nil)
+    board.broadcast_refresh_to board
+  rescue StandardError
+    # A failed dive must not leave the button stuck on "Working" forever.
+    clear_working(board)
+  end
+
+  private
+
+  def clear_working(board)
+    board.update!(brief_status: nil)
+    board.broadcast_refresh_to board
+  end
+end

data/app/jobs/start_run_job.rb

@@ -3,7 +3,7 @@ class StartRunJob < ApplicationJob
 
   def perform(card_id)
     card = Card.find(card_id)
-    return unless card.queued? && card.column.execution?
+    return unless card.queued? && card.column.execution? && card.column.ai?
     return if card.column.at_wip_limit? # stays queued; kicked when a slot frees
 
     session = card.agent_sessions.create!(status: "provisioning", model: card.column.model)

data/app/models/board.rb

@@ -1,19 +1,53 @@
 class Board < ApplicationRecord
+  # Captured from the author's live board (2026-07-05) — the battle-tested
+  # layout. accepts_from is stored as NAMES here and resolved to column ids
+  # by install_default_columns! (ids don't exist until creation).
   DEFAULT_COLUMNS = [
-    { name: "Tasks",       archetype: "inbox",     policy: {} },
-    { name: "Planning",    archetype: "planning",  policy: { "model" => "claude-haiku-4-5-20251001" } },
+    { name: "Tasks",       archetype: "inbox",
+      policy: { "plan_approval" => false,
+                "accepts_from_names" => ["Planning", "Review", "QA", "Done"] } },
+    { name: "Planning",    archetype: "planning",
+      policy: { "ai" => true, "model" => "claude-haiku-4-5-20251001", "plan_approval" => false,
+                "on_entry" => [{ "action" => "assistant_greeting" }],
+                "on_entry_text" => "The planning assistant reads the card and opens the discussion.",
+                "accepts_from_names" => ["Tasks", "In Progress", "Review", "QA"] } },
     { name: "In Progress", archetype: "execution",
-      policy: { "model" => "claude-sonnet-4-6", "effort" => "high", "concurrency_limit" => 3,
-                "plan_approval" => true, "max_turns" => 80, "timeout_minutes" => 30,
-                "on_entry" => [{ "action" => "start_agent_run" }] } },
-    { name: "Review",      archetype: "review",    policy: {} },
-    { name: "QA",          archetype: "review",
-      policy: { "on_entry" => [{ "action" => "mark_pr_ready" }],
+      policy: { "ai" => true, "model" => "claude-opus-4-8", "effort" => "high",
+                "concurrency_limit" => 3, "plan_approval" => true,
+                "budget_per_run_cents" => 200, "timeout_minutes" => 90, "max_turns" => 80,
+                "tools" => %w[read edit run_commands git_commit_push],
+                "on_entry" => [{ "action" => "start_agent_run" }],
+                "accepts_from_names" => ["Planning", "Review", "QA"],
+                "instructions" => "Follow repo conventions. Write tests when the repo has a suite." } },
+    { name: "Review",      archetype: "review",
+      policy: { "ai" => true, "plan_approval" => false,
+                "accepts_from_names" => ["In Progress", "QA"],
+                "on_entry" => [{ "action" => "mark_pr_ready" }],
                 "on_entry_text" => "Take the PR out of draft — mark it ready for review on GitHub." } },
+    { name: "QA",          archetype: "review",
+      policy: { "ai" => true, "plan_approval" => false,
+                "accepts_from_names" => ["Review"],
+                "on_entry" => [{ "action" => "mark_pr_ready" }] } },
     { name: "Done",        archetype: "terminal",
-      policy: { "on_entry" => [{ "action" => "merge_pr" }], "arrivals" => "top" } }
+      policy: { "ai" => false, "plan_approval" => false, "arrivals" => "top",
+                "accepts_from_names" => ["Review", "QA", "Planning"],
+                "on_entry" => [{ "action" => "merge_pr" }] } }
   ].freeze
 
+  # Create the default columns, then resolve accepts_from_names -> ids.
+  def install_default_columns!
+    DEFAULT_COLUMNS.each_with_index do |attrs, index|
+      columns.create!(name: attrs[:name], archetype: attrs[:archetype], position: index,
+                      policy: attrs[:policy].except("accepts_from_names"))
+    end
+    DEFAULT_COLUMNS.each do |attrs|
+      names = attrs[:policy]["accepts_from_names"] or next
+      col = columns.find_by!(name: attrs[:name])
+      ids = columns.where(name: names).pluck(:id).map(&:to_s)
+      col.update!(policy: col.policy.merge("accepts_from" => ids))
+    end
+  end
+
   has_many :columns, -> { order(:position) }, dependent: :destroy
   has_many :cards, dependent: :destroy
 
@@ -34,9 +68,7 @@ class Board < ApplicationRecord
       default_branch: branch_ok.success? && branch.strip.present? ? branch.strip : "main",
       local_path: repo_path
     )
-    DEFAULT_COLUMNS.each_with_index do |attrs, index|
-      board.columns.create!(position: index, **attrs)
-    end
+    board.install_default_columns!
     board
   end
 
@@ -51,6 +83,63 @@ class Board < ApplicationRecord
     cards.pluck(:tags).flatten.compact.uniq.sort
   end
 
+  # --- Repo brief (card #12) ---------------------------------------------
+  # A one-time deep dive that maps the repo, stored as flat markdown in
+  # .cardinal/ (never the host repo) and injected into worker prompts to
+  # spare each run the exploration tax. Metadata (which SHA/model/when) lives
+  # on the board so staleness can be judged against the current HEAD.
+  #
+  # Storage is a file + metadata, not one text column, so a structure
+  # provider (the Graphify child card) can slot a richer representation in
+  # underneath later without a migration.
+  BRIEF_STALE_AT = 10 # commits behind → the "refresh me" red/flashing state
+
+  def brief_path = Rails.root.join(".cardinal", "repo-brief.md")
+
+  def repo_brief
+    File.read(brief_path) if File.exist?(brief_path)
+  end
+
+  def brief?
+    brief_sha.present? && File.exist?(brief_path)
+  end
+
+  def brief_working? = brief_status == "working"
+
+  # HEAD of the board's repo right now — the yardstick staleness measures against.
+  def head_sha
+    return nil if local_path.blank?
+    out, ok = Open3.capture2e("git", "-C", local_path, "rev-parse", "HEAD")
+    ok.success? ? out.strip : nil
+  end
+
+  # How many commits landed since the brief was generated. nil when there's
+  # no brief (nothing to be stale against) or the SHA is unknown to the repo.
+  def commits_behind_brief
+    return @commits_behind_brief if defined?(@commits_behind_brief)
+    @commits_behind_brief =
+      if brief_sha.blank? || local_path.blank?
+        nil
+      else
+        out, ok = Open3.capture2e("git", "-C", local_path, "rev-list", "--count", "#{brief_sha}..HEAD")
+        ok.success? ? out.strip.to_i : nil
+      end
+  end
+
+  def brief_stale? = (commits_behind_brief || 0) >= BRIEF_STALE_AT
+
+  # Grey → red interpolation over 0..BRIEF_STALE_AT commits behind, emitted
+  # as a validated hex into the button's inline style (mirrors Column#safe_color).
+  # Deep red once the brief is stale enough to over-anchor on.
+  def brief_staleness_color
+    behind = commits_behind_brief || 0
+    grey = [0x8a, 0x8a, 0x8a]
+    red  = [0xd4, 0x33, 0x33]
+    t = [behind.to_f / BRIEF_STALE_AT, 1.0].min
+    rgb = grey.zip(red).map { |g, r| (g + (r - g) * t).round }
+    format("#%02x%02x%02x", *rgb)
+  end
+
   # Cards currently waiting on the human, ordered by urgency — feeds the
   # attention inbox in the board header.
   def attention_cards

data/app/models/card.rb

@@ -29,6 +29,9 @@ class Card < ApplicationRecord
   validate :status_legal_for_column
 
   before_validation :assign_number_and_position, on: :create
+  # Optional git fields left blank on the new-card form arrive as "" — store
+  # them as nil so "no PR/branch" is one state, not two ("" renders footers).
+  normalizes :branch_name, :pr_url, with: ->(v) { v.strip.presence }
 
   after_commit -> { broadcast_refresh_to board }
 
@@ -46,7 +49,7 @@ class Card < ApplicationRecord
   # Is the planning assistant expected to post next? True right after entering
   # a planning column (kickoff inspection pending) or after a user message.
   def awaiting_assistant?
-    return false unless column.planning?
+    return false unless column.planning? && column.ai?
     last = events.where(kind: %w[user_message assistant_message error column_move]).order(:id).last
     last.present? && %w[user_message column_move].include?(last.kind)
   end

data/app/models/column.rb

@@ -6,29 +6,86 @@ class Column < ApplicationRecord
 
   enum :archetype, ARCHETYPES.index_by(&:itself)
 
+  # Archetypes are TEMPLATES, not magic: choosing one stamps concrete,
+  # editable values into the policy fields. Nothing falls back to these at
+  # runtime — what the gear modal shows is everything there is.
+  ARCHETYPE_TEMPLATES = {
+    "inbox"     => {},
+    "planning"  => {
+      "on_entry"      => [{ "action" => "assistant_greeting" }],
+      "on_entry_text" => "The planning assistant reads the card and opens the discussion.",
+      "instructions"  => "Drive toward crisp acceptance criteria. Open with the 2-3 sharpest questions."
+    },
+    "execution" => {
+      "on_entry"      => [{ "action" => "start_agent_run" }],
+      "on_entry_text" => "Assign a dedicated worker agent to the card and start a run."
+    },
+    "review"    => {},
+    "terminal"  => {
+      "on_entry"      => [{ "action" => "merge_pr" }],
+      "on_entry_text" => "Merge the card's PR and ship it."
+    }
+  }.freeze
+
+  before_create :seed_archetype_template
+
+  def archetype_template = ARCHETYPE_TEMPLATES.fetch(archetype, {})
+
   # The policy blob is the column's entire behavior configuration (§1, §14.3).
   store_accessor :policy, :instructions, :model, :effort, :concurrency_limit,
                  :plan_approval, :budget_per_run_cents, :timeout_minutes,
                  :max_turns, :tools, :on_entry, :on_success, :color, :arrivals,
-                 :accepts_from
+                 :accepts_from, :footer
+
+  # Aggregations a footer row may compute over the column's cards (card #18).
+  # A compute key not listed here renders blank, so config that outruns the
+  # code degrades gracefully instead of erroring.
+  FOOTER_COMPUTES = %w[sum_cost sum_tokens count_cards].freeze
 
   # Only ever emit a validated hex color into inline styles.
   def safe_color
     color if color.to_s.match?(/\A#\h{6}\z/)
   end
 
+  # Does any AI service this column? Explicit per-column switch (default ON
+  # for back-compat); the inbox/Tasks intake is never AI, unconditionally.
+  # When false the column is inert AI-wise: no assistant, no worker runs,
+  # no ai_task rules — cards there are human work.
+  def ai?
+    return false if inbox?
+    policy["ai"] != false
+  end
+
   # Which columns may move cards INTO this one (§ accept policy, card #15).
-  # Stored as an array of column-id strings; blank = accept from anywhere, so
-  # existing boards keep their unrestricted behavior.
+  # Stored as an array of column-id strings. EXPLICIT ONLY: an empty list
+  # means this column accepts from nowhere — there is no permissive default.
   def accepts?(source_column)
-    ids = Array(accepts_from).map(&:to_s).reject(&:blank?)
-    ids.empty? || ids.include?(source_column.id.to_s)
+    Array(accepts_from).map(&:to_s).include?(source_column.id.to_s)
+  end
+
+  # Rows rendered under the cards (card #18). Footer config is an array of
+  # {"label" => "Total cost:", "compute" => "sum_cost"} hashes; each row pairs
+  # static label text with an optional computed aggregate over this column's
+  # cards. Returns [] when unconfigured, so existing columns render no footer.
+  def footer_rows
+    rows = Array(footer).filter_map do |row|
+      label = row["label"].to_s
+      value = footer_value(row["compute"])
+      next if label.blank? && value.blank?
+      { label:, value: }
+    end
+    # AI columns advertise their active model as a final auto-row (card #32).
+    # Guarded on model presence so an AI column without one adds nothing,
+    # rather than emitting a "Model:" row with a blank value.
+    rows << { label: "Model:", value: model_short } if ai? && model.present?
+    rows
   end
 
   # Start the next queued card when a run slot frees up. A queued card whose
   # run parked and already has its answer recorded resumes instead of
   # starting fresh.
   def kick_queue
+    return unless ai?
     return if at_wip_limit?
     next_card = cards.where(status: "queued").order(:position).first
     return unless next_card
@@ -56,6 +113,21 @@ class Column < ApplicationRecord
     execution? && concurrency_limit.present? && running_count >= concurrency_limit.to_i
   end
 
+  # Aggregate a single footer row over the runs/cards in this column (card #18).
+  # Unknown keys return "" so the row shows just its static label.
+  def footer_value(compute)
+    case compute.to_s
+    when "sum_cost"
+      "$%.2f" % column_runs.sum(:cost)
+    when "sum_tokens"
+      ActiveSupport::NumberHelper.number_to_delimited(column_runs.sum("input_tokens + output_tokens"))
+    when "count_cards"
+      cards.count.to_s
+    else
+      ""
+    end
+  end
+
   # The built-in role contract for AI servicing this archetype — shown
   # read-only in the gear modal so the Instructions field is understood as
   # ADDING to this, never replacing it. Enforced in code, not editable.
@@ -70,6 +142,23 @@ class Column < ApplicationRecord
 
   def built_in_role = BUILT_IN_ROLES[archetype]
 
+  # What "Use AI" concretely means here — the §5 tier distinction, visible.
+  AI_MODES = {
+    "planning"  => "a shared planning assistant joins each card's conversation",
+    "execution" => "a dedicated worker agent is assigned to each card",
+    "review"    => "allow AI on-entry rules (ai_task) in this column",
+    "terminal"  => "allow AI on-entry rules (ai_task) in this column"
+  }.freeze
+
+  def ai_mode_description = AI_MODES[archetype]
+
+  # Stamp template values into any policy field the creator left blank.
+  def seed_archetype_template
+    archetype_template.each do |key, value|
+      policy[key] = value if policy[key].blank?
+    end
+  end
+
   # One-line consequence shown while dragging a card over this column (§14.1).
   def drag_hint
     case archetype
@@ -77,7 +166,14 @@ class Column < ApplicationRecord
     when "planning"  then "The board assistant will join the discussion"
     when "execution" then "An agent will be assigned and start work"
     when "review"    then "Work stops — ready for your verdict"
-    when "terminal"  then "Ships it — PR merged, branch deleted"
+    when "terminal"  then "Closes it — PR merged and branch deleted, if there is one"
     end
   end
+
+  private
+
+  # Every run belonging to a card in this column, for footer aggregation.
+  def column_runs
+    Run.joins(agent_session: :card).where(cards: { column_id: id })
+  end
 end

data/app/services/agent/runner.rb

@@ -329,7 +329,7 @@ module Agent
         ## Brief
         #{card.description.presence || "(no description — infer scope from the title and conversation)"}
 
-        #{"## Brief from planning (authoritative — refined with the user)\n#{planning_brief}\n" if planning_brief}
+        #{repo_brief_section}#{"## Brief from planning (authoritative — refined with the user)\n#{planning_brief}\n" if planning_brief}
         ## Card conversation so far
         #{conversation_excerpt.presence || "(none)"}
 
@@ -346,7 +346,7 @@ module Agent
         ## Brief
         #{card.description.presence || "(no description — infer scope from the title and conversation)"}
 
-        #{"## Brief from planning (authoritative — refined with the user)\n#{planning_brief}\n" if planning_brief}
+        #{repo_brief_section}#{"## Brief from planning (authoritative — refined with the user)\n#{planning_brief}\n" if planning_brief}
         ## Card conversation so far
         #{conversation_excerpt.presence || "(none)"}
 
@@ -363,6 +363,14 @@ module Agent
       PROMPT
     end
 
+    # The one-time repo deep dive (card #12), injected ahead of the planning
+    # brief so the agent starts oriented instead of re-exploring the tree each
+    # run. Empty string (not nil) when there's no brief, so the heredoc stays clean.
+    def repo_brief_section
+      brief = card.board.repo_brief.presence or return ""
+      "## Repo brief\n#{brief.strip}\n\n"
+    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/services/card_transition.rb

@@ -79,7 +79,7 @@ class CardTransition
     case @to.archetype
     when "inbox"     then "draft"
     when "planning"  then "discussing"
-    when "execution" then "queued"
+    when "execution" then @to.ai? ? "queued" : "working" # no AI = a human is on it
     when "review"    then "in_review"
     when "terminal"  then "done"
     end

data/app/services/rules.rb

@@ -1,12 +1,11 @@
 # 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 only supply defaults —
-# any column can carry any rules, including one-shot AI maintenance tasks.
+# 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
-  DEFAULTS = {
-    "planning"  => [{ "action" => "assistant_greeting" }],
-    "execution" => [{ "action" => "start_agent_run" }],
-    "terminal"  => [{ "action" => "merge_pr" }]
-  }.freeze
+  # 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).
@@ -15,22 +14,48 @@ module Rules
     "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 marked ready, squash-merged, and its branch deleted."
+    "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"], column.archetype) do |rule|
+    each_rule(column.policy["on_entry"]) do |rule|
       apply(rule, card, column)
     end
   end
 
-  def self.each_rule(configured, archetype, &block)
-    rules = configured.presence || DEFAULTS[archetype] || []
+  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

data/app/services/run_sweeper.rb

@@ -31,6 +31,7 @@ module RunSweeper
   # 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.")

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

@@ -1,8 +1,31 @@
 <%= turbo_stream_from @board %>
 
 <header class="topbar">
-  <h1>Cardinal AI <span class="sep">▸</span> <%= @board.name %></h1>
+  <div class="topbar-left">
+    <h1>Cardinal AI <span class="sep">▸</span> <%= @board.name %></h1>
+    <%= button_to "⇣ Pull", pull_board_path, form_class: "pull-form",
+          form: { title: "git pull --ff-only in #{@board.local_path} — fetch what Done has merged" },
+          data: { turbo_submits_with: "⇣ Pulling…" }, class: "theme-toggle" %>
+    <span id="repo-pull-status"></span>
+  </div>
   <div class="topbar-right">
+    <%# Repo deep dive (card #12): one-shot read-only mapping of the repo, stored
+        as a brief and injected into worker prompts. The button greys→reds as the
+        brief falls behind HEAD; a stale brief over-anchors, so it nags at 10+. %>
+    <% behind = @board.commits_behind_brief %>
+    <%= button_to deep_dive_board_path,
+          class: "deep-dive#{' stale-critical' if @board.brief_stale?}#{' working' if @board.brief_working?}",
+          disabled: @board.brief_working?,
+          style: @board.brief? ? "color: #{@board.brief_staleness_color}; border-color: #{@board.brief_staleness_color}" : nil,
+          title: @board.brief? ? "Repo brief from #{@board.brief_sha&.first(7)} · #{@board.brief_generated_at&.to_date}" : "Map this repo into a brief agents reuse — saves exploration on every run" do %>
+      <% if @board.brief_working? %>
+        <span class="pulse-dot"></span> Deep dive · working…
+      <% elsif behind&.positive? %>
+        🔍 Deep dive · <%= behind %> commit<%= "s" if behind != 1 %> behind
+      <% else %>
+        🔍 Deep dive
+      <% end %>
+    <% end %>
     <button type="button" class="theme-toggle"
             data-controller="theme" data-action="theme#toggle">☀ Light</button>
     <% if ENV["CARDINAL_AUTH"].present? %>

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

@@ -10,7 +10,7 @@
     <% 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? %>
+    <% 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>
@@ -23,7 +23,7 @@
     <% end %>
     <div class="card-meta">
       <% card.tags.each do |tag| %><span class="tag"><%= tag %></span><% end %>
-      <% if card.running? && card.column.model %>
+      <% 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? %>
@@ -36,10 +36,10 @@
       <% 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 %>
+      <% if card.branch_name.present? && card.pr_url.blank? %><span class="chip branch">🌿 <%= card.branch_name.delete_prefix("cardinal/") %></span><% end %>
     </div>
   <% end %>
-  <% if card.pr_url %>
+  <% if card.pr_url.present? %>
     <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>

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

@@ -8,7 +8,7 @@
           <span class="card-number-sub" title="Card number — how branches, PRs, and other cards refer to this card">#<%= @card.number %></span>
         </h1>
         <div class="modal-header-right">
-          <% if @card.branch_name %>
+          <% if @card.branch_name.present? %>
             <span class="git-line">
               <span class="branch-base"><%= @card.board.default_branch %></span>
               <span class="git-arrow">→</span>
@@ -17,7 +17,7 @@
                 <button type="button" class="copy-btn" data-clipboard-target="button"
                         data-action="clipboard#copy" title="Copy branch name">⧉</button>
               </span>
-              <% if @card.pr_url %>
+              <% if @card.pr_url.present? %>
                 <span class="git-arrow">→</span>
                 <%= link_to "##{@card.pr_url[%r{/pull/(\d+)}, 1]}", @card.pr_url, target: "_blank", rel: "noopener", class: "pr-link" %>
                 <% if @card.pr_state.present? %><span class="pr-state">(<%= @card.pr_state %>)</span><% end %>
@@ -113,7 +113,7 @@
 
           <% if @card.column.review? %>
             <h3>Review</h3>
-            <% if @card.pr_url %>
+            <% if @card.pr_url.present? %>
               <%= link_to "View Pull Request", @card.pr_url, target: "_blank", rel: "noopener", class: "pr-view-btn" %>
             <% end %>
             <% if @card.in_review? %>
@@ -168,7 +168,7 @@
                 </li>
               <% end %>
             </ul>
-            <% if @card.pr_url %>
+            <% if @card.pr_url.present? %>
               <p>🌿 <%= link_to "View pull request", @card.pr_url, target: "_blank" %><%= " (#{@card.pr_state})" if @card.pr_state.present? %></p>
             <% end %>
           <% else %>

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

@@ -22,4 +22,15 @@
       <%= render "cards/card", card: card %>
     <% end %>
   </div>
+  <% rows = column.footer_rows %>
+  <% if rows.any? %>
+    <footer class="column-footer">
+      <% rows.each do |row| %>
+        <div class="footer-row">
+          <span class="footer-label"><%= row[:label] %></span>
+          <span class="footer-value"><%= row[:value] %></span>
+        </div>
+      <% end %>
+    </footer>
+  <% end %>
 </section>

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

@@ -1,22 +1,29 @@
 <%= turbo_frame_tag "modal", data: { turbo_permanent: true } do %>
   <div class="modal-backdrop" data-controller="modal" data-action="click->modal#backdrop">
-    <div class="modal modal-sm">
+    <div class="modal modal-sm" data-controller="autosave">
       <header class="modal-header">
-        <h1>⚙ <%= @column.name %> <span class="chip"><%= @column.archetype %></span></h1>
+        <h1>⚙ <%= @column.name %> <span class="chip"><%= @column.archetype %></span>
+            <span class="autosave-status" data-autosave-target="status"></span></h1>
         <button type="button" class="modal-close" data-action="modal#close" title="Close (Esc)">✕</button>
       </header>
       <div class="modal-body">
-        <% if @json_error %><p class="form-error"><%= @json_error %></p><% end %>
+        <div id="column-form-errors"><% if @json_error %><p class="form-error"><%= @json_error %></p><% end %></div>
 
-        <%= form_with model: @column, class: "card-edit" do |f| %>
+        <%= form_with model: @column, class: "card-edit",
+              data: { autosave_target: "form", action: "input->autosave#save change->autosave#save" } do |f| %>
+          <%= hidden_field_tag :autosave, "1" %>
           <div class="field-row">
             <div>
               <label>Name <%= info_tip("The column's display name on the board.") %></label>
               <%= f.text_field :name, required: true %>
             </div>
             <div>
-              <label>Archetype <%= info_tip("What kind of stage this is. Inbox: parking lot, no AI. Planning: a shared assistant discusses cards with you. Execution: each card gets its own worker agent that does the work. Review: work stops for your verdict. Terminal: finalizes the card (Done merges the PR).") %></label>
-              <%= f.select :archetype, Column::ARCHETYPES.map { |a| [a.capitalize, a] } %>
+              <label>Archetype <%= info_tip("What kind of stage this is. Planning: a shared assistant discusses cards with you. Execution: each card gets its own worker agent that does the work. Review: work stops for your verdict. Terminal: finalizes the card (Done merges the PR). Inbox isn't selectable — the board has exactly one, the far-left intake.") %></label>
+              <% if @column.inbox? %>
+                <p class="archetype-locked">Inbox — the board's single intake (fixed)</p>
+              <% else %>
+                <%= f.select :archetype, (Column::ARCHETYPES - ["inbox"]).map { |a| [a.capitalize, a] } %>
+              <% end %>
             </div>
             <div>
               <label>Arrivals <%= info_tip("Where cards land when dragged into this column. 'Top' makes it a feed — newest first, no matter where you drop (the Done default). Reordering inside the column stays manual.") %></label>
@@ -34,7 +41,7 @@
           <% siblings = @column.board.columns.where.not(id: @column.id).order(:position) %>
           <% if siblings.any? %>
             <% allowed = Array(@column.accepts_from).map(&:to_s) %>
-            <label>Accepts moves from (inbound) <%= info_tip("INBOUND rule: which columns may drag cards INTO this one. It does not control where this column's cards may go — set that on the destination columns. Leave all unchecked to accept from anywhere. Example: check only Planning on In Progress so work can't skip triage.") %></label>
+            <label>Accepts moves from (inbound) <%= info_tip("INBOUND rule: which columns may drag cards INTO this one. EXPLICIT ONLY — nothing checked means nothing may enter (there is no accept-from-anywhere). It does not control where this column's cards may go; set that on the destinations.") %></label>
             <div class="accepts-from">
               <% siblings.each do |sib| %>
                 <label class="check-row inline">
@@ -47,7 +54,18 @@
 
           <%# The Tasks/inbox column is the board's intake — cards park here untouched,
               so none of the AI-work or on-entry settings below apply to it (card #17). %>
-          <% unless @column.inbox? %>
+          <% if @column.inbox? %>
+            <p class="default-rule">This column never uses AI — it's the board's intake.</p>
+          <% else %>
+          <div data-controller="reveal">
+            <label class="check-row">
+              <%= hidden_field_tag "column[ai]", "0", id: nil %>
+              <%= check_box_tag "column[ai]", "1", @column.ai?, data: { reveal_target: "toggle", action: "change->reveal#sync" } %>
+              🤖 Use AI in this column — <%= @column.ai_mode_description %>
+              <%= info_tip("Off = this column is fully inert AI-wise: no assistant, no worker agents, no AI rules. Cards here are human work (a card dragged into a non-AI work column reads as being worked by a person). Non-AI on-entry rules like merge_pr still run.") %>
+            </label>
+
+            <div data-reveal-target="panel">
             <label>Instructions <%= info_tip("Extra guidance given to any AI servicing cards in this column — added ON TOP of the built-in role shown below (which is enforced in code and can't be edited away).") %></label>
             <% if @column.built_in_role %>
               <p class="default-rule">Built-in role: <%= @column.built_in_role %></p>
@@ -87,13 +105,16 @@
               <%= info_tip("The agent's first pass is read-only: it explores and proposes a plan, then waits. You approve with one click or reply to redirect. Your main safety rail.") %>
             </label>
 
+            </div>
+
             <label>On-entry rules <%= info_tip("What happens when a card lands in this column, in plain English — e.g. \"start the worker agent\" or \"have an AI suggest tags and a better title\". Cardinal compiles it to rule actions when you save. Blank = the archetype's default behavior shown below.") %></label>
-            <% if @column.policy["on_entry_text"].blank? && @column.policy["on_entry"].blank? %>
-              <p class="default-rule">Default: <%= Rules::DEFAULT_DESCRIPTIONS[@column.archetype] %></p>
+            <p class="default-rule">Archetype template: <%= Rules::DEFAULT_DESCRIPTIONS[@column.archetype] %></p>
+            <% if @column.policy["on_entry"].present? %>
+              <p class="default-rule active-rule">Currently active: <%= Rules.describe(@column.policy["on_entry"]) %><%= " — from your English rules below" if @column.policy["on_entry_text"].present? %></p>
             <% end %>
             <%= f.text_area :on_entry_text, rows: 3,
                   value: @column.policy["on_entry_text"],
-                  placeholder: "Describe what should happen instead of the default…" %>
+                  placeholder: "Describe what should happen when a card arrives — replaces the active behavior shown above. Blank = archetype default." %>
 
             <details class="advanced-rules">
               <summary>Advanced: compiled rules (JSON)</summary>
@@ -102,9 +123,13 @@
                     value: @column.policy["on_entry"] ? JSON.pretty_generate(@column.policy["on_entry"]) : "",
                     placeholder: '[{"action": "ai_task", "prompt": "Suggest tags for: %{title}"}]' %>
             </details>
+          </div>
           <% end %>
 
-          <%= f.submit "Save" %>
+          <label>Footer <%= info_tip("A summary strip under the cards. One row per line as \"Label | compute\", where compute is sum_cost (total run cost), sum_tokens (total input+output tokens), count_cards, or blank for a static label. Example: \"Total cost: | sum_cost\".") %></label>
+          <%= f.text_area :footer_text, rows: 3, class: "mono",
+                value: footer_config_text(@column),
+                placeholder: "Total cost: | sum_cost" %>
         <% end %>
 
         <details class="advanced-rules panel-advanced">

data/cardinal.md

@@ -591,6 +591,15 @@ admin surface.
   (5) review surface = in-card final report + file-level diff summary, deep link to the
   GitHub PR for line-level review. Scaffolding started: Rails 8 + Ruby 3.4 (Fullstaq) +
   Postgres 15 inside the cage container, repo at github.com/palamedes/cardinal.
+- **2026-07-03 (de-magic pass)** — **Archetypes are templates, not magic.** Choosing an
+  archetype stamps concrete on-entry rules, rule text, and starter instructions into the
+  column's policy at creation (and re-stamps them when the archetype is switched in the
+  gear modal); there is no hidden runtime fallback — a blank on-entry box means nothing
+  happens, visibly. **Accept rails are explicit-only:** "Accepts moves from" is a
+  whitelist and an empty list means the column accepts from nowhere; there is no
+  permissive blank default. Default board: Done also accepts from Planning — dragging
+  planning→Done means "closed/terminated without work" (merge_pr on a card with no PR
+  just finalizes it).
 
 ---
 

data/config/routes.rb

@@ -1,7 +1,10 @@
 Rails.application.routes.draw do
   root "boards#show"
 
-  resource :board, only: :show
+  resource :board, only: :show do
+    post :deep_dive
+    post :pull
+  end
   resources :cards, only: [:new, :create, :show, :update, :destroy] do
     member do
       patch :move

data/db/migrate/20260704120000_add_repo_brief_to_boards.rb

@@ -0,0 +1,8 @@
+class AddRepoBriefToBoards < ActiveRecord::Migration[8.1]
+  def change
+    add_column :boards, :brief_sha, :string
+    add_column :boards, :brief_generated_at, :datetime
+    add_column :boards, :brief_model, :string
+    add_column :boards, :brief_status, :string
+  end
+end

data/db/seeds.rb

@@ -8,12 +8,6 @@ board = Board.find_or_create_by!(name: "Cardinal") do |b|
   b.local_path = Rails.root.to_s
 end
 
-Board::DEFAULT_COLUMNS.each_with_index do |attrs, index|
-  board.columns.find_or_create_by!(name: attrs[:name]) do |c|
-    c.position = index
-    c.archetype = attrs[:archetype]
-    c.policy = attrs[:policy]
-  end
-end
+board.install_default_columns! if board.columns.none?
 
 puts "Seeded board '#{board.name}' with #{board.columns.count} columns."

data/lib/cardinal/version.rb

@@ -1,3 +1,3 @@
 module Cardinal
-  VERSION = "0.2.3"
+  VERSION = "0.2.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cardinal-ai
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Jason Ellis
@@ -149,6 +149,7 @@ files:
 - app/javascript/controllers/composer_controller.js
 - app/javascript/controllers/index.js
 - app/javascript/controllers/modal_controller.js
+- app/javascript/controllers/reveal_controller.js
 - app/javascript/controllers/scroll_controller.js
 - app/javascript/controllers/tags_controller.js
 - app/javascript/controllers/theme_controller.js
@@ -156,6 +157,7 @@ files:
 - app/jobs/ai_task_job.rb
 - app/jobs/application_job.rb
 - app/jobs/assistant_reply_job.rb
+- app/jobs/deep_dive_job.rb
 - app/jobs/mark_pr_ready_job.rb
 - app/jobs/merge_pr_job.rb
 - app/jobs/resume_run_job.rb
@@ -221,6 +223,7 @@ files:
 - db/migrate/20260703000002_add_agent_runner_fields.rb
 - db/migrate/20260704000001_add_parent_to_cards.rb
 - db/migrate/20260704000002_add_assistant_session_to_cards.rb
+- db/migrate/20260704120000_add_repo_brief_to_boards.rb
 - db/seeds.rb
 - docker/agent/Dockerfile
 - exe/cardinal