@volter/supercode-orchestrator 0.5.228 → 0.5.230

package/board/ztrack.mjs

@@ -1,4 +1,8 @@
+import { registerWorkOperations, measureWork } from "@volter/supercode-harness-sdk/work-ledger";
+registerWorkOperations([{"kind":"pass","operation":"board.transaction"}]);
+import { assertBoardRestingDocument } from './resting-admission.mjs';
 import { fillReadableIds, validateReadableId } from './readable-id.mjs';
+import { assertBacklogQualified, assertPauseRecord, restingReaderBound, restingSerializationOptions } from './resting-state.mjs';
 // The document is card state. One SQLite file beside it keeps the runtime tables the engine speaks
 // and an index of the document's card spans. ADR 0001 and 0003.
 // All markdown interpretation belongs to ztrack's public codec and kanban preset.
@@ -73,7 +77,7 @@ const timedStatement = (sql, fn) => {
   finally { noteStatement(sql, started, before); }
 };
 import { fire, workflowFor } from './workflow.mjs';
-import { byOwner, LIST_REVISION, listRevision, TASK_SUMMARY_INDEX, TASK_SUMMARY_INDEX_SQL } from './listing.mjs';
+import { byOwner, LIST_CONNECTION, LIST_REVISION, READ_BOUNDARY, listRevision, TASK_SUMMARY_INDEX, TASK_SUMMARY_INDEX_SQL } from './listing.mjs';
 
 const require = createRequire(import.meta.url);
 const hash = (text) => createHash('sha256').update(text).digest('hex');
@@ -144,7 +148,7 @@ export function openZtrackBoard(marker, { create = false, document = null, decla
   const config = JSON.parse(read(marker));
   const backing = new ZtrackBoard({ ...config, seed, marker, init, root, slug, held, readOnly });
   return { db: backing.db, snapshot: (path) => backing.snapshot(path), vacuum: (sql) => backing.vacuum(sql), tx: (fn) => backing.tx(fn), publishPending: () => backing.git?.publishPending(), unimported: () => backing.unimported(), close: () => backing.close(), document: backing.path,
-    documentsChanged: () => backing.documentsChanged(), documentsUnwatched: (unwatched) => { backing.unwatched = unwatched; }, saidOnOpen: () => backing.sayLate() };
+    documentsChanged: () => backing.documentsChanged(), ownDocument: (path) => backing.ownDocument(path), documentsUnwatched: (unwatched) => { backing.unwatched = unwatched; }, saidOnOpen: () => backing.sayLate() };
 }
 
 
@@ -155,6 +159,7 @@ class ZtrackBoard {
     // watch on them (unwatched); git's lateness held and refreshed on its own commits
     this.held = held; this.docsChanged = true; this.importDue = true; this.knownStamps = null;
     // a listing's read-only view (readSnapshot): it makes, migrates, recovers, pulls and commits nothing
+    if (readOnly && !restingReaderBound()) throw byOwner('a document listing needs its owner’s source-bound resting-state reader');
     this.readOnly = readOnly;
     this.path = resolve(dirname(marker), document);
     this.archive = `${this.path}.archive.md`;
@@ -200,6 +205,8 @@ class ZtrackBoard {
     }
     const self = this;
     this.db = {
+      get [LIST_CONNECTION]() { return self.conn; },
+      [READ_BOUNDARY]: fn => self.read(fn),
       [LIST_REVISION]: () => self.read(() => listRevision(self.conn)),
       boardErrors: self.errors,
       prepare(sql) {
@@ -270,6 +277,14 @@ class ZtrackBoard {
   }
   /** The owner's watch saw this board's documents change: their stamps are read on the next read, and only then. */
   documentsChanged() { this.docsChanged = true; this.importDue = true; }
+  /** Whether document `path` holds the text this board published itself, and no hand edit was taken in since the
+   *  owner's watch last asked: a change the owner's own write made (store.mjs ownBoardWrite). */
+  ownDocument(path) {
+    if (this.externalTaken) { this.externalTaken = false; return false; }
+    const doc = this.docs.find((d) => resolve(d.path) === resolve(path));
+    if (!doc) return false;
+    try { return this.fileHash(doc.path).hash === this.get('published', {})[doc.role]; } catch { return false; }
+  }
   // The board's documents: the open one, the current archive, and each rotated archive (recorded in the board's own
   // state, so a rotation committed but not yet written is still a document of the board).
   get docs() {
@@ -278,8 +293,26 @@ class ZtrackBoard {
     // recorded by file name, beside the document, so a board moved with its documents still finds them
     return [...this.baseDocs, ...rotated.map(({ role, name }) => ({ role, path: resolve(dirname(this.path), name) }))];
   }
-  get codec() { return this._codec ??= require('@volter/ztrack/board-document'); }
-  get preset() { return this._preset ??= require('@volter/ztrack/kanban-preset'); }
+  get codec() {
+    if (this._codec) return this._codec;
+    const codec = require('@volter/ztrack/board-document');
+    // A generation's actual predecessor chooses one immutable read/write interpretation. The options are never
+    // accepted from a CLI caller or environment; a legacy incumbent keeps the exact frozen predecessor grammar.
+    const positions = { parseBoardDocument: 2, inspectBoardDocument: 2, chunkBoardDocument: 2,
+      renderBoardCard: 3, renderBoardDocument: 4, mergeBoardDocument: 5, rechunkBoardDocument: 3 };
+    this._codec = { ...codec };
+    for (const [name, index] of Object.entries(positions)) if (typeof codec[name] === 'function') this._codec[name] = (...args) => {
+      args[index] = restingSerializationOptions();
+      return codec[name](...args);
+    };
+    return this._codec;
+  }
+  get preset() {
+    if (this._preset) return this._preset;
+    const preset = require('@volter/ztrack/kanban-preset');
+    return this._preset = { ...preset, parseKanban: records => preset.parseKanban(records, restingSerializationOptions()),
+      serializeKanbanCard: card => preset.serializeKanbanCard(card, restingSerializationOptions()) };
+  }
   board() { return { root: this.root, slug: this.slug, label: this.slug, db: this.db }; }
   close() { this.closed = true; this.git?.release(); this.dropOverlay(); this.conn.close(); }
 
@@ -327,7 +360,7 @@ class ZtrackBoard {
     }
     // What a transaction touched, for the renderer (cards whose text may change: anything beyond run fields and scheduling clocks). Plain inserts: a trigger's
     // own conflict clause yields to the outer statement's, so duplicates are removed when read.
-    this.conn.exec('CREATE TEMP TABLE IF NOT EXISTS board_dirty (name TEXT NOT NULL, key TEXT NOT NULL); CREATE TEMP TABLE IF NOT EXISTS board_touched (id TEXT)');
+    this.conn.exec('CREATE TEMP TABLE IF NOT EXISTS board_dirty (name TEXT NOT NULL, key TEXT NOT NULL); CREATE TEMP TABLE IF NOT EXISTS board_touched (id TEXT); CREATE TEMP TABLE IF NOT EXISTS board_body_before (id TEXT, body TEXT, present INTEGER NOT NULL); CREATE INDEX IF NOT EXISTS temp.board_body_before_id ON board_body_before(id)');
     this.tables = this.shapes();
     const trigger = (name, when, body) => this.conn.exec(`CREATE TEMP TRIGGER IF NOT EXISTS ${quote(name)} ${when} BEGIN ${body} END`);
     for (const { name, keys } of this.tables.values()) {
@@ -343,6 +376,15 @@ class ZtrackBoard {
       trigger(`board_tu_${name}`, `AFTER UPDATE ON main.${quote(name)} WHEN ${changed}`, `INSERT INTO board_touched VALUES (NEW.${id}); INSERT INTO board_touched VALUES (OLD.${id});`);
       trigger(`board_td_${name}`, `AFTER DELETE ON main.${quote(name)}`, `INSERT INTO board_touched VALUES (OLD.${id});`);
     }
+    // Remember the first body seen in this transaction, including delete/insert replacements. An inherited row
+    // keeps its predecessor's interpretation; only newly supplied bytes need the stricter legacy admission.
+    // Plain inserts avoid an outer statement's conflict clause replacing the original snapshot.
+    const before = (id, body, present) => `INSERT INTO board_body_before SELECT ${id}, ${body}, ${present} WHERE NOT EXISTS (SELECT 1 FROM board_body_before WHERE id = ${id});`;
+    trigger('board_body_i', 'BEFORE INSERT ON main.tasks',
+      `INSERT INTO board_body_before SELECT id, body, 1 FROM main.tasks WHERE id = NEW.id AND NOT EXISTS (SELECT 1 FROM board_body_before WHERE id = NEW.id);` + before('NEW.id', 'NULL', '0'));
+    trigger('board_body_u', 'AFTER UPDATE ON main.tasks WHEN OLD.body IS NOT NEW.body OR OLD.id IS NOT NEW.id',
+      before('NEW.id', 'CASE WHEN OLD.id IS NEW.id THEN OLD.body ELSE NULL END', 'OLD.id IS NEW.id'));
+    trigger('board_body_d', 'AFTER DELETE ON main.tasks', before('OLD.id', 'OLD.body', '1'));
   }
 
   // Each runtime table's columns and key, as the store has them.
@@ -497,11 +539,15 @@ class ZtrackBoard {
     // a listing's view is its snapshot's (readSnapshot): its statements read that, never the documents again
     if (this.readOnly) return fn();
     if (this.active) return this.noting(fn);
-    this.observeForRead();
-    for (let attempt = 0; ; attempt++) {
-      // each sleep between tries is a step: its count on a slow line is how many times the read was tried again
-      try { return fn(); } catch (error) { if (!sqliteContention(error)) throw error; timedStep('board read: contention backoff', () => backoff(attempt)); }
-    }
+    if (this.readDepth) return fn();
+    this.readDepth = 1;
+    try {
+      this.observeForRead();
+      for (let attempt = 0; ; attempt++) {
+        // each sleep between tries is a step: its count on a slow line is how many times the read was tried again
+        try { return fn(); } catch (error) { if (!sqliteContention(error)) throw error; timedStep('board read: contention backoff', () => backoff(attempt)); }
+      }
+    } finally { this.readDepth = 0; }
   }
 
   fileHash(path) {
@@ -509,6 +555,7 @@ class ZtrackBoard {
     const known = this.hashes.get(path);
     if (known?.stamp === stamp) return known;
     const raw = read(path);
+    assertBoardRestingDocument(raw, path);
     const value = { stamp, raw, hash: hash(raw) };
     this.hashes.set(path, value);
     return value;
@@ -533,20 +580,42 @@ class ZtrackBoard {
 
   // A reader sees a hand edit at once, through connection-local copies of the card tables, and
   // writes nothing: the next write records the edit.
+  observationRevision() {
+    return { connection: this.conn, ...this.statement(`SELECT total_changes() AS changes,
+      (SELECT data_version FROM pragma_data_version) AS data,
+      (SELECT schema_version FROM pragma_schema_version) AS mainSchema`).get(),
+      tempSchema: this.statement('PRAGMA temp.schema_version').get().schema_version };
+  }
+
   observeForRead() {
+    // The owner's document watch and its own writes invalidate explicitly. A foreign commit
+    // invalidates through SQLite. Include this connection's writes and both schemas: a raw
+    // write or replaced TEMP overlay must not keep an older observation. SQLite's schema_version
+    // table function reads main even when qualified with temp, so sample TEMP with its own PRAGMA.
+    // Nested reads share this boundary observation instead of rereading publication state.
+    const revision = this.observationRevision(), previous = this.observedRevision;
+    const unchanged = previous && Object.keys(revision).every(key => previous[key] === revision[key]);
+    if (this.held && !this.docsChanged && !this.unwatched && unchanged && this.seen !== null) return;
     // a held board knows its documents' stamps until the owner's watch says they changed; one opened per use reads them
     const stamps = this.held && !this.docsChanged && !this.unwatched && this.knownStamps ? this.knownStamps
       : timedStep('board read: document stamps', () => this.docs.map((doc) => this.fileHash(doc.path).stamp));
     if (this.held) { this.knownStamps = stamps; this.docsChanged = false; }
     const stamp = [...stamps, this.stateText('published'), this.stateText('pending_hashes')].join('|');
-    if (stamp === this.seen) return;
-    this.seen = stamp;
+    if (stamp === this.seen && unchanged) return;
+    this.seen = null; this.observedRevision = null;
+    if (previous && previous.mainSchema !== revision.mainSchema) this.tables = this.shapes();
     this.loadErrors();
     const stale = timedStep('board read: stale check', () => this.staleDocuments({ pending: true }));
-    if (!stale.length) { this.dropOverlay(); return; }
-    let plan;
-    try { plan = timedStep('board read: observe', () => this.observe(stale)); } catch { this.dropOverlay(); return; } // the next write reports it
-    timedStep('board read: overlay', () => this.applyPlan(plan, { overlay: true }));
+    if (!stale.length) this.dropOverlay();
+    else {
+      let plan;
+      try { plan = timedStep('board read: observe', () => this.observe(stale)); } catch { this.dropOverlay(); } // the next write reports it
+      if (plan) timedStep('board read: overlay', () => this.applyPlan(plan, { overlay: true }));
+    }
+    this.seen = stamp;
+    // Building/removing an overlay changes TEMP schema and total_changes itself. Retain its
+    // completed revision so the next unchanged read does not rebuild it again.
+    this.observedRevision = this.observationRevision();
   }
 
   // Whether a document holds an edit its tables have not imported (a hand edit, a git update): the publication owner
@@ -562,6 +631,7 @@ class ZtrackBoard {
 
   dropOverlay() {
     if (!this.overlay) return;
+    this.seen = null; this.observedRevision = null;
     this.conn.exec('DROP TABLE IF EXISTS temp.tasks; DROP TABLE IF EXISTS temp.supercode_cards; DROP TABLE IF EXISTS temp.task_links');
     this.overlay = false; this.statements.clear();
   }
@@ -569,9 +639,11 @@ class ZtrackBoard {
   // ------------------------------------------------------------------ writes
 
   tx(fn) {
+    return measureWork("pass", "board.transaction", () => {
     if (this.readOnly) throw new Error('a listing reads the board and writes nothing');
     // A write inside a write is part of it: the pull below happened once, for the outermost one.
     if (this.active) return fn(this.db);
+    this.seen = null;
     // A pull request merged on the remote (a page edited in Git Notes) is in the document before this write reads it.
     if (this.git) this.git.paths = this.docs.map((doc) => doc.path);
     try { timedStep('board git pull', () => this.git?.pull()); } catch (error) { current().err(`board: ${error.message}\n`); }
@@ -583,7 +655,7 @@ class ZtrackBoard {
         this.dropOverlay();
         timedStep('board tx begin', () => { this.conn.exec('BEGIN'); fenced(this.conn); });
         this.active = true; this.contended = false;
-        this.conn.exec('DELETE FROM temp.board_dirty; DELETE FROM temp.board_touched');
+        this.conn.exec('DELETE FROM temp.board_dirty; DELETE FROM temp.board_touched; DELETE FROM temp.board_body_before');
         this.refused = new Set();
         timedStep('board tx errors', () => this.loadErrors());
         const recovered = timedStep('board tx recover', () => this.recover());
@@ -592,9 +664,15 @@ class ZtrackBoard {
         if (this.seed) this.indexForSeed();
         else {
           const stale = timedStep('board tx stale check', () => this.staleDocuments({ pending: false }));
-          if (stale.length) timedStep('board tx reread', () => this.applyPlan(this.observe(stale), { overlay: false }));
+          if (stale.length) { this.externalTaken = true; timedStep('board tx reread', () => this.applyPlan(this.observe(stale), { overlay: false })); }
+        }
+        if (this.seed) {
+          this.seedRows();
+          // The explicit SQLite migration copies existing predecessor rows, not newly authored bodies.
+          this.conn.exec('DELETE FROM temp.board_body_before');
         }
-        if (this.seed) this.seedRows();
+        this.letGo = new Set();
+        if (!this.rendersRetried) timedStep('board tx retry renders', () => this.retryRenders());
         timedStep('board tx snapshot', () => this.snapshotHeld());
         fillReadableIds(this.db);
         const result = timedStep('board tx body', () => fn(this.db));
@@ -617,12 +695,16 @@ class ZtrackBoard {
           this.put('task_identities_written', true);
         }
         const files = timedStep('board tx render', () => this.render());
+        // Rendering may reread refused spans and run document hooks. Admit the final supplied bytes outside every
+        // recoverable render catch, before commit or publication, including bodies hidden by presentation holds.
+        timedStep('board tx body admission', () => this.validateBodyChanges());
         const intent = files.length ? randomBytes(16).toString('hex') : null;
         if (intent) {
           this.put('pending', { intent, files });
           this.put('pending_hashes', Object.fromEntries(files.map((f) => [f.role, { before: f.before, after: f.after }])));
         }
         timedStep('board tx commit', () => this.conn.exec('COMMIT'));
+        this.rendersRetried = true;
         // A long transaction holds every other writer of this board (the dispatcher's tick included), so it is a line
         // of its own in the slow log, from whichever process ran it.
         const held = performance.now() - txStarted;
@@ -658,6 +740,9 @@ class ZtrackBoard {
       }
       return outcome.result;
     }
+
+
+    });
   }
 
   // Replace each document with its committed text. A document edited in the meantime is merged
@@ -691,6 +776,8 @@ class ZtrackBoard {
     const pending = this.get('pending');
     if (!pending) return false;
     for (const file of pending.files) {
+      assertBoardRestingDocument(file.base, `${file.path} (pending base)`);
+      assertBoardRestingDocument(file.text, `${file.path} (pending publication)`);
       const current = this.fileHash(file.path);
       if (current.hash === file.after) continue;
       if (current.hash === file.before) { atomic(file.path, file.text); continue; }
@@ -780,7 +867,29 @@ class ZtrackBoard {
     const keyed = new Map([...plan.tasks].map(([tid, { key }]) => [key, tid]));
     const resolveRef = (ref) => keyed.get(ref) ?? this.one('SELECT id FROM main.board_tasks WHERE key = ?', ref)?.id ?? ref;
     for (const rows of plan.rows.values()) rows.state.blocked_by = JSON.stringify(json(rows.state.blocked_by, []).map((b) => ({ ...b, id: resolveRef(b.id) })));
-    if (held.length) this.keepMoved(plan);
+    // A subtask's task line carries only its blockers' ids. A blocker the store already holds keeps the store's entry
+    // whole (answered, aged_at, reason, by, since): a hand edit of the card's text is no new block, and an answer
+    // already handed to the workflow is not handed to it again (workflow.mjs settleRelations).
+    for (const [id, rows] of plan.rows) {
+      if (!rows.state.subtask_of) continue;
+      const stored = json(this.one('SELECT blocked_by FROM main.supercode_cards WHERE task_id = ?', id)?.blocked_by, []);
+      if (stored.length) rows.state.blocked_by = JSON.stringify(json(rows.state.blocked_by, []).map((b) => stored.find((s) => s.kind === b.kind && s.id === b.id) ?? b));
+    }
+    // A held card read again keeps what the store moved since this write began (snapshotHeld). A hand edit of a card
+    // held by a refused render (heldBy) is made over the board's last render, older than the store:
+    // it keeps what the store moved past that render, and a task line that render never showed is not removed by it.
+    if (held.length) this.keepMoved(plan, new Set(held), (id) => this.heldRows?.get(id));
+    const reads = this.refusedReads();
+    const unrendered = new Set([...plan.cards.keys()].filter((id) => !held.includes(id) && plan.before.has(id) && this.heldBy(id) && !reads.has(id)));
+    if (unrendered.size) {
+      const cardOf = (id) => plan.rows.get(id)?.state.subtask_of ?? this.one('SELECT subtask_of FROM main.supercode_cards WHERE task_id = ?', id)?.subtask_of ?? id;
+      this.keepMoved(plan, unrendered, (id) => this.spanRows(plan, cardOf(id), resolveRef).get(id), { span: true });
+      for (const id of plan.remove) {
+        const card = cardOf(id);
+        const prior = card !== id && unrendered.has(card) && !plan.remove.has(card) ? this.spanRows(plan, card, resolveRef) : null;
+        if (prior?.size && !prior.has(id)) { plan.remove.delete(id); plan.checked.add(id); }
+      }
+    }
     this.checkControls(plan, resolveRef);
     // A refused task line refuses its card's edit: the hand text stays in the document with the reason, never
     // re-rendered without the line.
@@ -797,6 +906,81 @@ class ZtrackBoard {
     return plan;
   }
 
+  // A card is held while it or one of its subtasks has a recorded refusal (board_errors). A hold is one of two kinds:
+  // - a refused read: the card's span holds document text the store refused. The card is listed in `refused_reads`,
+  //   and its span is read again when a write touches it (render, keepMoved).
+  // - a refused render: the store moved past the card's span and the codec could not render it. Its span is still the
+  //   board's own last render (any hand edit since is read, and either taken or listed as a refused read), so the
+  //   store is authoritative: the card renders again from the store, and is held again if that render fails.
+  heldBy(card) { return this.errors.has(card) || Boolean(this.one('SELECT 1 FROM main.supercode_cards WHERE subtask_of = ? AND task_id IN (SELECT id FROM main.board_errors)', card)); }
+  refusedReads() { return new Set(this.get('refused_reads', []).filter((card) => this.heldBy(card))); }
+
+  // A card held by a refused render is let go, its subtasks' refusals with it, to render from the store.
+  release(card) {
+    for (const id of [card, ...this.statement('SELECT task_id FROM main.supercode_cards WHERE subtask_of = ?').all(card).map((row) => row.task_id)]) {
+      this.errors.delete(id);
+      this.statement('DELETE FROM main.board_errors WHERE id = ?').run(id);
+    }
+  }
+
+  // A refused render is tried again on the first write of each open of the board, before that write's verb runs: a
+  // card the store renders now is let go and written by this write (render), so no verb is refused (validateEvent)
+  // for a hold the codec no longer makes. A card that still fails, its record or its subtasks' included, stays held
+  // with its recorded reason, and the write goes on. Contention and a storage fault are the write's own failure, never
+  // the card's: they end the trial and are thrown to tx(), which rolls the write back whole and tries it again.
+  retryRenders() {
+    if (!this.errors.size) return;
+    const reads = this.refusedReads();
+    const cards = new Set([...this.errors.keys()].map((id) => this.one('SELECT subtask_of FROM main.supercode_cards WHERE task_id = ?', id)?.subtask_of ?? id));
+    const where = this.placed();
+    for (const card of cards) {
+      if (reads.has(card) || !this.one('SELECT 1 FROM main.tasks WHERE id = ?', card)) continue;
+      // a trial: what building the records writes (a subtask's key) is undone, and written by render() if let go
+      this.conn.exec('SAVEPOINT retry_render');
+      let renders = false;
+      try {
+        const task = this.one('SELECT * FROM main.tasks WHERE id = ?', card);
+        const state = this.one('SELECT * FROM main.supercode_cards WHERE task_id = ?', card) ?? {};
+        const { role, level } = this.placeOf(task, state, where.get(card));
+        // as render() writes it: each ended subtask's own entry while the card is open, then the card
+        for (const sub of this.statement('SELECT t.* FROM main.tasks t JOIN main.supercode_cards s ON s.task_id = t.id WHERE s.subtask_of = ?').all(card)) {
+          const subState = this.one('SELECT * FROM main.supercode_cards WHERE task_id = ?', sub.id) ?? {};
+          if (role !== 'open' || !ENDED.has(subState.stage ?? sub.status)) continue;
+          const subAt = where.get(sub.id), kept = isArchive(subAt?.role);
+          this.codec.renderBoardCard(this.subtaskRecord(sub.id, sub, subState, card, where), kept ? subAt.entry.level : 2, this.docOf(kept ? subAt.role : 'archived').path);
+        }
+        this.codec.renderBoardCard(this.recordOf(card, task, state, where), level, this.docOf(role).path);
+        renders = true;
+      } catch (error) {
+        // SQLite may have rolled the whole transaction back (IOERR, FULL, BUSY): the savepoint is gone with it, and
+        // nothing after this may run outside the write's transaction (a Node before 22.16 has no isTransaction, and
+        // says nothing of it)
+        if (contention(error) || storageFault(error) || this.conn.isTransaction === false) throw error;
+        /* otherwise still unrenderable: held as it was */
+      }
+      this.conn.exec('ROLLBACK TO retry_render; RELEASE retry_render');
+      if (!renders) continue;
+      this.release(card);
+      this.letGo.add(card);
+      this.statement('INSERT INTO temp.board_touched VALUES (?)').run(card);
+    }
+  }
+
+  // Every entry of every document, by card id: { role, index, entry }.
+  placed() {
+    const where = new Map();
+    for (const { role } of this.docs) this.entries(role).forEach((entry, index) => { if (entry.id) where.set(nativeId(entry.id), { role, index, entry }); });
+    return where;
+  }
+
+  // The document a card renders into, and its heading level there: an ended card stays in the archive that holds it (a
+  // rotated one included); one that newly ends goes to the current.
+  placeOf(task, state, at) {
+    const ended = state.archived || ENDED.has(state.stage ?? task.status);
+    const role = !ended ? 'open' : isArchive(at?.role) ? at.role : 'archived';
+    return { role, level: at?.role === role ? at.entry.level : 2 };
+  }
+
   // The rows of every card held by a recorded refusal (with its subtasks) before this write's verb runs, so a held
   // card read again after it keeps what the verb moved (keepMoved).
   snapshotHeld() {
@@ -810,22 +994,58 @@ class ZtrackBoard {
     }
   }
 
-  // A held card's span is older than this write: every column the write's verb moved keeps the store's value
-  // (title, body, assignee, status, ...); the span's text lands only where the store did not move.
-  keepMoved(plan) {
-    const same = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+  // A held card's span is older than the store: every column the store moved past `base` (the rows the span stands
+  // for) keeps the store's value (title, body, assignee, status, ...); the span's text lands only where the store did
+  // not move. `cards` are the cards whose rows this applies to; `span` says `base` is the rows parsed from the span.
+  keepMoved(plan, cards, base, { span = false } = {}) {
+    // A span's parse and the store's row write one value differently, and a difference of form alone moves nothing
+    // (a person's edit is kept): blocked_by's entries are compared whole (the store's own fields included: answered,
+    // aged_at, reason, by, since), each with its keys in one order and the entries in kind/id order, so a store change
+    // to any field moves it; a body without its trailing newlines (a span's parse ends its body with one, a stored
+    // body need not). Against a span, a subtask's line differs from its store row in two more ways: its blocker ids
+    // are all the line carries, so its blocked_by is compared by kind and id; and its title carries its task key (the
+    // line reads `c1 title`, a subtask made by a verb stores `title`; both render the same line). Against a snapshot of
+    // the store both sides are the store's, and are compared whole.
+    const ordered = (v) => Array.isArray(v) ? v.map(ordered)
+      : v && typeof v === 'object' ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, ordered(v[k])])) : v;
+    const blocks = (v, ids) => (json(v, []) ?? []).map((b) => ids ? { id: b?.id, kind: b?.kind } : ordered(b))
+      .sort((a, b) => String(a.kind).localeCompare(String(b.kind)) || String(a.id).localeCompare(String(b.id)));
+    const value = (key, v, line) => key === 'blocked_by' ? blocks(v, line)
+      : ['paused', 'backlog'].includes(key) ? json(v, null) : key === 'archived' ? Boolean(v)
+      : key === 'body' ? String(v ?? '').replace(/\n+$/, '')
+      : key === 'title' && line ? String(v ?? '').replace(/^[a-z]+\d+\s+(?=\S)/, '') : v ?? null;
+    const same = (key, a, b, line) => JSON.stringify(value(key, a, line)) === JSON.stringify(value(key, b, line));
     for (const [id, rows] of plan.rows) {
+      if (!cards.has(rows.state.subtask_of ?? id)) continue;
       const task = this.one('SELECT * FROM main.tasks WHERE id = ?', id), state = this.one('SELECT * FROM main.supercode_cards WHERE task_id = ?', id);
       if (!task) continue;
-      const was = this.heldRows?.get(id);
+      const was = base(id);
       for (const [side, now, then] of [['task', task, was?.task], ['state', state, was?.state]]) {
         if (!now) continue;
-        // A row the write created has nothing held to keep: all of it is the store's.
-        for (const key of Object.keys(now)) if (!then || !same(now[key], then[key])) rows[side][key] = now[key];
+        // A row `base` does not hold (one the store made since) has nothing held to keep: all of it is the store's.
+        for (const key of Object.keys(now)) if (!then || !same(key, now[key], then[key], span && Boolean(rows.state.subtask_of))) rows[side][key] = now[key];
       }
     }
   }
 
+  // The rows a card's span read as before this edit (plan.before), with its subtasks', parsed once per plan.
+  spanRows(plan, card, resolveRef) {
+    plan.spans ??= new Map();
+    if (plan.spans.has(card)) return plan.spans.get(card);
+    const rows = new Map(); plan.spans.set(card, rows);
+    const at = plan.before.get(card);
+    if (!at) return rows;
+    try {
+      const { records, errors } = this.codec.inspectBoardDocument(this.texts([at.entry])[0].text, this.docOf(at.role).path);
+      if (errors.length || records.length !== 1 || nativeId(records[0].id) !== card) return rows;
+      const parsed = this.preset.KanbanRootSchema.parse(this.preset.parseKanban([records[0]])).issues[0];
+      rows.set(card, this.cardRows(card, parsed, null));
+      for (const [tid, taskCard] of this.taskCards(card, parsed)) rows.set(tid, this.cardRows(tid, taskCard, card));
+      for (const r of rows.values()) r.state.blocked_by = JSON.stringify(json(r.state.blocked_by, []).map((b) => ({ ...b, id: resolveRef(b.id) })));
+    } catch { rows.clear(); } // an unreadable span says nothing of what the lines said
+    return rows;
+  }
+
   planRemoval(plan, id) {
     const task = this.one('SELECT current_run_id FROM main.tasks WHERE id = ?', id);
     if (!task) return;
@@ -845,30 +1065,14 @@ class ZtrackBoard {
     try { fields = workflowFor(this.root).params.document_control_fields ?? []; } catch { /* no home policy */ }
     const value = (task, state, field) => field === 'status' ? state?.stage ?? task?.status ?? 'todo'
       : field === 'blocked_by' ? json(state?.blocked_by, []).map((b) => [b.kind, b.id]).sort()
-      : field === 'paused' ? json(state?.paused, null)
+      : ['paused', 'backlog'].includes(field) ? json(state?.[field], null)
       : field === 'archived' ? Boolean(state?.archived) : task?.[field] ?? null;
     const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-    // The rows a card's span read as before this edit, with its subtasks', parsed only when a field differs.
-    const before = new Map();
-    const rowsBefore = (card) => {
-      if (before.has(card)) return before.get(card);
-      const rows = new Map(); before.set(card, rows);
-      const at = plan.before.get(card);
-      if (!at) return rows;
-      try {
-        const { records, errors } = this.codec.inspectBoardDocument(this.texts([at.entry])[0].text, this.docOf(at.role).path);
-        if (errors.length || records.length !== 1 || nativeId(records[0].id) !== card) return rows;
-        const parsed = this.preset.KanbanRootSchema.parse(this.preset.parseKanban([records[0]])).issues[0];
-        rows.set(card, this.cardRows(card, parsed, null));
-        for (const [tid, taskCard] of this.taskCards(card, parsed)) rows.set(tid, this.cardRows(tid, taskCard, card));
-        for (const r of rows.values()) r.state.blocked_by = JSON.stringify(json(r.state.blocked_by, []).map((b) => ({ ...b, id: resolveRef(b.id) })));
-      } catch { rows.clear(); } // an unreadable span says nothing of what the lines said
-      return rows;
-    };
+    const rowsBefore = (card) => this.spanRows(plan, card, resolveRef);
     const adopt = (rows, task, state, field) => {
       if (field === 'status') { rows.task.status = task.status; rows.state.stage = state?.stage ?? null; }
       else if (field === 'blocked_by') rows.state.blocked_by = state?.blocked_by ?? '[]';
-      else if (field === 'paused') rows.state.paused = state?.paused ?? null;
+      else if (['paused', 'backlog'].includes(field)) rows.state[field] = state?.[field] ?? null;
       else if (field === 'archived') rows.state.archived = state?.archived ?? 0;
       else rows.task[field] = task[field] ?? null;
     };
@@ -901,6 +1105,7 @@ class ZtrackBoard {
     const schema = overlay ? 'temp' : 'main';
     if (overlay) {
       this.dropOverlay();
+      this.seen = null; this.observedRevision = null;
       this.conn.exec('CREATE TEMP TABLE tasks AS SELECT * FROM main.tasks; CREATE TEMP TABLE supercode_cards AS SELECT * FROM main.supercode_cards; CREATE TEMP TABLE task_links AS SELECT * FROM main.task_links');
       this.conn.exec(TASK_SUMMARY_INDEX_SQL.replace(TASK_SUMMARY_INDEX, `temp.${TASK_SUMMARY_INDEX}`));
       this.conn.exec("CREATE UNIQUE INDEX temp.supercode_open_readable_ids ON tasks(readable_id) WHERE status NOT IN ('done','cancelled','archived')");
@@ -946,6 +1151,12 @@ class ZtrackBoard {
       const oldState = this.one(`SELECT * FROM ${schema}.supercode_cards WHERE task_id = ?`, id) ?? {};
       this.replace(schema, 'tasks', { ...oldTask, ...rows.task }, 'id');
       this.replace(schema, 'supercode_cards', { ...oldState, ...rows.state }, 'task_id');
+      // Imports and rebuilt caches must satisfy the same release boundary as the manager's
+      // backlog verb. A read overlay is discarded on refusal so it cannot hide execution holdings.
+      try {
+        assertPauseRecord(json(rows.state.paused, null), { id, source: 'document' });
+        assertBacklogQualified(this.conn, id, { backlog: json(rows.state.backlog, null), source: 'document' });
+      } catch (error) { if (overlay) this.dropOverlay(); throw error; }
       if (rebuilding && ENDED.has(rows.state.stage ?? rows.task.status) && oldTask.current_run_id) {
         this.statement("UPDATE main.task_runs SET ended_at = COALESCE(ended_at, ?), status = 'reclaimed', outcome = COALESCE(outcome, 'reclaimed') WHERE id = ? AND ended_at IS NULL").run(now(), oldTask.current_run_id);
         this.statement('UPDATE main.tasks SET current_run_id = NULL, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL WHERE id = ?').run(id);
@@ -970,6 +1181,8 @@ class ZtrackBoard {
     for (const [tid, { key, sources }] of plan.tasks) this.statement('INSERT OR REPLACE INTO main.board_tasks (id, key, sources) VALUES (?, ?, ?)').run(tid, key, sources?.length ? JSON.stringify(sources) : null);
     for (const id of [...plan.checked, ...plan.rows.keys()]) if (!plan.errors.has(id)) this.statement('DELETE FROM main.board_errors WHERE id = ?').run(id);
     for (const [id, reason] of plan.errors) this.statement('INSERT OR REPLACE INTO main.board_errors VALUES (?, ?)').run(id, reason);
+    // A card this read refused holds the refused text in its span (a refused read); one it took or let go holds none.
+    this.put('refused_reads', [...new Set([...this.get('refused_reads', []), ...this.refused])].filter((card) => this.heldBy(card)));
     for (const [role, entries] of plan.layout) {
       if (!(role in plan.published)) continue;
       this.put(`chunks:${role}`, entries.map((entry) => {
@@ -1000,7 +1213,7 @@ class ZtrackBoard {
 
   fingerprint(t, c) {
     const status = c.stage ?? t.status;
-    return { hash: hash(JSON.stringify([t.title, t.body, status, t.assignee, c.machine, c.blocked_by, c.paused, c.every])), status, assignee: t.assignee, parent: c.subtask_of };
+    return { hash: hash(JSON.stringify([t.title, t.body, status, t.assignee, c.machine, c.blocked_by, c.paused, c.backlog, c.every])), status, assignee: t.assignee, parent: c.subtask_of };
   }
 
   // A card's rows from its parsed document form. Run fields and clocks stay the table's.
@@ -1008,7 +1221,7 @@ class ZtrackBoard {
     // An ended subtask kept in the archive document names its card (`subtask_of`); it is not a column of the task.
     const { subtask_of: declaredParent, ...meta } = card.metadata ?? {};
     parent ??= declaredParent ? nativeId(declaredParent) : null;
-    const stored = this.preset.serializeKanbanCard({ ...card, acceptanceCriteria: [], relations: [], metadata: undefined, paused: undefined, every: undefined, workspace: undefined, branch: undefined, machine: undefined, priority: undefined });
+    const stored = this.preset.serializeKanbanCard({ ...card, acceptanceCriteria: [], relations: [], metadata: undefined, paused: undefined, backlog: undefined, every: undefined, workspace: undefined, branch: undefined, machine: undefined, priority: undefined });
     const workspace = /^(scratch|dir|worktree)(?::(.*))?$/.exec(card.workspace ?? 'scratch');
     const old = this.one('SELECT * FROM main.tasks WHERE id = ?', id) ?? {};
     const runtime = Object.fromEntries(Object.entries(old).filter(([k]) => RUNTIME.has(k) || RUN_OUTPUT.has(k)));
@@ -1019,9 +1232,9 @@ class ZtrackBoard {
       blocked_by: JSON.stringify((card.relations ?? []).map((r) => ({ ...(meta.blocked_by ?? []).find((b) => b.id === nativeId(r.issueId)), id: nativeId(r.issueId), kind: /^[ma]-/.test(r.issueId) ? 'message' : 'card' }))),
       // A card whose text says nothing of archiving keeps the store's flag: an entry rendered before subtask lines
       // carried it (or edited without it) is not an unarchive. Saying `archived: false` of an archived card is.
-      paused: card.paused ? JSON.stringify(card.paused) : null, every: card.every ?? null,
+      paused: card.paused ? JSON.stringify(card.paused) : null, backlog: card.backlog ? JSON.stringify(card.backlog) : null, every: card.every ?? null,
       archived: (meta.archived ?? card.archived) === undefined ? Number(this.one('SELECT archived FROM main.supercode_cards WHERE task_id = ?', id)?.archived ?? 0) : ((meta.archived ?? card.archived) ? 1 : 0) };
-    if (!state.archived && !ENDED.has(card.status)) task.status = card.paused ? 'paused' : card.relations?.length ? 'blocked' : card.status;
+    if (!state.archived && !ENDED.has(card.status)) task.status = card.paused ? 'paused' : card.relations?.length ? 'blocked' : card.backlog ? 'todo' : card.status;
     return { task, state };
   }
 
@@ -1035,7 +1248,7 @@ class ZtrackBoard {
       const stored = this.one('SELECT * FROM main.tasks WHERE id = ?', tid);
       const storedState = this.one('SELECT * FROM main.supercode_cards WHERE task_id = ?', tid);
       const was = task.metadata?.status ?? storedState?.stage ?? stored?.status;
-      const taskCard = { ...(storedState ? { paused: json(storedState.paused, null) ?? undefined, every: storedState.every || undefined } : {}), ...task.metadata?.card,
+      const taskCard = { ...(storedState ? { paused: json(storedState.paused, null) ?? undefined, backlog: json(storedState.backlog, null) ?? undefined, every: storedState.every || undefined } : {}), ...task.metadata?.card,
         id: tid, title: `${task.id} ${task.text}`, body: task.metadata?.body ?? task.brief ?? '',
         status: task.status === 'passed' ? (was === 'cancelled' ? 'cancelled' : 'done') : (ENDED.has(was) ? 'todo' : was ?? 'todo'),
         metadata: task.metadata?.properties ?? Object.fromEntries(Object.entries(stored ?? {}).filter(([k, v]) => declared(k, v))),
@@ -1065,19 +1278,32 @@ class ZtrackBoard {
     let parents = cardsTouched();
     const mark = this.numberMark();
     if (!parents.size && !mark) return [];
-    const heldBy = (id) => this.errors.has(id) || this.one('SELECT 1 FROM main.supercode_cards WHERE subtask_of = ? AND task_id IN (SELECT id FROM main.board_errors)', id);
+    const heldBy = (id) => this.heldBy(id);
     // A card held by a recorded refusal is not rendered, so the store's verbs move its tasks past its lines. When
-    // the store moves it, its span is read again: what the store moved past is stale and takes the store's value
-    // (checkControls), and the card renders. A card refused by this write's own edit stays as it was written.
+    // the store moves it, a refused read's span is read again: what the store moved past is stale and takes the
+    // store's value (keepMoved, checkControls), and the card renders. A refused render's span is the board's own and
+    // older than the store, so it is never read back: the card renders from the store (heldBy). A card refused by this
+    // write's own edit stays as it was written.
     const held = [...parents].filter((id) => !this.refused.has(id) && heldBy(id));
-    if (held.length) { this.applyPlan(this.observe([], held), { overlay: false }); parents = cardsTouched(); }
+    const reads = this.refusedReads();
+    // the refused renders let go for this write (this one's and retryRenders'): one that still cannot render is held again
+    const released = new Set(this.letGo ?? []);
+    for (const id of held) if (!reads.has(id)) { this.release(id); released.add(id); }
+    const reread = held.filter((id) => reads.has(id));
+    if (reread.length) { this.applyPlan(this.observe([], reread), { overlay: false }); parents = cardsTouched(); }
     if (this.seedIds) for (const id of this.seedIds) parents.add(id);
     const roles = this.docs.map((doc) => doc.role);
     const layout = Object.fromEntries(roles.map((role) => [role, this.entries(role)]));
-    const where = new Map();
-    for (const role of roles) layout[role].forEach((entry, index) => { if (entry.id) where.set(nativeId(entry.id), { role, index, entry }); });
+    const where = this.placed();
     const edits = Object.fromEntries(roles.map((role) => [role, []]));
     if (mark) edits.open.push(mark);
+    // a refused render: the span stays the board's last render, and the store stays authoritative
+    const hold = (id, reason) => {
+      this.errors.set(id, reason);
+      this.statement('INSERT OR REPLACE INTO main.board_errors VALUES (?, ?)').run(id, reason);
+      const listed = this.get('refused_reads', []);
+      if (listed.includes(id)) this.put('refused_reads', listed.filter((card) => card !== id));
+    };
     for (const id of parents) {
       if (heldBy(id)) continue;
       const task = this.one('SELECT * FROM main.tasks WHERE id = ?', id);
@@ -1085,37 +1311,42 @@ class ZtrackBoard {
       if (task && state.subtask_of) continue;
       const at = where.get(id);
       if (!task) { if (at) edits[at.role].push({ index: at.index, remove: true }); continue; }
-      // An ended card stays in the archive that holds it (a rotated one included); one that newly ends goes to the current.
-      const ended = state.archived || ['done', 'cancelled'].includes(state.stage ?? task.status);
-      const role = !ended ? 'open' : isArchive(at?.role) ? at.role : 'archived';
-      // Its ended subtasks: each its own entry in the archive document while the card is open (the open document lists
-      // only what is still to do); back in the card's own text once the card has ended.
-      for (const sub of this.statement('SELECT t.* FROM main.tasks t JOIN main.supercode_cards s ON s.task_id = t.id WHERE s.subtask_of = ?').all(id)) {
-        const subState = this.one('SELECT * FROM main.supercode_cards WHERE task_id = ?', sub.id) ?? {};
-        const subAt = where.get(sub.id);
-        if (role !== 'open' || !ENDED.has(subState.stage ?? sub.status)) { if (subAt) edits[subAt.role].push({ index: subAt.index, remove: true }); continue; }
-        const subRecord = this.subtaskRecord(sub.id, sub, subState, id, where);
-        const subRec = hash(JSON.stringify(subRecord));
-        const kept = isArchive(subAt?.role);
-        if (kept && subAt.entry.rec === subRec) continue;
-        let subText;
-        try { subText = this.codec.renderBoardCard(subRecord, kept ? subAt.entry.level : 2, this.docOf(kept ? subAt.role : 'archived').path); }
-        catch (error) { this.errors.set(sub.id, error.message); continue; }
-        const subEntry = { cid: null, id: subRecord.id, level: kept ? subAt.entry.level : 2, len: subText.length, rec: subRec, text: subText };
-        if (kept) edits[subAt.role].push({ index: subAt.index, entry: subEntry });
-        else { if (subAt) edits[subAt.role].push({ index: subAt.index, remove: true }); edits.archived.push({ entry: subEntry }); }
+      const { role, level } = this.placeOf(task, state, at);
+      // This card's edits, made once its record is built: a released card whose record cannot be built is held again
+      // whole, its subtasks' entries untouched with it.
+      const own = [];
+      let record;
+      try {
+        // Its ended subtasks: each its own entry in the archive document while the card is open (the open document
+        // lists only what is still to do); back in the card's own text once the card has ended.
+        for (const sub of this.statement('SELECT t.* FROM main.tasks t JOIN main.supercode_cards s ON s.task_id = t.id WHERE s.subtask_of = ?').all(id)) {
+          const subState = this.one('SELECT * FROM main.supercode_cards WHERE task_id = ?', sub.id) ?? {};
+          const subAt = where.get(sub.id);
+          if (role !== 'open' || !ENDED.has(subState.stage ?? sub.status)) { if (subAt) own.push([subAt.role, { index: subAt.index, remove: true }]); continue; }
+          const subRecord = this.subtaskRecord(sub.id, sub, subState, id, where);
+          const subRec = hash(JSON.stringify(subRecord));
+          const kept = isArchive(subAt?.role);
+          if (kept && subAt.entry.rec === subRec) continue;
+          let subText;
+          try { subText = this.codec.renderBoardCard(subRecord, kept ? subAt.entry.level : 2, this.docOf(kept ? subAt.role : 'archived').path); }
+          catch (error) { this.errors.set(sub.id, error.message); continue; }
+          const subEntry = { cid: null, id: subRecord.id, level: kept ? subAt.entry.level : 2, len: subText.length, rec: subRec, text: subText };
+          if (kept) own.push([subAt.role, { index: subAt.index, entry: subEntry }]);
+          else { if (subAt) own.push([subAt.role, { index: subAt.index, remove: true }]); own.push(['archived', { entry: subEntry }]); }
+        }
+        record = this.recordOf(id, task, state, where);
+      } catch (error) {
+        // contention and a storage fault (or a transaction SQLite already rolled back) fail the write, never the card
+        if (!released.has(id) || contention(error) || storageFault(error) || this.conn.isTransaction === false) throw error;
+        hold(id, error.message);
+        continue;
       }
-      const record = this.recordOf(id, task, state, where);
+      for (const [r, edit] of own) edits[r].push(edit);
       const rec = hash(JSON.stringify(record));
       if (at?.role === role && at.entry.rec === rec) continue;
-      const level = at?.role === role ? at.entry.level : 2;
       let text;
       try { text = this.codec.renderBoardCard(record, level, this.docOf(role).path); }
-      catch (error) {
-        this.errors.set(id, error.message);
-        this.statement('INSERT OR REPLACE INTO main.board_errors VALUES (?, ?)').run(id, error.message);
-        continue;
-      }
+      catch (error) { hold(id, error.message); continue; }
       const entry = { cid: null, id: record.id, level, len: text.length, rec, text };
       if (at?.role === role) edits[role].push({ index: at.index, entry });
       else { if (at) edits[at.role].push({ index: at.index, remove: true }); edits[role].push({ entry }); }
@@ -1191,17 +1422,38 @@ class ZtrackBoard {
     published.archived = hash('');
   }
 
+  validateBodyChanges() {
+    if (restingSerializationOptions().resting !== 'legacy') return;
+    const rows = this.statement(`SELECT t.*, COALESCE(s.stage,t.status) AS stage FROM temp.board_body_before b
+      JOIN main.tasks t ON t.id = b.id LEFT JOIN main.supercode_cards s ON s.task_id = t.id
+      WHERE b.present = 0 OR t.body IS NOT b.body`).all();
+    for (const row of rows) this.parseStoredCard({ id: row.id, title: row.title, status: row.stage, body: row.body ?? '' }, row.id);
+  }
+
+  // Validate newly supplied body bytes before the frozen parser can move Acceptance annotations or remove literal
+  // escapes. Existing bytes retain the exact predecessor meaning on metadata edits and SQLite migration; incoming
+  // documents have their own raw admission before parsing. Use the native row id even when its file id differs.
+  parseStoredCard(record, id) {
+    const before = this.one('SELECT body, present FROM temp.board_body_before WHERE id = ?', id);
+    if (restingSerializationOptions().resting === 'legacy' && before && (!before.present || before.body !== record.body)) {
+      const preset = require('@volter/ztrack/kanban-preset');
+      const meaning = preset.KanbanRootSchema.parse(preset.parseKanban([record], { resting: 'preserve' })).issues[0];
+      preset.serializeKanbanCard(meaning, { resting: 'legacy' });
+      this.codec.renderBoardCard(record, 2, this.path);
+    }
+    return this.preset.KanbanRootSchema.parse(this.preset.parseKanban([record])).issues[0];
+  }
+
   // The document record of card `id`, from its rows and its subtasks' rows.
   recordOf(id, row, c, where) {
     const fileId = (x) => where.get(x)?.entry.id ?? x;
     const keyOf = (x) => this.one('SELECT key FROM main.board_tasks WHERE id = ?', x)?.key ?? null;
-    const parse = (record) => this.preset.KanbanRootSchema.parse(this.preset.parseKanban([record])).issues[0];
-    const parsed = parse({ id: fileId(id), title: row.title, status: c.stage ?? row.status, assignee: row.assignee || undefined, body: row.body ?? '' });
+    const parsed = this.parseStoredCard({ id: fileId(id), title: row.title, status: c.stage ?? row.status, assignee: row.assignee || undefined, body: row.body ?? '' }, id);
     const metadata = Object.fromEntries(Object.entries(row).filter(([k, v]) => declared(k, v)));
     if (c.archived) metadata.archived = true;
     if (json(c.blocked_by, []).length) metadata.blocked_by = json(c.blocked_by, []);
     const card = { ...parsed, metadata, priority: row.priority ?? 0, workspace: row.workspace_kind + (row.workspace_kind !== 'scratch' && (c.workspace_anchor ?? row.workspace_path) ? `:${c.workspace_anchor ?? row.workspace_path}` : ''),
-      branch: row.branch_name || undefined, machine: c.machine || undefined, paused: json(c.paused, null) ?? undefined, every: c.every || undefined,
+      branch: row.branch_name || undefined, machine: c.machine || undefined, paused: json(c.paused, null) ?? undefined, backlog: json(c.backlog, null) ?? undefined, every: c.every || undefined,
       // Task lines left in a stored body (create and specify file them as subtasks) stay in its Tasks, before its subtasks.
       relations: json(c.blocked_by, []).map((b) => ({ type: 'blocked-by', issueId: fileId(b.id) })), acceptanceCriteria: [...(parsed.acceptanceCriteria ?? [])] };
     // An open card lists its open subtasks; its ended ones are kept in the archive document (subtaskRecord), so the open
@@ -1225,7 +1477,7 @@ class ZtrackBoard {
       const stored = this.one('SELECT key, sources FROM main.board_tasks WHERE id = ?', r.id);
       if (stored?.key !== `${id}:${key}`) this.statement('INSERT INTO main.board_tasks (id, key, sources) VALUES (?, ?, ?) ON CONFLICT(id) DO UPDATE SET key = excluded.key').run(r.id, `${id}:${key}`, stored?.sources ?? null);
       const match = /^([a-z]+\d+)\s+(.+)$/.exec(r.title);
-      const task = parse({ id: r.id, title: r.title, status, body: r.body ?? '' });
+      const task = this.parseStoredCard({ id: r.id, title: r.title, status, body: r.body ?? '' }, r.id);
       const blocks = json(s.blocked_by, []);
       const messages = blocks.filter((block) => block.kind === 'message');
       // Keep the identity-to-number binding and declared state durable with its line; a stale runtime cache cannot
@@ -1234,7 +1486,8 @@ class ZtrackBoard {
         metadata: { id: r.id, status, assignee: r.assignee, machine: s.machine,
           properties: Object.fromEntries(Object.entries(r).filter(([k, v]) => declared(k, v))),
           card: { priority: r.priority ?? 0, workspace: r.workspace_kind + (r.workspace_kind !== 'scratch' && (s.workspace_anchor ?? r.workspace_path) ? `:${s.workspace_anchor ?? r.workspace_path}` : ''),
-            branch: r.branch_name || undefined, paused: json(s.paused, null) ?? undefined, every: s.every || undefined } },
+            branch: r.branch_name || undefined, paused: json(s.paused, null) ?? undefined, backlog: json(s.backlog, null) ?? undefined, every: s.every || undefined,
+            acceptancePreamble: task.acceptancePreamble?.length ? task.acceptancePreamble : undefined } },
         ...(task.body ? { brief: task.body } : {}), lines: task.acceptance,
         waitingOn: messages[0]?.id,
         blockedBy: blocks.filter((block) => block !== messages[0]).map((block) => {
@@ -1244,7 +1497,7 @@ class ZtrackBoard {
           return { issue: fileId(target.slice(0, at)), ac: target.slice(at + 1) };
         }) });
     }
-    const serialized = this.preset.serializeKanbanCard(card);
+    const serialized = this.preset.serializeKanbanCard(card, restingSerializationOptions());
     return { id: card.id, ...this.numberOf(id), title: card.title, status: card.status, ...(card.assignee ? { assignee: card.assignee } : {}), body: serialized.body };
   }
 
@@ -1349,10 +1602,10 @@ class ZtrackBoard {
   // An ended subtask's own record in the archive document: its title and brief, and the card it belongs to.
   subtaskRecord(id, task, state, parentId, where) {
     const fileId = (x) => where.get(x)?.entry.id ?? x;
-    const parsed = this.preset.KanbanRootSchema.parse(this.preset.parseKanban([{ id: fileId(id), title: task.title, status: state.stage ?? task.status, assignee: task.assignee || undefined, body: task.body ?? '' }])).issues[0];
+    const parsed = this.parseStoredCard({ id: fileId(id), title: task.title, status: state.stage ?? task.status, assignee: task.assignee || undefined, body: task.body ?? '' }, id);
     const metadata = { subtask_of: fileId(parentId), ...Object.fromEntries(Object.entries(task).filter(([k, v]) => declared(k, v))) };
     const card = { ...parsed, metadata, machine: state.machine || undefined, relations: [] };
-    const serialized = this.preset.serializeKanbanCard(card);
+    const serialized = this.preset.serializeKanbanCard(card, restingSerializationOptions());
     return { id: card.id, ...this.numberOf(id), title: card.title, status: card.status, ...(card.assignee ? { assignee: card.assignee } : {}), body: serialized.body };
   }