cardinal-ai 0.2.14 → 0.2.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b30a673a110becb4019a1d537443a14ec37ebeb326c29ff310c41edd3dc59dee
-  data.tar.gz: ca0b8933f66d185cf62b30e9b32fc6b9e6217045654bc2dc61f884be82ff212c
+  metadata.gz: aaa2760a909ef2ee8cef012432e1a15311d1d3db2b1f37a5f2374e4322fc0c92
+  data.tar.gz: 6f995d0029b94d19dbb7f26fccf1dd01014ceab5973a766a91ef72aec043335d
 SHA512:
-  metadata.gz: 585edbeff0fc41cef7ad16fcb76bb61c5bd041fc44a51f0ce3ca71d7dfcfa22144951638f0f9c3f400821fda0a5ffb84eaff2bde32d2e29ecf7448783c689672
-  data.tar.gz: d00bca1a2862b301a4204545ff0d79dfd14855f36a8a45e538e595a7eb7e1e81983e6aeeda3c0806fce789d7fea69f0fbb2690b8ef6e97e59dfc6774dd20036d
+  metadata.gz: 58d4a91169f2b8ab305e86b49d4d839cb16b275904d672525352258845af6ab70b6c47777d6a9b56dfc45b1db583b19fbb5e7bcce3d63cd8ec578e2d5a1e06ae
+  data.tar.gz: bd8de891a41f0a7841d371d342173639b7548988b8c25377804207971da1735f6e9ea9b2a8e6e17a736a6487d0d394b0160a5aa18ce60638e51b78b1bce5c693

data/app/assets/stylesheets/cardinal.css

@@ -110,6 +110,64 @@ a { color: var(--blue); text-decoration: none; }
 
 .assistant-spend { margin-left: auto; font-size: 11px; color: var(--text-dim); cursor: default; }
 
+/* Quick-add (card #42) */
+.quick-add input[type="text"] {
+  width: 100%; margin: 0 0 8px; font-size: 12px;
+  background: var(--surface-2); border: 1px dashed var(--border); border-radius: 6px;
+  color: var(--text); padding: 5px 8px;
+}
+.quick-add input[type="text"]:focus { border-style: solid; }
+
+/* Archive browser (card #42) */
+.archive-page { padding: 18px; max-width: 900px; margin: 0 auto; }
+.archive-tools { display: flex; align-items: center; gap: 12px; margin-bottom: 14px; }
+.archive-list { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 8px; }
+.archive-row { display: flex; align-items: center; justify-content: space-between; gap: 12px; cursor: default; }
+.archive-title { font-weight: 600; }
+.archive-meta { display: block; font-size: 11px; color: var(--text-dim); margin-top: 3px; }
+.restore-btn { white-space: nowrap; }
+
+.composer-box { flex: 1; display: flex; flex-direction: column; gap: 3px; }
+.composer-box textarea { width: 100%; }
+.note-toggle {
+  font-size: 11px; color: var(--text-dim); cursor: pointer; align-self: flex-start;
+  display: inline-flex; align-items: center; gap: 4px;
+}
+.note-toggle input[type="checkbox"] { margin: 0; }
+.note-toggle input { accent-color: var(--amber); }
+.note-flag { font-size: 10px; color: var(--amber); border: 1px solid var(--amber); border-radius: 8px; padding: 0 6px; margin-right: 4px; }
+
+.issue-list { list-style: none; margin: 0; padding: 0; }
+.issue-row { display: flex; align-items: center; justify-content: space-between; gap: 10px;
+             padding: 8px 4px; border-bottom: 1px solid var(--border); }
+.issue-row:last-child { border-bottom: 0; }
+
+.ready-chip { color: var(--green); border-color: var(--green); }
+
+/* 🗄 as a drag target: lit while a drag from an allowed column is live. */
+.archive-drop { display: inline-flex; border-radius: 6px; }
+.archive-drop.drop-ready .archive-link {
+  color: var(--amber); border-color: var(--amber);
+  animation: pulse-dot 1.2s ease-in-out infinite;
+}
+.archive-drop .card, .archive-drop .card-ghost { display: none !important; }
+
+.archive-rails { margin: 0 0 16px; padding: 10px 12px; background: var(--surface);
+                 border: 1px solid var(--border); border-radius: 8px; font-size: 12px; }
+.archive-rails .rails-label { font-weight: 600; margin-right: 10px; }
+.archive-rails .inline-check { display: inline-flex; align-items: center; gap: 4px; margin-right: 12px; cursor: pointer; }
+.archive-rails .hint { display: block; margin-top: 6px; }
+
+.asana-entry {
+  margin-right: auto; display: inline-flex; align-items: center;
+  background: transparent; color: var(--text-dim); border: 1px solid var(--border);
+  border-radius: 6px; padding: 6px 12px; font-weight: 600; font-size: inherit;
+}
+.asana-entry:hover { color: var(--text); border-color: var(--text-dim); }
+.asana-steps { font-size: 13px; margin: 8px 0 14px; padding-left: 20px; }
+.asana-steps li { margin: 4px 0; }
+.asana-connected { color: var(--green); }
+
 .pull-form { display: inline; }
 #repo-pull-status { font-size: 0.85rem; }
 #repo-pull-status .pull-ok  { color: var(--green); }
@@ -408,15 +466,20 @@ body.dragging .drop-hint { display: block; }
 .zoom-tabs a { padding: 4px 12px; border-radius: 6px; color: var(--text-dim); }
 .zoom-tabs a.active { background: var(--surface-2); color: var(--text); }
 
+/* Summary/Compact panels fill the pane: header + blurb on top, the textarea
+   flexes to all remaining height, the last-generated stamp holds the floor. */
+.summary-panel { display: flex; flex-direction: column; height: 100%; }
 .summary-panel .summary-head { display: flex; align-items: center; justify-content: space-between; gap: 10px; }
 .summary-panel .summary-head h3 { margin: 0; }
 .summary-generate { white-space: nowrap; }
-.summary-blurb { margin: 6px 0 12px; }
+.summary-blurb { margin: 6px 0 12px; flex-shrink: 0; }
+.summary-form { flex: 1; min-height: 0; display: flex; }
 .summary-form textarea {
-  width: 100%; background: var(--surface-2); border: 1px solid var(--border);
-  border-radius: 6px; color: var(--text); padding: 8px 10px; font: inherit; resize: vertical;
+  width: 100%; height: 100%; flex: 1; background: var(--surface-2); border: 1px solid var(--border);
+  border-radius: 6px; color: var(--text); padding: 8px 10px; font: inherit; resize: none;
 }
-.summary-stamp { margin-top: 8px; }
+.summary-head-right { display: flex; align-items: center; gap: 10px; }
+.summary-stamp { font-size: 11px; color: var(--text-dim); white-space: nowrap; }
 
 .event { display: flex; gap: 10px; padding: 8px 4px; border-bottom: 1px solid var(--surface-2); }
 
@@ -474,6 +537,22 @@ body.dragging .drop-hint { display: block; }
 .actor-agent .event-body p { color: #b9c3d8; }
 [data-theme="light"] .actor-agent .event-body p { color: #3a4a63; }
 
+/* Pasted attachments (card #21): image thumbnails and file badges, inline in
+   descriptions and timeline messages. */
+.attachment { margin: 6px 0; }
+.attachment-image { display: inline-block; margin: 6px 8px 6px 0; }
+.attachment-thumb {
+  display: block; max-width: 120px; max-height: 120px; width: auto; height: auto;
+  border: 1px solid var(--border); border-radius: 6px; background: var(--surface-2);
+}
+.attachment-image figcaption { font-size: 11px; color: var(--text-dim); margin-top: 3px; }
+.attachment-file {
+  display: inline-flex; align-items: center; gap: 6px; padding: 4px 8px;
+  background: var(--surface-2); border: 1px solid var(--border); border-radius: 6px;
+  font-size: 12px; color: var(--text-dim);
+}
+.attachment-icon { font-size: 14px; }
+
 .empty { color: var(--text-dim); font-style: italic; }
 
 /* AI typing indicator */

data/app/controllers/asana_controller.rb

@@ -0,0 +1,31 @@
+# Asana import (card #7). First visit is a connect wizard (PAT walkthrough);
+# once connected it's a one-field modal: paste the task URL, get a card.
+class AsanaController < ApplicationController
+  def new_card
+    @board = Board.first!
+    redirect_to root_path and return unless turbo_frame_request?
+    @connected = Asana.connected?
+    @error = params[:error]
+    @just_connected = params[:connected]
+  end
+
+  def connect
+    name = Asana.verify!(params.require(:token))
+    Asana.save_token!(params[:token])
+    redirect_to asana_new_card_path(connected: name)
+  rescue Asana::Error => e
+    redirect_to asana_new_card_path(error: e.message)
+  end
+
+  def import
+    card = Asana.import!(Board.first!, params.require(:url))
+    redirect_to card_path(card)
+  rescue Asana::Error => e
+    redirect_to asana_new_card_path(error: e.message)
+  end
+
+  def disconnect
+    Asana.disconnect!
+    redirect_to asana_new_card_path
+  end
+end

data/app/controllers/boards_controller.rb

@@ -29,7 +29,8 @@ class BoardsController < ApplicationController
 
   def update
     board = Board.first!
-    attrs = params.require(:board).permit(:name, :default_branch)
+    attrs = params.require(:board).permit(:name, :default_branch, archive_accepts_from: [])
+    board.archive_accepts_from = attrs[:archive_accepts_from].to_a.map(&:to_s).reject(&:blank?) if attrs.key?(:archive_accepts_from)
     board.update!(
       name: attrs[:name].presence || board.name,
       default_branch: attrs[:default_branch].presence || board.default_branch
@@ -45,6 +46,29 @@ class BoardsController < ApplicationController
     end
   end
 
+  # GitHub Issues sync (card #49): list open issues, one click imports one as
+  # an inbox card; the card's eventual PR carries "Closes #N".
+  def issues
+    @board = Board.first!
+    redirect_to root_path and return unless turbo_frame_request?
+    @issues = GithubIssues.available?(@board) ? GithubIssues.list(@board) : []
+    @imported = @board.cards.where.not(issue_number: nil).pluck(:issue_number, :number).to_h
+  end
+
+  def import_issue
+    board = Board.first!
+    card = GithubIssues.import!(board, params.require(:number))
+    redirect_to card_path(card)
+  rescue ArgumentError => e
+    redirect_to root_path, alert: e.message
+  end
+
+  # The archive browser (card #42): everything archived, searchable, restorable.
+  def archive
+    @board = Board.first!
+    @cards = @board.cards.archived.includes(:column).order(updated_at: :desc)
+  end
+
   # Inspect the repo brief: what the deep dive wrote, when, from which SHA.
   def brief
     @board = Board.first!

data/app/controllers/cards_controller.rb

@@ -1,5 +1,5 @@
 class CardsController < ApplicationController
-  before_action :set_card, only: [:show, :update, :move, :approve, :summarize, :compact, :destroy]
+  before_action :set_card, only: [:show, :update, :move, :approve, :summarize, :compact, :destroy, :archive, :unarchive]
 
   def new
     @board = Board.first!
@@ -140,6 +140,26 @@ class CardsController < ApplicationController
     end
   end
 
+  # Archive (card #42): off the board, never gone — /board/archive lists,
+  # searches, and restores. Running cards can't be archived out from under
+  # their agent.
+  def archive
+    if @card.running?
+      redirect_to card_path(@card), alert: "Card is running — cancel or finish the run first."
+    else
+      @card.update!(status: "archived")
+      @card.log!("status_change", actor: "user", text: "Archived")
+      redirect_to root_path
+    end
+  end
+
+  def unarchive
+    restore = Card::ARCHIVE_RESTORE.fetch(@card.column.archetype, "draft")
+    @card.update!(status: restore, position: (@card.column.cards.active.maximum(:position) || -1) + 1)
+    @card.log!("status_change", actor: "user", text: "Restored from the archive to #{@card.column.name} (#{restore.humanize.downcase})")
+    redirect_to archive_board_path
+  end
+
   private
 
   def set_card

data/app/controllers/messages_controller.rb

@@ -3,12 +3,27 @@ class MessagesController < ApplicationController
     card = Board.first!.cards.find_by!(number: params[:card_id])
     text = params.require(:message)[:text]
     parked_run = card.runs.where(status: "needs_input").order(:id).last
+    live_run = card.runs.where(status: "running").order(:id).last
 
-    if parked_run
+    if params.dig(:message, :note) == "1"
+      # Note only (card #47): on the record for any FUTURE reader — the next
+      # column's assistant or worker sees it in conversation context — but no
+      # AI is invoked now and no verdict changes. Type, drag, done.
+      card.log!("user_message", actor: "user", text: text, note: true)
+    elsif parked_run
       # Answer / plan feedback: goes back into the same agent session.
       kind = parked_run.phase == "plan" ? "user_message" : "answer"
       card.log!(kind, actor: "user", run: parked_run, text: text)
       ResumeRunJob.perform_later(parked_run.id, text)
+    elsif card.column.execution? && card.working? && live_run
+      # Mid-run steering (card #47): the run is streaming and can't hear you
+      # yet — queue the note on the run; it delivers at the next segment
+      # boundary (question, plan approval, budget pause) via ResumeRunJob.
+      notes = Array(live_run.briefing["steering"]) << text
+      live_run.update!(briefing: live_run.briefing.merge("steering" => notes))
+      card.log!("user_message", actor: "user", run: live_run, text: text)
+      card.log!("status_change", run: live_run,
+                text: "🧭 Note queued for the agent — delivers at its next check-in")
     elsif card.column.review? && %w[in_review approved].include?(card.status)
       # Review is entirely human: feedback IS the conversation. A message on a
       # card under review marks it changes_requested; dragging it back to a

data/app/helpers/application_helper.rb

@@ -36,6 +36,60 @@ module ApplicationHelper
     MARKDOWN.render(text.to_s).html_safe
   end
 
+  # Pasted files live inline in message/description text as attachment tokens
+  # (card #21). Format, kept in sync with attach_controller.js:
+  #   [[cardinal:file name="foo.png" mime="image/png" size="12345"]]<base64>[[/cardinal:file]]
+  # The regex is anchored on delimiters base64 can never contain ([, ], ").
+  ATTACHMENT_TOKEN =
+    /\[\[cardinal:file name="([^"]*)" mime="([^"]*)" size="(\d+)"\]\]([A-Za-z0-9+\/=\s]*?)\[\[\/cardinal:file\]\]/
+
+  # Only these render as an inline <img> off a data: URL. Anything else — including
+  # a spoofed mime like text/html — falls through to an inert badge, never an image.
+  ATTACHMENT_IMAGE_MIMES = %w[image/png image/jpeg image/gif image/webp].freeze
+
+  # Render text that may carry attachment tokens: markdown for the prose, a
+  # thumbnail (images) or a badge (everything else) for each attachment. Tokens
+  # are pulled out BEFORE markdown so the raw base64 never floods the timeline and
+  # a token can never be interpreted as HTML.
+  def render_with_attachments(text)
+    text = text.to_s
+    return render_markdown(text) unless text.match?(ATTACHMENT_TOKEN)
+
+    html = +""
+    last = 0
+    text.scan(ATTACHMENT_TOKEN) do
+      match = Regexp.last_match
+      html << render_markdown(text[last...match.begin(0)])
+      html << render_attachment(match[1], match[2], match[3].to_i, match[4].gsub(/\s+/, ""))
+      last = match.end(0)
+    end
+    html << render_markdown(text[last..])
+    html.html_safe
+  end
+
+  # One attachment's HTML. All interpolated values are escaped; the base64 is
+  # only ever used as an <img> data: URL for a whitelisted image mime.
+  def render_attachment(name, mime, size, base64)
+    caption = "#{name} · #{number_to_human_size(size)}"
+    if ATTACHMENT_IMAGE_MIMES.include?(mime) && base64.present?
+      tag.figure(class: "attachment attachment-image") do
+        image_tag("data:#{mime};base64,#{base64}", alt: name, class: "attachment-thumb") +
+          tag.figcaption(caption)
+      end
+    else
+      tag.span(class: "attachment attachment-file", title: caption) do
+        tag.span("📄", class: "attachment-icon") + tag.span(caption, class: "attachment-name")
+      end
+    end
+  end
+
+  # Strip attachment tokens down to just their filename for plain-text contexts
+  # like the card-face search haystack — a pasted image must not turn a card's
+  # searchable text into base64 noise (card #21).
+  def strip_attachment_tokens(text)
+    text.to_s.gsub(ATTACHMENT_TOKEN) { Regexp.last_match(1) }
+  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)

data/app/javascript/controllers/archive_drop_controller.js

@@ -0,0 +1,41 @@
+import { Controller } from "@hotwired/stimulus"
+import Sortable from "sortablejs"
+
+// The topbar 🗄 as a drop bin: cards dragged from whitelisted columns
+// (board.archive_accepts_from, set on the archive page) can be dropped here
+// to archive in one motion. The link inside keeps its normal click.
+export default class extends Controller {
+  connect() {
+    this.sortable = Sortable.create(this.element, {
+      group: {
+        name: "cards",
+        pull: false,
+        put: (_to, from) => this.accepts(from.el.dataset.columnId)
+      },
+      onAdd: (event) => this.archive(event)
+    })
+  }
+
+  disconnect() {
+    this.sortable?.destroy()
+  }
+
+  accepts(columnId) {
+    const allowed = (this.element.dataset.accepts || "").split(",").filter(Boolean)
+    return allowed.includes(columnId)
+  }
+
+  async archive(event) {
+    const number = event.item.dataset.cardId
+    // Drop the dragged face immediately; the server's refresh broadcast is
+    // the durable truth (board re-renders active cards + the 🗄 count).
+    event.item.remove()
+    await fetch(`/cards/${number}/archive`, {
+      method: "POST",
+      headers: {
+        "X-CSRF-Token": document.querySelector("meta[name='csrf-token']").content,
+        "Accept": "text/html"
+      }
+    })
+  }
+}

data/app/javascript/controllers/attach_controller.js

@@ -0,0 +1,80 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Paste files (images + text/code) into a textarea as base64 attachment tokens.
+// The token stays inline in the field text — that is how the agent, the timeline
+// renderer, and autosave all see it. Format (kept in sync with ApplicationHelper):
+//   [[cardinal:file name="foo.png" mime="image/png" size="12345"]]<base64>[[/cardinal:file]]
+export default class extends Controller {
+  static values = {
+    // Hard ceiling and the point where a paste is worth warning about (bytes).
+    max: { type: Number, default: 500 * 1024 },
+    warn: { type: Number, default: 250 * 1024 }
+  }
+
+  paste(event) {
+    const files = Array.from(event.clipboardData?.items || [])
+      .filter((item) => item.kind === "file")
+      .map((item) => item.getAsFile())
+      .filter(Boolean)
+
+    // No files on the clipboard — let the browser paste text as usual.
+    if (files.length === 0) return
+
+    event.preventDefault()
+    files.forEach((file) => this.attach(file))
+  }
+
+  attach(file) {
+    if (file.size > this.maxValue) {
+      this.notify(`"${file.name}" is ${this.kb(file.size)}KB — over the ${this.kb(this.maxValue)}KB limit. Not attached.`)
+      return
+    }
+    if (file.size >= this.warnValue) {
+      const proceed = window.confirm(
+        `"${file.name}" is ${this.kb(file.size)}KB. Pasting it embeds the full file in this card, ` +
+        `and every agent run and planning reply re-sends it as context — that consumes tokens and ` +
+        `increases run cost each time. Attach it anyway?`
+      )
+      if (!proceed) return
+    }
+
+    const reader = new FileReader()
+    reader.onload = () => {
+      // FileReader gives us a data: URL; the base64 payload is after the comma.
+      const base64 = String(reader.result).split(",", 2)[1] || ""
+      const mime = file.type || "application/octet-stream"
+      this.insert(this.token(file.name, mime, file.size, base64))
+    }
+    reader.readAsDataURL(file)
+  }
+
+  // Build one attachment token. The name is sanitized so quotes/brackets can
+  // never break the delimiter the renderer parses back out.
+  token(name, mime, size, base64) {
+    const safeName = String(name || "file").replace(/["\[\]]/g, "").trim() || "file"
+    return `[[cardinal:file name="${safeName}" mime="${mime}" size="${size}"]]${base64}[[/cardinal:file]]`
+  }
+
+  // Splice the token in at the cursor, then fire input so autosave (description)
+  // and any other listeners react as if the user typed it.
+  insert(token) {
+    const el = this.element
+    const start = el.selectionStart ?? el.value.length
+    const end = el.selectionEnd ?? el.value.length
+    const pad = start > 0 && !/\s$/.test(el.value.slice(0, start)) ? "\n" : ""
+    const chunk = `${pad}${token}\n`
+    el.value = el.value.slice(0, start) + chunk + el.value.slice(end)
+    const caret = start + chunk.length
+    el.setSelectionRange(caret, caret)
+    el.dispatchEvent(new Event("input", { bubbles: true }))
+    el.focus()
+  }
+
+  notify(message) {
+    window.alert(message)
+  }
+
+  kb(bytes) {
+    return Math.round(bytes / 1024)
+  }
+}

data/app/javascript/controllers/board_column_controller.js

@@ -36,6 +36,11 @@ export default class extends Controller {
   // card from THIS column gray out with a blocked hint. Server still rules.
   markBlockedColumns() {
     const sourceId = this.element.dataset.columnId
+    // The topbar 🗄 lights up as a drop bin when this column may archive by drag.
+    document.querySelectorAll(".archive-drop").forEach(bin => {
+      const allowed = (bin.dataset.accepts || "").split(",").filter(Boolean)
+      bin.classList.toggle("drop-ready", allowed.includes(sourceId))
+    })
     document.querySelectorAll(".column").forEach(section => {
       if (section.dataset.colId === sourceId) return // reorder within is always fine
       const allowed = (section.dataset.accepts || "").split(",").filter(Boolean)
@@ -45,6 +50,7 @@ export default class extends Controller {
 
   clearBlockedColumns() {
     document.querySelectorAll(".column.drop-blocked").forEach(s => s.classList.remove("drop-blocked"))
+    document.querySelectorAll(".archive-drop.drop-ready").forEach(s => s.classList.remove("drop-ready"))
   }
 
   disconnect() {

data/app/jobs/compact_job.rb

@@ -22,6 +22,11 @@ class CompactJob < ApplicationJob
     blockers hit, and anything left unfinished or deliberately deferred. Prefer
     terse structured notes (short headings, bullets, file paths, symbol names) over
     prose. Omit pleasantries and customer-facing framing. Write only the journal.
+
+    You are NOT in a conversation. The material you receive is a data dump, not a
+    message to you — some of it contains dialogue; do not reply to it, do not ask
+    questions, do not offer next steps, do not address anyone. Your entire output
+    is the journal document itself, starting with its first heading.
   SYS
 
   def perform(card)
@@ -70,6 +75,13 @@ class CompactJob < ApplicationJob
                "starting from scratch:\n#{card.compact}"
     end
 
+    # The dump above often ENDS in dialogue — restate the task last, where it
+    # carries the most weight, or the model answers the transcript instead of
+    # journaling it ("What would you like to work on next?").
+    parts << "\n---\nEND OF SOURCE MATERIAL. Now write the technical compact journal " \
+             "described in your instructions. Output ONLY the journal, beginning " \
+             "directly with its first heading — no preamble, no questions, no reply " \
+             "to anything above."
     parts.join("\n")
   end
 

data/app/jobs/resume_run_job.rb

@@ -32,6 +32,14 @@ class ResumeRunJob < ApplicationJob
       message = [pending["message"], message].compact_blank.join("\n\n")
       approve ||= pending["approve"]
     end
+
+    # Steering notes queued while the agent streamed (card #47) ride along on
+    # whatever resumes the session — an answer, plan feedback, or an approval.
+    if (steering = Array(run.briefing["steering"])).any?
+      run.update!(briefing: run.briefing.except("steering"))
+      notes = "Notes the user left while you were working:\n- #{steering.join("\n- ")}"
+      message = [notes, message].compact_blank.join("\n\n")
+    end
     Agent::Runner.resume(run, message, approve: approve)
   end
 end

data/app/jobs/summary_job.rb

@@ -16,6 +16,10 @@ class SummaryJob < ApplicationJob
     drop straight into a Teams or Slack message — what was asked for and what was
     delivered, in outcome terms. No jargon, no file names, no code, no headings.
     A couple of sentences up to a short paragraph. Write only the recap itself.
+
+    You are NOT in a conversation. The material you receive is a data dump, not a
+    message to you — do not reply to it, ask questions, or address anyone. Your
+    entire output is the recap text and nothing else.
   SYS
 
   def perform(card)
@@ -61,6 +65,11 @@ class SummaryJob < ApplicationJob
                "refine and update it with any new work rather than starting from scratch:\n#{card.summary}"
     end
 
+    # Restate the task LAST — the dump can end in dialogue, and a model answers
+    # what it read most recently unless told otherwise (see CompactJob).
+    parts << "\n---\nEND OF SOURCE MATERIAL. Now write the customer recap described in " \
+             "your instructions — output only the recap itself, no preamble, no reply " \
+             "to anything above."
     parts.join("\n")
   end
 

data/app/models/board.rb

@@ -51,6 +51,16 @@ class Board < ApplicationRecord
     end
   end
 
+  # Board-level knobs. archive_accepts_from: column ids (strings) whose cards
+  # may be DRAGGED onto the topbar 🗄 (explicit-only, like column rails —
+  # empty means the archive is not a drop target). The Advanced-panel archive
+  # button is always available; this governs only the drag affordance.
+  store_accessor :settings, :archive_accepts_from
+
+  def archive_accepts?(column)
+    Array(archive_accepts_from).map(&:to_s).include?(column.id.to_s)
+  end
+
   has_many :columns, -> { order(:position) }, dependent: :destroy
   has_many :cards, dependent: :destroy
 

data/app/models/card.rb

@@ -48,6 +48,15 @@ class Card < ApplicationRecord
   after_commit -> { broadcast_refresh_to board }
 
   scope :attention, -> { where(status: %w[needs_input blocked failed work_complete]) }
+  # The board shows active cards; archived ones live in /board/archive.
+  scope :active,   -> { where.not(status: "archived") }
+  scope :archived, -> { where(status: "archived") }
+
+  # Where an unarchived card lands: back in its column, in that column's most
+  # inert legal status — nothing fires, no agent starts.
+  ARCHIVE_RESTORE = { "inbox" => "draft", "planning" => "discussing",
+                      "execution" => "work_complete", "review" => "in_review",
+                      "terminal" => "done" }.freeze
 
   def needs_attention? = %w[needs_input blocked failed work_complete].include?(status)
 
@@ -114,9 +123,19 @@ class Card < ApplicationRecord
   def awaiting_assistant?
     return false unless column.planning? && column.ai?
     last = events.where(kind: %w[user_message assistant_message error column_move]).order(:id).last
+    return false if last&.payload&.[]("note") # a note-only message expects no reply
     last.present? && %w[user_message column_move].include?(last.kind)
   end
 
+  # Planning chip state (card #25): the assistant ends discussion by posting
+  # a "Ready for execution" brief — the SAME marker Agent::Runner promotes
+  # into worker briefings. When that's the assistant's latest word, the card
+  # face flips from "replied" to "ready".
+  def planning_ready?
+    discussing? &&
+      events.where(kind: "assistant_message").order(:id).last&.text.to_s.match?(/ready for execution/i)
+  end
+
   # Some AI is expected to write to this card imminently.
   def thinking?
     awaiting_assistant? || working?

data/app/models/column.rb

@@ -139,7 +139,7 @@ class Column < ApplicationRecord
       ActiveSupport::NumberHelper.number_to_delimited(
         column_runs.sum("input_tokens + output_tokens") + column_ai_calls.sum("input_tokens + output_tokens"))
     when "count_cards"
-      cards.count.to_s
+      cards.active.count.to_s
     when "model"
       # The column's active AI model, short form. Blank when AI is off or no
       # model is set — the row then shows just its label, telling the truth.
@@ -195,11 +195,11 @@ class Column < ApplicationRecord
 
   # 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 })
+    Run.joins(agent_session: :card).where(cards: { column_id: id }).where.not(cards: { status: "archived" })
   end
 
   # One-shot AI spend (assistant/ai_task/summary/…) of this column's cards.
   def column_ai_calls
-    AiCall.where(card_id: cards.select(:id))
+    AiCall.where(card_id: cards.active.select(:id))
   end
 end

data/app/services/agent/runner.rb

@@ -74,8 +74,12 @@ module Agent
       begin_segment!
       if run.phase == "plan" && approve
         run.update!(phase: "execute")
-        stream_agent(prompt: "Your plan is approved — execute it now.\n\n#{execute_rules}",
-                     mode: "execute", resuming: true)
+        # Approve-with-notes: an approval may carry final adjustments — fold
+        # them into the execute prompt instead of silently dropping them.
+        prompt = ["Your plan is approved — execute it now.",
+                  (message.present? ? "Notes from the user to fold in as you execute:\n\n#{message}" : nil),
+                  execute_rules].compact.join("\n\n")
+        stream_agent(prompt: prompt, mode: "execute", resuming: true)
       elsif run.phase == "plan"
         stream_agent(prompt: "Feedback on your plan:\n\n#{message}\n\nRevise the plan accordingly, present it, and stop again for approval. Stay in read-only mode.",
                      mode: "plan", resuming: true)
@@ -263,6 +267,10 @@ module Agent
         ensure_pull_request(workspace)
       end
 
+      if (undelivered = Array(run.briefing["steering"])).any?
+        card.log!("status_change", run: run,
+                  text: "#{undelivered.size} queued note(s) never reached the agent — the run finished before its next check-in. They stay in the conversation, so the next run will see them.")
+      end
       run.update!(status: "succeeded", finished_at: Time.current,
                   result_summary: report.presence&.truncate(2000))
       card.log!("final_report", actor: "agent", run: run,
@@ -331,13 +339,20 @@ module Agent
 
     def base_sha = run.briefing.fetch("base_sha")
 
+    # "Closes #N" makes GitHub close the source issue on merge (card #49).
+    def pr_body
+      [("Closes ##{card.issue_number}" if card.issue_number.present?),
+       "Automated work by Cardinal card ##{card.number}'s agent.",
+       card.description].compact.join("\n\n")
+    end
+
     def ensure_pull_request(workspace)
       return if card.pr_url.present?
       out, status = Open3.capture2e(
         "gh", "pr", "create", "--draft",
         "--head", card.branch_name,
         "--title", "##{card.number} #{card.title}",
-        "--body", "Automated work by Cardinal card ##{card.number}'s agent.\n\n#{card.description}",
+        "--body", pr_body,
         chdir: workspace.path.to_s
       )
       if status.success? && (url = out[%r{https://github\.com/\S+/pull/\d+}])