create-walle 0.10.0 → 0.10.2

package/template/coding-task-manager/lib/typing-worker-stages.js

@@ -25,6 +25,18 @@ function mergePendingInteractionIds(existing, incoming, limit = PENDING_IDS_LIMI
   return merged.slice(-limit);
 }
 
+// WP-4 (R-7, clock-free-tests-followups-r3-2026-10-24.html §5 R-7, §6 WP-4): keep the per-id
+// inputSeq map to exactly the ids `pending` still carries, oldest dropped first, capped at
+// `limit` -- the same "keep the most recent N" policy mergePendingInteractionIds applies to the
+// id list itself, so the two can never drift apart.
+function prunePendingInputSeqs(byId, pending, limit = PENDING_IDS_LIMIT) {
+  for (const id of Array.from(byId.keys())) {
+    if (!pending.includes(id)) byId.delete(id);
+  }
+  while (byId.size > limit) byId.delete(byId.keys().next().value);
+  return byId;
+}
+
 // Post ONE 'typing-stage' message covering every id currently pending for this session -- the
 // STAGES store's note() (lib/typing-interaction-trace.js) fans it out per-interactionId and is
 // idempotent per (interactionId, stage), so calling this more than once for the same boundary is
@@ -38,4 +50,199 @@ function noteWorkerTypingStage(postTransport, sessionId, interactionIds, stage,
   });
 }
 
-module.exports = { mergePendingInteractionIds, noteWorkerTypingStage, PENDING_IDS_LIMIT };
+// --- WP-3 shadow echo matchers -----------------------------------------------------------
+// Design doc: composer-freeze-followups-load-sigstop-attribution-2026-10-20.html §5 D-C2
+// (two per-key matchers, shadow-only, OPTIONAL stages) and §1.3 (most existing stages are
+// "first X after the key", not that key's echo -- e.g. pty-output lands 0-3 ms after
+// pty-written in 14 of 18 retained slow rows, which no agent CLI can do).
+//
+// Prior art, both rules copied as-is:
+//   - echo-bytes = VS Code terminal typeahead's rule: the predicted char is "eaten" out of
+//     the incoming BYTE STREAM once SGR/escape sequences are skipped
+//     (terminalTypeAheadAddon.ts, `input.eatChar(this._char)`).
+//   - echo-cell = mosh's rule: a prediction is confirmed only when "a letter we hypothesized
+//     to appear in a particular cell did appear there" (mosh paper, USENIX ATC'12).
+//
+// Both stamps are per-key (ONE interactionId), shadow-only: nothing reads them as truth and
+// no existing stage changes meaning (that decision is WP-5, on WP-4's numbers, per D-C4).
+const ECHO_PREDICTION_CAP = 24;
+// D-C2: a prediction that neither matcher confirmed within this window is dropped -- the CLI
+// may echo arbitrarily late, but a stale prediction can only ever produce a false positive
+// against a later, unrelated redraw.
+const ECHO_PREDICTION_TTL_MS = 10_000;
+
+// One grapheme, at most 4 UTF-8 bytes, no C0 control / ESC / DEL -- the D-C2 input class that
+// can be predicted at all. This is also what server.js uses to decide whether a keystroke
+// carries an `echo` payload; it lives here so server.js stays at its file-size ratchet.
+const _echoSegmenter = new Intl.Segmenter();
+function isSingleGraphemeEcho(data) {
+  if (typeof data !== 'string' || !data) return false;
+  if (Buffer.byteLength(data, 'utf8') > 4) return false;
+  if (/[\x00-\x1f\x7f]/.test(data)) return false;
+  let count = 0;
+  for (const _segment of _echoSegmenter.segment(data)) {
+    count += 1;
+    if (count > 1) return false;
+  }
+  return count === 1;
+}
+
+// D-C2: the byte matcher must look at what the CLI actually printed, not at the escape
+// sequences around it. Strip CSI (`ESC [ ... final`), OSC (`ESC ] ... BEL | ESC \`) and any
+// other two-byte `ESC x`, leaving only the printable text.
+function stripEscapeSequences(text) {
+  const source = String(text ?? '');
+  let out = '';
+  let index = 0;
+  while (index < source.length) {
+    if (source[index] !== '\x1b') {
+      out += source[index];
+      index += 1;
+      continue;
+    }
+    const next = source[index + 1];
+    if (next === '[') {
+      let end = index + 2;
+      // ECMA-48 CSI: parameter/intermediate bytes are 0x20-0x3f, the final byte is 0x40-0x7e.
+      while (end < source.length) {
+        const code = source.charCodeAt(end);
+        if (code >= 0x40 && code <= 0x7e) break;
+        end += 1;
+      }
+      index = end + 1;
+    } else if (next === ']') {
+      let end = index + 2;
+      while (end < source.length && source[end] !== '\x07'
+        && !(source[end] === '\x1b' && source[end + 1] === '\\')) {
+        end += 1;
+      }
+      if (end >= source.length) index = source.length;
+      else index = source[end] === '\x07' ? end + 1 : end + 2;
+    } else if (next === undefined) {
+      index = source.length;
+    } else {
+      index += 2;
+    }
+  }
+  return out;
+}
+
+// D-C2, called from the 'note-input' handler (headless-term-service.js). Merges the incoming
+// interactionIds exactly like the inline block it replaces, then -- when the keystroke carries
+// a single-grapheme `echo` -- records where the CLI's echo SHOULD land from here: the cursor
+// cell of the mirror at this instant, in the buffer that is active at this instant.
+function armEchoPrediction(entry, msg) {
+  if (!entry || !entry.state || !msg) return;
+  if (Array.isArray(msg.interactionIds) && msg.interactionIds.length) {
+    entry.state.pendingTypingInteractionIds = mergePendingInteractionIds(
+      entry.state.pendingTypingInteractionIds, msg.interactionIds,
+    );
+    entry.state.typingIdsAwaitingFeed = true;
+    // WP-4 (R-7): remember each pending id's OWN inputSeq here, so emitSettled can tell "the
+    // offered frame did not yet contain this key's echo" apart from "worker->main delivery or
+    // main-thread queueing" (the (i)/(ii) split design r3 §1.4 says today's stamps cannot make).
+    // Earliest seq wins for an id seen twice; the Math.max(0, ...) normalization is the same one
+    // headless-term-service.js's 'note-input' handler applies to msg.inputSeq.
+    const inputSeq = Math.max(0, Number(msg.inputSeq) || 0);
+    const seqById = entry.state.pendingTypingInputSeqById instanceof Map
+      ? entry.state.pendingTypingInputSeqById
+      : new Map();
+    for (const rawId of msg.interactionIds) {
+      const id = String(rawId);
+      if (!seqById.has(id) || inputSeq < seqById.get(id)) seqById.set(id, inputSeq);
+    }
+    entry.state.pendingTypingInputSeqById = prunePendingInputSeqs(
+      seqById, entry.state.pendingTypingInteractionIds,
+    );
+  }
+  const echo = msg.echo;
+  if (!echo || !echo.interactionId || typeof echo.char !== 'string' || !echo.char) return;
+  const buf = entry.term?.buffer?.active;
+  if (!buf) return;
+  if (!Array.isArray(entry.state.echoPredictions)) entry.state.echoPredictions = [];
+  const predictions = entry.state.echoPredictions;
+  predictions.push({
+    interactionId: String(echo.interactionId),
+    char: echo.char,
+    row: buf.baseY + buf.cursorY,
+    col: buf.cursorX,
+    bufferType: buf.type,
+    armedAt: Date.now(),
+    bytes: false,
+    cell: false,
+  });
+  // D-C2 bound: never more than 24 pending, oldest dropped first.
+  while (predictions.length > ECHO_PREDICTION_CAP) predictions.shift();
+  return predictions;
+}
+
+// D-C2, called once per applied NON-seed feed (headless-term-service.js's feed onApplied).
+// Each matcher stamps AT MOST ONCE per prediction, for that prediction's single id only --
+// never the session's whole pending set (that is the R1/R2 misattribution this shadows).
+function matchEchoPredictions(postTransport, sessionId, entry, data, now = Date.now()) {
+  const predictions = entry?.state?.echoPredictions;
+  if (!Array.isArray(predictions) || !predictions.length) return;
+  const text = stripEscapeSequences(data);
+  const buf = entry.term?.buffer?.active;
+  const kept = [];
+  for (const prediction of predictions) {
+    if (!prediction.bytes && prediction.char && text.includes(prediction.char)) {
+      prediction.bytes = true;
+      noteWorkerTypingStage(postTransport, sessionId, [prediction.interactionId], 'echo-bytes');
+    }
+    if (!prediction.cell && buf && buf.type === prediction.bufferType) {
+      const line = buf.getLine(prediction.row);
+      if (line?.getCell(prediction.col)?.getChars() === prediction.char) {
+        prediction.cell = true;
+        noteWorkerTypingStage(postTransport, sessionId, [prediction.interactionId], 'echo-cell');
+      }
+    }
+    // D-C2: drop when both matchers hit, or past the 10 s window.
+    if (prediction.bytes && prediction.cell) continue;
+    if (now - prediction.armedAt > ECHO_PREDICTION_TTL_MS) continue;
+    kept.push(prediction);
+  }
+  entry.state.echoPredictions = kept;
+}
+
+// WP-4 (R-7), called from headless-term-service.js's emitSettled ONLY after
+// _stateSyncEmitter.onMirrorUpdated returned `sent` -- the frame that just shipped is the first
+// one that could carry these keys' echoes, so stamp `frame-posted` for exactly the pending ids
+// the frame's `echoedThroughSeq` already covers (recorded inputSeq >= 1 AND <= offeredEchoSeq).
+// An id with NO recorded seq is treated as echoed, which preserves the pre-WP-4 blanket clear.
+// Returns the ids that remain un-echoed (recorded seq > offeredEchoSeq) so the caller can keep
+// only those pending -- that is what makes `emit-offered -> frame-posted` readable as "the
+// offered frame DID contain this key's echo" versus "the frame lacked it" instead of collapsing
+// both into one delivery gap.
+function noteFramePostedForEchoed(postTransport, sessionId, entry, offeredEchoSeq) {
+  const pending = Array.isArray(entry?.state?.pendingTypingInteractionIds)
+    ? entry.state.pendingTypingInteractionIds
+    : [];
+  const seqById = entry?.state?.pendingTypingInputSeqById;
+  const covering = Math.max(0, Number(offeredEchoSeq) || 0);
+  const echoedIds = [];
+  const remaining = [];
+  for (const rawId of pending) {
+    const id = String(rawId);
+    const seq = seqById instanceof Map && seqById.has(id) ? Number(seqById.get(id)) : 0;
+    if (seq > covering) remaining.push(id);
+    else echoedIds.push(id);
+  }
+  noteWorkerTypingStage(postTransport, sessionId, echoedIds, 'frame-posted', { offeredEchoSeq: covering });
+  // The echoed ids are delivered; only the un-echoed ones stay pending (and keep their seq).
+  if (seqById instanceof Map) {
+    for (const id of echoedIds) seqById.delete(id);
+  }
+  return remaining;
+}
+
+module.exports = {
+  mergePendingInteractionIds,
+  noteWorkerTypingStage,
+  noteFramePostedForEchoed,
+  PENDING_IDS_LIMIT,
+  isSingleGraphemeEcho,
+  armEchoPrediction,
+  matchEchoPredictions,
+  ECHO_PREDICTION_CAP,
+};

package/template/coding-task-manager/lib/usage-ledger/claude-parse.js

@@ -267,6 +267,37 @@ function createClaudeFileParser({ sessionId, agentId = '', state = null } = {})
   // it just emitted (the store's primary key dedups across passes as well).
   const seenAliases = new Set();
 
+  // The vendor ids of the rows THIS slice saw (WP-3, design §5 D-8). A re-read from 0 no
+  // longer deletes the file's prior facts up front (D-7); instead the store sweeps, at EOF,
+  // only the prior facts whose vendor id the new reading OBSERVED and no longer re-emits.
+  // So this is the evidence half of that rule: every id that proves a source row is still
+  // in the file, whether or not this reading turned it into a fact.
+  //
+  //   * responses -- the provider message id of every assistant record (with or without
+  //     usage: a record the reading no longer admits is exactly one whose call must go);
+  //   * prompts   -- the id of every row the parser ACCEPTS as a prompt row, and only
+  //     those rows. Later rows of the same turn (a tool_result `user` row, for instance)
+  //     carry the same promptId, so collecting the id off every record would "observe" a
+  //     prompt whose OWN row the vendor cut -- and the sweep would then delete the prompt
+  //     fact and its aliases. Observation happens in the prompt-recording path alone;
+  //   * toolUses  -- every tool_use block id, which is the vendor id of a spawn, an edge
+  //     and an attempt alike.
+  //
+  // De-duplicated within the slice (a Set), and NOT persisted in the checkpoint: it
+  // describes one slice's reading, never a resume position.
+  const observedResponses = new Set();
+  const observedPrompts = new Set();
+  const observedToolUses = new Set();
+
+  function observeToolUses(content) {
+    if (!Array.isArray(content)) return;
+    for (const block of content) {
+      if (!block || block.type !== 'tool_use') continue;
+      if (typeof block.id !== 'string' || block.id === '') continue;
+      observedToolUses.add(block.id);
+    }
+  }
+
   function recordCall(row) {
     const existing = indexByKey.get(row.call_key);
     if (existing === undefined) {
@@ -315,11 +346,14 @@ function createClaudeFileParser({ sessionId, agentId = '', state = null } = {})
     if (record.type === 'assistant') {
       const message = record.message;
       const usage = message && message.usage;
+      const responseId = responseIdOf(message);
+      if (responseId !== '') observedResponses.add(responseId);
+      observeToolUses(message && message.content);
       // Admission: a usage object and a nonempty response id. A requestId is NOT required (it
       // is absent in every one of the six historical glm-5-3 transcripts, which is what the
       // old rule discarded), and no prefix is required on the id.
       if (usage && typeof usage === 'object'
-          && responseIdOf(message) !== ''
+          && responseId !== ''
           && nonEmptyText(message.model) !== '<synthetic>') {
         const promptId = agentId === '' ? persisted.current_prompt_id : null;
         recordCall(callRowFor(record, offset, { sessionId, agentId, promptId }));
@@ -440,6 +474,10 @@ function createClaudeFileParser({ sessionId, agentId = '', state = null } = {})
     // other silently.
     const promptId = nonEmptyText(entry.promptId) || nonEmptyText(entry.uuid);
     if (!promptId) return;
+    // The row is accepted as a prompt, so its id proves THIS record's own row is present
+    // (WP-3 D-8). Recorded here, and nowhere else: an id carried by a later row of the same
+    // turn would observe a prompt whose own row the vendor removed.
+    observedPrompts.add(promptId);
     const digest = providerMessageDigestFor(nonEmptyText(entry.uuid)) || null;
     // Every persisted prompt row is where attribution goes next -- a human task, or the
     // `/clear` / `/compact` boundary that broke the previous turn. A boundary therefore gets
@@ -478,7 +516,17 @@ function createClaudeFileParser({ sessionId, agentId = '', state = null } = {})
   }
 
   function drain() {
-    const out = { calls, prompts, aliases, spawns, delegations, attempts, reported, state: persisted };
+    const out = {
+      calls, prompts, aliases, spawns, delegations, attempts, reported,
+      // The ids this slice observed (WP-3 D-8). Never persisted: they describe one slice's
+      // reading, and the store clears its own copy of them at EOF.
+      observed: {
+        responses: [...observedResponses],
+        prompts: [...observedPrompts],
+        toolUses: [...observedToolUses],
+      },
+      state: persisted,
+    };
     calls = [];
     prompts = [];
     aliases = [];
@@ -489,6 +537,9 @@ function createClaudeFileParser({ sessionId, agentId = '', state = null } = {})
     indexByKey.clear();
     seenAliases.clear();
     seenPrompts.clear();
+    observedResponses.clear();
+    observedPrompts.clear();
+    observedToolUses.clear();
     return out;
   }
 

package/template/coding-task-manager/lib/usage-ledger/ingest.js

@@ -205,10 +205,13 @@ function createUsageIngestor({ store, sliceBytes = DEFAULT_SLICE_BYTES, pricer =
     let firstBatch = true;
     let done = false;
     let remaining = maxBytes;
-    // WP-8b: when a file RESETS to offset 0 (its checkpoint was discarded by a
-    // parser_version or head change) the store must first delete the facts this file
-    // wrote under the old reading, else stale rows double-count. The flag rides the
-    // first slice only: a brand-new file (no row) never resets, and the re-read's later
+    // WP-8b/WP-3: when a file RESETS to offset 0 (its checkpoint was discarded by a
+    // parser_version or head change) the store must reconcile the facts this file wrote
+    // under the old reading. For a CODEX file that stays today's eager delete (WP-8b). For
+    // a CLAUDE file it is a SNAPSHOT instead (WP-3 D-7): the vendor rewrites a compacted
+    // transcript, so the new reading sees fewer rows than the reading that wrote those
+    // facts, and deleting them would destroy usage nothing can re-create. The flag rides
+    // the first slice only: a brand-new file (no row) never resets, and the re-read's later
     // slices append to the facts the first slice just re-created.
     const resetOnFirstBatch = !!row && offset === 0;
 
@@ -257,6 +260,12 @@ function createUsageIngestor({ store, sliceBytes = DEFAULT_SLICE_BYTES, pricer =
           reported: out.reported,
           checkpoint,
           reset: firstBatch && resetOnFirstBatch,
+          // The ids this slice OBSERVED (WP-3 D-8) and whether this slice reached EOF. The
+          // store uses them only for a Claude file: a prior fact whose vendor id was seen
+          // but which the new reading no longer emits is swept at EOF, while one whose row
+          // the vendor deleted is kept. Both are ignored for Codex (D-10).
+          observed: out.observed || null,
+          final: checkpoint.status === 'current',
           price,
         });
         calls += upserted.callsWritten;

package/template/coding-task-manager/lib/usage-ledger/read.js

@@ -506,6 +506,11 @@ function resolveScope(coreDb, ctmSessionId) {
       delegatedCtmSessions.push(childId);
       workers.push({
         ctm_session_id: childId,
+        // WP-2: the CTM session whose OWN turn launched this worker -- the BFS node whose children are
+        // being read. The launch-time fallback (task-read.js) may only charge a worker to the scope
+        // ROOT's canonical turns, so a worker launched by another worker (a nested delegation) is
+        // excluded by comparing this field against the scope's own CTM session id.
+        parent_ctm_session_id: String(current.ctmId),
         generation: Number.isInteger(child.generation) && child.generation >= 1 ? child.generation : null,
         generation_ends_ms: generationEndsMs(child.generation, child.runtime_json),
         launches: workerLaunches(child, childId),
@@ -708,6 +713,10 @@ function availabilityOf(ledgerDb) {
     // v5: the native local turn of a prompt, beside its event-derived identity. A ledger
     // written before the column reads it as an explicit UNAVAILABLE fact, never a throw.
     prompt_native_turn_id: prompts.has('native_turn_id'),
+    // D-3 (WP-1): whether a prompt row still carries its SOURCE file. A prompt written before the
+    // column existed reads as an explicit `source_less` fact on the page; the raw file id itself is
+    // internal plumbing and never crosses this boundary.
+    prompt_source_file: prompts.has('source_file_id'),
     prompt_aliases: hasAll(aliases, ['prompt_id', 'provider_message_digest']),
     revision: tableColumns(ledgerDb, 'usage_ledger_meta').has('value'),
   };
@@ -986,6 +995,7 @@ function readLedgerSession(ledgerDb, scope, options = {}) {
     if (available.source_event_digest) promptColumns.push('source_event_digest');
     if (available.prompt_content_fingerprint) promptColumns.push('content_fingerprint');
     if (available.prompt_native_turn_id) promptColumns.push('native_turn_id');
+    if (available.prompt_source_file) promptColumns.push('source_file_id');
     const promptSizeColumns = available.prompt_metadata
       ? ", CASE WHEN text IS NULL THEN 0 ELSE length(CAST(text AS BLOB)) END AS text_bytes, CASE WHEN text IS NULL THEN 0 ELSE length(text) END AS text_chars"
       : ', 0 AS text_bytes, 0 AS text_chars';
@@ -1106,6 +1116,10 @@ function readLedgerSession(ledgerDb, scope, options = {}) {
         source_event_digest: available.source_event_digest ? row.source_event_digest ?? null : null,
         content_fingerprint: available.prompt_content_fingerprint ? row.content_fingerprint ?? null : null,
         native_turn_id: available.prompt_native_turn_id ? row.native_turn_id ?? null : null,
+        // D-3: `true` only when the column EXISTS and the row's value is NULL. Without the column
+        // the read cannot prove the prompt is sourceless, so it reports `false` ("cannot prove") and
+        // the prompt is never matched by time.
+        source_less: available.prompt_source_file ? row.source_file_id == null : false,
         kind: available.prompt_metadata ? (row.kind ?? null) : null,
         text: fetched ? overviewTextFor.get(key) : null,
         text_truncated: available.prompt_metadata ? row.text_truncated === 1 || row.text_truncated === true : null,

package/template/coding-task-manager/lib/usage-ledger/schema.js

@@ -15,7 +15,7 @@
 
 const { createMigrationRunner, pragmaVersionStore } = require('../../../shared/db-migration-runner');
 
-const USAGE_LEDGER_SCHEMA_VERSION = 7;
+const USAGE_LEDGER_SCHEMA_VERSION = 8;
 
 // The complete v1 schema, in one place. Each statement is idempotent
 // (IF NOT EXISTS) so a re-run of the baseline against a partially-created file
@@ -302,6 +302,52 @@ function createV7(db) {
   `);
 }
 
+// v8 (usage-vendor-rewrite WP-3, design §5 D-7/D-8): the non-destructive re-read scratch
+// state for CLAUDE files. Claude Code rewrites a large transcript after compaction -- it
+// removes every row before the last compact boundary and renames a new file over the old
+// path -- so a re-read from 0 sees FEWER rows than the reading that wrote the ledger's
+// facts. Until this version the reset deleted the file's facts up front, which destroyed
+// real, already-recorded usage (the measured incident: 4.5 days of one lead session's calls
+// and every launch receipt). The two tables here make the re-read a snapshot refresh
+// instead of a retraction (D-7) while keeping today's safety for a fact whose row IS still
+// present but which the new reading no longer emits (D-8):
+//
+//   * usage_reread_prior -- the keys of the file's prior facts, snapshotted on the first
+//     slice of a re-read instead of deleting them. `fact_key` is the JSON array of the
+//     fact's primary-key values in PK column order, so it is comparable as text and
+//     rebuildable in SQL (json_array) and in JS (JSON.stringify) identically. `vendor_id`
+//     is the provider id a fact can be matched against what the new reading OBSERVED;
+//     NULL means the identity is an older form nothing can match (swept at EOF, which is
+//     exactly today's behaviour for a stale key).
+//   * usage_reread_seen -- the vendor ids the re-read actually SAW, in three kinds:
+//     'response' (an assistant message.id), 'prompt' (the id of a row the parser accepted as a
+//     prompt row -- never a later row of the same turn, which carries the same promptId) and
+//     'tool_use' (a tool_use block id).
+//
+// Both are per-file scratch: they are cleared for the file in the same transaction as the
+// slice that reaches EOF. They are bounded by that file's own fact count. Codex files never
+// write here -- they keep the eager reset delete (D-10).
+//
+// It is a pure CREATE TABLE step (no data rewrite), so the migration is inherently re-run
+// safe and idempotent.
+function createV8(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS usage_reread_prior (
+      file_id INTEGER NOT NULL,
+      kind TEXT NOT NULL CHECK(kind IN ('call','prompt','alias','spawn','delegation','attempt')),
+      fact_key TEXT NOT NULL,     -- JSON array of the fact's primary-key values, in PK column order
+      vendor_id TEXT,             -- NULL = not derivable (older identity form) -> swept at EOF
+      PRIMARY KEY(file_id, kind, fact_key)
+    ) WITHOUT ROWID;
+    CREATE TABLE IF NOT EXISTS usage_reread_seen (
+      file_id INTEGER NOT NULL,
+      kind TEXT NOT NULL CHECK(kind IN ('response','prompt','tool_use')),
+      vendor_id TEXT NOT NULL,
+      PRIMARY KEY(file_id, kind, vendor_id)
+    ) WITHOUT ROWID;
+  `);
+}
+
 // Built lazily on first use so merely requiring this module has no side effects
 // (no module-level runner construction, no DDL, no env reads).
 let _runner = null;
@@ -323,6 +369,7 @@ function runner() {
         5: { up: createV5, label: 'v5 prompt native turn id' },
         6: { up: createV6, label: 'v6 delegation edges' },
         7: { up: createV7, label: 'v7 delegation launch attempts' },
+        8: { up: createV8, label: 'v8 claude re-read snapshot' },
       },
       baseline: (db) => {
         createV1(db);
@@ -332,6 +379,7 @@ function runner() {
         createV5(db);
         createV6(db);
         createV7(db);
+        createV8(db);
       },
       versionStore: pragmaVersionStore(),
     });