cardinal-ai 0.2.13 → 0.2.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d68fd5849d2147217f98894631cb725af6c4dd786bf4e2c5438f374101f0e34
-  data.tar.gz: 905b5c3af9bd9fdad3aa2c5f19b69968b495ff2e2788a9ca04567c0e2be15e6a
+  metadata.gz: 84bab289a5a9655c54a7e2cbd4587c21275a122903d08892f264c20fc2c0a52d
+  data.tar.gz: fdf187aa387793ddb12e7e5ccb6d9cb649a3214d894859490217be45585d690b
 SHA512:
-  metadata.gz: 184cbda0e27ce7e49f5b921e39b8e532a77ec27e80105f186161f2d01197ad36a5da1fdf549c2636f31b09b318459dcd9f3b19f4a74ffadd17834c54fbeb04f2
-  data.tar.gz: 82e3aeb820bbb9252304147f37fd57bb50cb65d40e3ae709b7a9c8b911bb5b51930a19233a528eda0caec09e86181c4d95391349bf70f03bac8791aefa320ce4
+  metadata.gz: b128883b680056de0b221bba6df4d8db8c8ea299ef93feec45c30cf3c7df238982b983cc6ffb50db17ed52c7781d71ee2442c4091c1fd1c922e03209ca2af7ea
+  data.tar.gz: de0ae6c696aa5b3fa490f5f985a9acf81bf45d468660ff47522ec835c9871061b039eee9f5d872570667d8c109dd1b08ca2b71fe861cbea7a775f2ccef70d61e

data/app/assets/stylesheets/cardinal.css

@@ -108,6 +108,50 @@ a { color: var(--blue); text-decoration: none; }
 .col-search.open { display: block; }
 .filter-hidden { display: none !important; }
 
+.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; }
+
+.note-toggle { display: block; font-size: 11px; color: var(--text-dim); margin-top: 4px; cursor: pointer; }
+.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; }
+
 .pull-form { display: inline; }
 #repo-pull-status { font-size: 0.85rem; }
 #repo-pull-status .pull-ok  { color: var(--green); }
@@ -406,15 +450,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); }
 
@@ -472,6 +521,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/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/ai_task_job.rb

@@ -17,7 +17,8 @@ class AiTaskJob < ApplicationJob
     text = ClaudeCli.prompt(
       prompt,
       system: "You are a maintenance agent on a Cardinal board performing one bounded task on card ##{card.number}. Be concise; your output is posted directly to the card's timeline.",
-      model: model.presence || AssistantReplyJob::FALLBACK_MODEL
+      model: model.presence || AssistantReplyJob::FALLBACK_MODEL,
+      ledger: { kind: "ai_task", card: card }
     )
     card.log!("assistant_message", actor: "assistant", text: text) if text.present?
   rescue ClaudeCli::Error => e

data/app/jobs/assistant_reply_job.rb

@@ -57,6 +57,7 @@ class AssistantReplyJob < ApplicationJob
         # affirming reply ("yes, that approach") must not escalate the
         # planner into implementing.
         return ClaudeCli.prompt(unheard_messages(card), resume: card.assistant_session_id,
+                                 ledger: { kind: "assistant", card: card },
                                 system: ROLE_REMINDER, **common)
       rescue ClaudeCli::Error
         card.update!(assistant_session_id: nil) # stale/expired — start fresh below
@@ -64,7 +65,7 @@ class AssistantReplyJob < ApplicationJob
     end
 
     opener = kickoff ? kickoff_prompt(card) : transcript_prompt(card)
-    ClaudeCli.prompt(opener, system: system_prompt(card), **common)
+    ClaudeCli.prompt(opener, system: system_prompt(card), ledger: { kind: "assistant", card: card }, **common)
   end
 
   def kickoff_prompt(card)

data/app/jobs/compact_job.rb

@@ -22,13 +22,19 @@ 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)
     return clear_working(card) unless ClaudeCli.available?
 
     model = card.board.columns.find_by(archetype: "planning")&.model.presence || FALLBACK_MODEL
-    compact = ClaudeCli.prompt(build_prompt(card), system: SYSTEM, model: model, max_turns: 1)
+    compact = ClaudeCli.prompt(build_prompt(card), system: SYSTEM, model: model, max_turns: 1,
+                               ledger: { kind: "compact", card: card })
 
     card.update!(compact: compact.to_s.strip, compact_generated_at: Time.current, compact_status: nil)
     card.broadcast_replace_to card, target: "card_compact",
@@ -69,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/deep_dive_job.rb

@@ -44,7 +44,8 @@ class DeepDiveJob < ApplicationJob
     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)
+    brief = ClaudeCli.prompt(PROMPT, model:, tools: "Read,Glob,Grep", cwd: repo, max_turns: MAX_TURNS,
+                             ledger: { kind: "deep_dive" })
 
     File.write(board.brief_path, brief.to_s)
     board.update!(brief_sha: sha, brief_generated_at: Time.current,

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,13 +16,18 @@ 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)
     return clear_working(card) unless ClaudeCli.available?
 
     model = card.board.columns.find_by(archetype: "planning")&.model.presence || FALLBACK_MODEL
-    summary = ClaudeCli.prompt(build_prompt(card), system: SYSTEM, model: model, max_turns: 1)
+    summary = ClaudeCli.prompt(build_prompt(card), system: SYSTEM, model: model, max_turns: 1,
+                               ledger: { kind: "summary", card: card })
 
     card.update!(summary: summary.to_s.strip, summary_generated_at: Time.current, summary_status: nil)
     card.broadcast_replace_to card, target: "card_summary",
@@ -60,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/ai_call.rb

@@ -0,0 +1,10 @@
+# One row per one-shot AI call (§ money honesty): what it was for, what it
+# cost. Worker runs keep their usage on Run; everything that goes through
+# ClaudeCli lands here — including board-level calls with no card (deep dive).
+class AiCall < ApplicationRecord
+  KINDS = %w[assistant ai_task deep_dive summary compact rules_compile].freeze
+
+  belongs_to :card, optional: true
+
+  validates :kind, inclusion: { in: KINDS }
+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

@@ -23,6 +23,7 @@ class Card < ApplicationRecord
                       dependent: :nullify, inverse_of: :parent
   has_many :events, -> { order(:created_at, :id) }, dependent: :destroy
   has_many :agent_sessions, dependent: :destroy
+  has_many :ai_calls, dependent: :delete_all
   has_many :runs, through: :agent_sessions
 
   # Card-face status glyphs. Keyed on status, except `ready_for_approval?`
@@ -47,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)
 
@@ -101,17 +111,31 @@ class Card < ApplicationRecord
 
   # Running tally across every run on the card — the closed-card cost footer
   # (card #20). Sums stopped/restarted segments so the total reflects real spend.
-  def total_cost = runs.sum(:cost)
-  def total_output_tokens = runs.sum(:output_tokens)
+  # Honest money: worker runs PLUS every one-shot call made on this card's
+  # behalf (planning assistant, ai_task, summary/compact) — see AiCall.
+  def total_cost = runs.sum(:cost) + ai_calls.sum(:cost)
+  def total_output_tokens = runs.sum(:output_tokens) + ai_calls.sum(:output_tokens)
+
+  def assistant_cost = ai_calls.where(kind: "assistant").sum(:cost)
 
   # 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? && 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?