cardinal-ai 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: decfcea83bc4294b6cf14e947fa1586dee954dfaa30250b67df7d1c29377c191
-  data.tar.gz: f6718005edcdeda0d1608d13d93211c7785af98ca2297ef418d96457724c6d1d
+  metadata.gz: 9765ce8a3b88ca8a2d72dcdaa766d67d42b0b1f1304ce44551fb0b31a8b62f84
+  data.tar.gz: 6bbd3904403e6e91b83a684d134c15ad402a98ab27f4600d6424752033565b0b
 SHA512:
-  metadata.gz: 7c106ef6387b43103682e495071e3dfa1d04701eea84c2192f9c67c132ae623a5fa9614294e7e59606e0fad300cf9147008013906d6d9981799e4e3ea0740c89
-  data.tar.gz: 1e2b72553d1bd2c6fd678bd7a3bd8c49c5ec6acc902026546d51d7e0fa9fe783803285e4f2933319f52f1193f1850cf3dc516fb6439b402ef97daa78393f96e3
+  metadata.gz: b91c51d2d12d2df7d7d1f81b7d8547545ed68cac112f4d844dd4666626ccb34081397dc038fa4620a8b0e76e804b18c64608d96c92be657238958bf4bf3540ff
+  data.tar.gz: 1e71c84583f3c6f02b3315ce7fa4abce078117dcb47ceb13a15a1641c3a90651673db22015c63ab8c1ca2e0683c136b50ac278b695e7144d34d7f7d2bf8378fc

data/app/assets/stylesheets/cardinal.css

@@ -509,6 +509,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/columns_controller.rb

@@ -25,7 +25,7 @@ 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,
+      :on_entry_text, :on_entry_json, :color, :custom_color, :arrivals, :ai,
       accepts_from: []
     )
 
@@ -37,41 +37,76 @@ 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
 
     @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

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/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/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
 

data/app/models/card.rb

@@ -46,7 +46,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,6 +6,31 @@ 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,
@@ -17,18 +42,27 @@ class Column < ApplicationRecord
     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
 
   # 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
@@ -70,6 +104,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 +128,7 @@ 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
 end

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/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? %>

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,8 @@
                     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" %>
         <% 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/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.4"
 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.4
 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