session-steward 0.6.0 → 0.8.0

package/lib/providers/claude-code/tokens.mjs

@@ -0,0 +1,174 @@
+import { addTokenTotals, createTokenTotals, summarizeSessionTokens } from "../../session-tokens.mjs";
+import { readCachedTokens, readFileStamp, writeCachedTokens } from "../../session-token-cache.mjs";
+import { visitJsonlSnapshotEntries } from "../../storage/jsonl.mjs";
+import { getSessionRecord } from "./store.mjs";
+
+const SYNTHETIC_MODEL = "<synthetic>";
+
+// Claude Code reports usage per request rather than as a running total, so there
+// is no counter to reconcile. The catch is the opposite one: a single response is
+// written as several records, one per content block, and every copy repeats the
+// same usage in full. Summing records instead of requests inflates a session by
+// roughly 2.3x.
+function readCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
+
+// Anthropic reports cached tokens *beside* the input count, where Codex reports
+// them inside it. `input_tokens` is already the uncached remainder, so nothing is
+// subtracted here — doing so is what would drive the fresh-input slice negative.
+function normalizeUsage(value) {
+  if (!value || typeof value !== "object") return null;
+
+  const cachedInput = readCount(value.cache_read_input_tokens);
+  const cacheWrites = readCount(value.cache_creation_input_tokens);
+  const freshInput = readCount(value.input_tokens);
+  const output = readCount(value.output_tokens);
+
+  return {
+    cachedInput,
+    cacheWrites,
+    freshInput,
+    output,
+    // Claude Code does not report a reasoning figure; thinking is billed as
+    // ordinary output and cannot be separated from it.
+    reasoning: 0,
+    total: cachedInput + cacheWrites + freshInput + output,
+  };
+}
+
+export function createClaudeTokenCollector() {
+  // One entry per request, not per record. Repeats collapse onto the largest
+  // copy: a retried or superseded write reports zeros, and a streaming partial
+  // reports less than the finished response.
+  const requests = new Map();
+  let compactions = 0;
+  let observedRecords = 0;
+  let sessionId = null;
+  let sidechainRequests = 0;
+  let syntheticRecords = 0;
+
+  return {
+    record(recordValue) {
+      if (!recordValue || typeof recordValue !== "object") return;
+
+      if (recordValue.subtype === "compact_boundary") compactions += 1;
+      if (sessionId === null && typeof recordValue.sessionId === "string") {
+        sessionId = recordValue.sessionId;
+      }
+
+      const message = recordValue.message;
+      if (!message || typeof message !== "object") return;
+
+      const usage = normalizeUsage(message.usage);
+      if (!usage) return;
+      observedRecords += 1;
+
+      // Synthetic entries stand in for locally generated messages. They carry no
+      // usage and no request id, and would otherwise open a model row of zeros.
+      if (message.model === SYNTHETIC_MODEL) {
+        syntheticRecords += 1;
+        return;
+      }
+
+      const key = recordValue.requestId ?? message.id;
+      if (typeof key !== "string") return;
+
+      const previous = requests.get(key);
+      if (previous && previous.usage.total >= usage.total) return;
+      if (!previous && recordValue.isSidechain) sidechainRequests += 1;
+
+      requests.set(key, { model: message.model ?? "Unknown", sidechain: Boolean(recordValue.isSidechain), usage });
+    },
+
+    result() {
+      const totals = createTokenTotals();
+      const modelTotals = new Map();
+
+      for (const { model, usage } of requests.values()) {
+        addTokenTotals(totals, usage);
+        if (!modelTotals.has(model)) modelTotals.set(model, createTokenTotals());
+        addTokenTotals(modelTotals.get(model), usage);
+      }
+
+      return {
+        available: requests.size > 0,
+        byModel: [...modelTotals]
+          .map(([model, modelSpend]) => ({ model, totals: modelSpend }))
+          .sort((left, right) => right.totals.total - left.totals.total),
+        cacheWriteUnderflow: false,
+        compactions,
+        countedRequests: requests.size,
+        observedRecords,
+        sessionId,
+        sidechainRequests,
+        syntheticRecords,
+        totals,
+      };
+    },
+  };
+}
+
+export async function collectClaudeSessionTokens(filePath, { maxLineBytes, signal } = {}) {
+  const collector = createClaudeTokenCollector();
+  const { complete, snapshotBytes } = await visitJsonlSnapshotEntries(
+    filePath,
+    ({ parsed }) => {
+      // A closed panel should not leave a large transcript being scanned.
+      if (signal?.aborted) return false;
+      if (parsed && typeof parsed === "object") collector.record(parsed);
+      return true;
+    },
+    maxLineBytes === undefined ? {} : { maxLineBytes },
+  );
+
+  return { ...collector.result(), complete, snapshotBytes };
+}
+
+// Reading the timeline already streams every record of the same file, so the
+// count rides along with that pass instead of paying for a second one.
+export async function createSessionTokenScan({ record, signal }) {
+  if (!record?.rolloutPath) return null;
+  const stamp = await readFileStamp(record.rolloutPath);
+  const cached = readCachedTokens("summary", record.rolloutPath, stamp);
+  if (cached !== undefined) return { cached, record() {}, summarize: () => cached };
+
+  const collector = createClaudeTokenCollector();
+
+  return {
+    cached: null,
+    record(value) {
+      collector.record(value);
+    },
+    summarize({ complete }) {
+      const summary = summarizeSessionTokens({ ...collector.result(), complete });
+      if (signal?.aborted || complete === false) return summary;
+      return writeCachedTokens("summary", record.rolloutPath, stamp, summary);
+    },
+  };
+}
+
+export async function readSessionTokens({ claudeHome, desktopDataHome, id, maxLineBytes, signal }) {
+  const record = await getSessionRecord({ claudeHome, desktopDataHome, id });
+  if (!record) return null;
+  if (!record.rolloutPath) return { available: false, reason: "no-transcript-path" };
+
+  const stamp = await readFileStamp(record.rolloutPath);
+  const cached = readCachedTokens("summary", record.rolloutPath, stamp);
+  if (cached !== undefined) return cached;
+
+  let collected;
+  try {
+    collected = await collectClaudeSessionTokens(record.rolloutPath, { maxLineBytes, signal });
+  } catch (error) {
+    // A transcript can be deleted between the listing and the read. That is an
+    // answer about the session, not a failure of the server, and the timeline
+    // reader already treats it as one.
+    if (error?.code === "ENOENT") return { available: false, reason: "transcript-missing" };
+    throw error;
+  }
+
+  const summary = summarizeSessionTokens(collected);
+  if (signal?.aborted || collected.complete === false) return summary;
+  return writeCachedTokens("summary", record.rolloutPath, stamp, summary);
+}

package/lib/providers/codex/database-families.mjs

@@ -8,8 +8,8 @@ const CACHE_TTL_MS = 2_000;
 export const CODEX_DATABASE_PROFILE = Object.freeze({
   id: "codex-local-store-2026-08",
   builtFor: {
-    chatgptDesktop: ["26.727.40816", "26.803.61601"],
-    codexCli: ["0.144.1", "0.146.0", "0.147.0"],
+    chatgptDesktop: ["26.727.40816", "26.803.61601", "26.818.21641", "26.818.22352"],
+    codexCli: ["0.144.1", "0.146.0", "0.147.0", "0.148.0"],
   },
 });
 
@@ -41,6 +41,22 @@ const SCHEMA_REQUIREMENTS = Object.freeze({
       { name: "thread_goal_continuation_deferrals", requiredColumns: ["thread_id"] },
     ],
   },
+  queue: {
+    fallback: "queue_1.sqlite",
+    pattern: /^queue_(\d+)\.sqlite$/u,
+    required: false,
+    tables: [{ name: "queued_items", requiredColumns: ["thread_id"] }],
+  },
+  threadHistory: {
+    fallback: "thread_history_1.sqlite",
+    pattern: /^thread_history_(\d+)\.sqlite$/u,
+    required: false,
+    tables: [
+      { name: "thread_items", requiredColumns: ["thread_id"] },
+      { name: "thread_turns", requiredColumns: ["thread_id"] },
+      { name: "thread_history_projection_state", requiredColumns: ["thread_id"] },
+    ],
+  },
 });
 
 const resolutionCache = new Map();

package/lib/providers/codex/events.mjs

@@ -1,9 +1,13 @@
 import {
   createSessionEvent,
+  createSessionEventComposition,
   createSessionEventCoverage,
   createSessionEventHeader,
+  createSessionEventSummary,
   createSessionEventsResult,
+  finalizeSessionEventComposition,
   SESSION_EVENT_KIND,
+  SESSION_EVENT_READ_MODE,
   SESSION_EVENT_REASON,
 } from "../../session-events.mjs";
 import {
@@ -13,6 +17,7 @@ import {
 } from "../../session-event-reader.mjs";
 import { visitJsonlSnapshotEntries } from "../../storage/jsonl.mjs";
 import { getSessionRecord, loadSessionStore } from "./store.mjs";
+import { createSessionTokenScan } from "./tokens.mjs";
 
 const PROVIDER_ID = "codex";
 const RECORD_CLASSIFICATION = Object.freeze({
@@ -53,6 +58,30 @@ function createDuplicateTextTracker() {
   };
 }
 
+const COMPOSITION_TOOL_OUTPUT = new Set([
+  "custom_tool_call_output",
+  "exec_command_end",
+  "function_call_output",
+  "mcp_tool_call_end",
+  "web_search_end",
+]);
+const COMPOSITION_MESSAGES = new Set(["agent_message", "message", "user_message"]);
+const COMPOSITION_EDITS = new Set(["patch_apply_begin", "patch_apply_end"]);
+const COMPOSITION_REASONING = new Set(["agent_reasoning", "reasoning"]);
+
+function compositionSegment(parsed) {
+  const type = typeof parsed?.type === "string" ? parsed.type : "";
+  const payloadType = typeof parsed?.payload?.type === "string" ? parsed.payload.type : type;
+  if (type === "compacted" || payloadType === "compacted" || payloadType === "context_compacted") {
+    return "compaction";
+  }
+  if (COMPOSITION_TOOL_OUTPUT.has(payloadType)) return "toolOutput";
+  if (COMPOSITION_EDITS.has(payloadType)) return "edits";
+  if (COMPOSITION_REASONING.has(payloadType)) return "reasoning";
+  if (COMPOSITION_MESSAGES.has(payloadType)) return "messages";
+  return "other";
+}
+
 function asTimestamp(value) {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value !== "string") return null;
@@ -298,12 +327,15 @@ function outputText(payload) {
   return contentText(payload.output ?? payload.content ?? payload.stderr ?? payload.stdout).trim() || null;
 }
 
-function emptyResult({ cwd = null, origin = null, reason }) {
+function emptyResult({ counted = false, cwd = null, origin = null, reason }) {
   return createSessionEventsResult({
     coverage: createSessionEventCoverage(),
     events: [],
     header: createSessionEventHeader({ cwd, origin, provider: PROVIDER_ID }),
     reason,
+    // The reason the timeline is empty is the same reason there is no count:
+    // no transcript to read. Saying so beats leaving the field to guess.
+    tokens: counted ? { available: false, reason } : null,
     window: {
       complete: true,
       end: null,
@@ -325,6 +357,7 @@ export async function readSessionEvents({
   maxLineBytes,
   mode,
   signal,
+  tokens = false,
 }) {
   const record = await findSessionRecord({ codexHome, id });
   if (!record) return null;
@@ -332,13 +365,22 @@ export async function readSessionEvents({
   const origin = record.recordSource ?? null;
   if (!record.rolloutPath) {
     return emptyResult({
+      counted: tokens,
       cwd: record.cwd || null,
       origin,
       reason: SESSION_EVENT_REASON.NO_TRANSCRIPT_PATH,
     });
   }
 
+  // A preview stops as soon as it has enough events, so a count taken from it
+  // would be of part of the file while reading as the whole.
+  const tokenScan = tokens && mode !== SESSION_EVENT_READ_MODE.PREVIEW
+    ? await createSessionTokenScan({ codexHome, maxLineBytes, record, signal })
+    : null;
+
   const coverage = createSessionEventCoverage();
+  const summary = createSessionEventSummary();
+  const composition = createSessionEventComposition();
   const readState = createSessionEventReadState({ limit, mode });
   const unmappedTypes = createUnmappedSessionEventTracker();
   const duplicateTexts = createDuplicateTextTracker();
@@ -350,6 +392,9 @@ export async function readSessionEvents({
   });
 
   function addEvent(event, pendingId = null) {
+    if (event.kind === SESSION_EVENT_KIND.ASK && !event.injected) summary.asks += 1;
+    if (event.kind === SESSION_EVENT_KIND.EDIT) summary.edits += 1;
+    if (event.kind === SESSION_EVENT_KIND.RAN) summary.commands += 1;
     return readState.add(event, { pendingId });
   }
 
@@ -735,14 +780,18 @@ export async function readSessionEvents({
 
         if (entry.oversized) {
           coverage.oversized += 1;
+          composition.largeRecords += entry.bytes;
           return true;
         }
 
         if (!entry.parsed || typeof entry.parsed !== "object") {
           coverage.unparseable += 1;
+          composition.other += entry.bytes;
           return true;
         }
 
+        composition[compositionSegment(entry.parsed)] += entry.bytes;
+        tokenScan?.record(entry.parsed);
         const result = handleRecord(entry.parsed, entry.index);
         coverage[result.classification] += 1;
         if (result.duplicate) coverage.duplicates += 1;
@@ -756,6 +805,7 @@ export async function readSessionEvents({
   } catch (error) {
     if (error?.code === "ENOENT") {
       return emptyResult({
+        counted: tokens,
         cwd: record.cwd || null,
         origin,
         reason: SESSION_EVENT_REASON.TRANSCRIPT_MISSING,
@@ -774,6 +824,9 @@ export async function readSessionEvents({
     reason: events.length === 0 && read.complete
       ? SESSION_EVENT_REASON.NO_RECOGNIZED_EVENTS
       : null,
+    composition: finalizeSessionEventComposition(composition, read.snapshotBytes),
+    summary,
+    tokens: tokenScan ? tokenScan.summarize(read) : null,
     window: readState.window(read),
   });
 }

package/lib/providers/codex/index.mjs

@@ -1,4 +1,5 @@
 import { readSessionEvents } from "./events.mjs";
+import { readSessionTokens } from "./tokens.mjs";
 import {
   assertDeepCleanupSupported,
   diagnoseStorageCompatibility,
@@ -40,6 +41,7 @@ export const codexProvider = Object.freeze({
   planSessionDeletion,
   preflightSessionDeletion,
   readSessionEvents,
+  readSessionTokens,
   restoreSessionDeletionBackup,
   verifySessionDeletion,
 });

package/lib/providers/codex/store.mjs

@@ -440,11 +440,13 @@ export function getCodexPaths(codexHomeInput, { refresh = false } = {}) {
   const archivedSessionsDirectory = path.join(codexHome, "archived_sessions");
   const sessionsDirectory = path.join(codexHome, "sessions");
   const resolution = resolveCodexDatabases(codexHome, { refresh });
-  const { goals, logs, memories, state } = resolution.families;
+  const { goals, logs, memories, queue, state, threadHistory } = resolution.families;
   const stateDatabasePath = state.primary?.path ?? path.join(codexHome, "state_5.sqlite");
   const logsDatabasePath = logs.primary?.path ?? path.join(codexHome, "logs_2.sqlite");
   const memoryDatabasePath = memories.primary?.path ?? path.join(codexHome, "memories_1.sqlite");
   const goalsDatabasePath = goals.primary?.path ?? path.join(codexHome, "goals_1.sqlite");
+  const queueDatabasePath = queue.primary?.path ?? path.join(codexHome, "queue_1.sqlite");
+  const threadHistoryDatabasePath = threadHistory.primary?.path ?? path.join(codexHome, "thread_history_1.sqlite");
 
   return {
     archivedSessionsDirectory,
@@ -460,6 +462,8 @@ export function getCodexPaths(codexHomeInput, { refresh = false } = {}) {
     logsDatabasePaths: allValidDatabases(logs).map((database) => database.path),
     memoryDatabasePath,
     memoryDatabasePaths: allValidDatabases(memories).map((database) => database.path),
+    queueDatabasePath,
+    queueDatabasePaths: allValidDatabases(queue).map((database) => database.path),
     resolvedDatabases: databaseFamilySummary(resolution),
     sessionIndexPath: path.join(codexHome, "session_index.jsonl"),
     sessionsDirectory,
@@ -467,6 +471,8 @@ export function getCodexPaths(codexHomeInput, { refresh = false } = {}) {
     stateDatabases: allValidDatabases(state),
     stateDatabasePaths: allValidDatabases(state).map((database) => database.path),
     threadWriterLocksDirectory: path.join(codexHome, "thread-writer-locks"),
+    threadHistoryDatabasePath,
+    threadHistoryDatabasePaths: allValidDatabases(threadHistory).map((database) => database.path),
     transcriptDirectories: [sessionsDirectory, archivedSessionsDirectory],
   };
 }
@@ -569,12 +575,16 @@ export async function loadSessionStore({ codexHome }) {
     hasGoalsDatabase,
     hasLogsDatabase,
     hasMemoryDatabase,
+    hasQueueDatabase,
+    hasThreadHistoryDatabase,
   ] = await Promise.all([
     pathExists(paths.desktopStatePath),
     pathExists(paths.desktopStateBackupPath),
     pathExists(paths.goalsDatabasePath),
     pathExists(paths.logsDatabasePath),
     pathExists(paths.memoryDatabasePath),
+    pathExists(paths.queueDatabasePath),
+    pathExists(paths.threadHistoryDatabasePath),
   ]);
   const threadRowsById = new Map();
   const spawnEdgesByKey = new Map();
@@ -768,9 +778,12 @@ export async function loadSessionStore({ codexHome }) {
     hasGoalsDatabase,
     hasLogsDatabase,
     hasMemoryDatabase,
+    hasQueueDatabase,
+    hasThreadHistoryDatabase,
     goalsDatabasePath: paths.goalsDatabasePath,
     logsDatabasePath: paths.logsDatabasePath,
     memoryDatabasePath: paths.memoryDatabasePath,
+    queueDatabasePath: paths.queueDatabasePath,
     records,
     recordsById: new Map(records.map((record) => [record.id, record])),
     sessionIndexPath: paths.sessionIndexPath,
@@ -782,6 +795,9 @@ export async function loadSessionStore({ codexHome }) {
     resolvedDatabases: paths.resolvedDatabases,
     logsDatabasePaths: paths.logsDatabasePaths,
     memoryDatabasePaths: paths.memoryDatabasePaths,
+    queueDatabasePaths: paths.queueDatabasePaths,
+    threadHistoryDatabasePath: paths.threadHistoryDatabasePath,
+    threadHistoryDatabasePaths: paths.threadHistoryDatabasePaths,
     goalsDatabasePaths: paths.goalsDatabasePaths,
     transcriptHeaders,
     historyPath: paths.historyPath,
@@ -1217,12 +1233,16 @@ async function getStoreAvailability(paths) {
     hasGoalsDatabase,
     hasLogsDatabase,
     hasMemoryDatabase,
+    hasQueueDatabase,
+    hasThreadHistoryDatabase,
   ] = await Promise.all([
     pathExists(paths.desktopStatePath),
     pathExists(paths.desktopStateBackupPath),
     Promise.resolve(paths.goalsDatabasePaths.length > 0),
     Promise.resolve(paths.logsDatabasePaths.length > 0),
     Promise.resolve(paths.memoryDatabasePaths.length > 0),
+    Promise.resolve(paths.queueDatabasePaths.length > 0),
+    Promise.resolve(paths.threadHistoryDatabasePaths.length > 0),
   ]);
 
   return {
@@ -1231,6 +1251,8 @@ async function getStoreAvailability(paths) {
     hasGoalsDatabase,
     hasLogsDatabase,
     hasMemoryDatabase,
+    hasQueueDatabase,
+    hasThreadHistoryDatabase,
   };
 }
 
@@ -1485,6 +1507,7 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
     historyPath: paths.historyPath,
     logsDatabasePath: paths.logsDatabasePath,
     memoryDatabasePath: paths.memoryDatabasePath,
+    queueDatabasePath: paths.queueDatabasePath,
     records,
     recordsById: new Map(records.map((record) => [record.id, record])),
     sessionIndexPath: paths.sessionIndexPath,
@@ -1495,6 +1518,9 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
     resolvedDatabases: paths.resolvedDatabases,
     logsDatabasePaths: paths.logsDatabasePaths,
     memoryDatabasePaths: paths.memoryDatabasePaths,
+    queueDatabasePaths: paths.queueDatabasePaths,
+    threadHistoryDatabasePath: paths.threadHistoryDatabasePath,
+    threadHistoryDatabasePaths: paths.threadHistoryDatabasePaths,
     goalsDatabasePaths: paths.goalsDatabasePaths,
     transcriptHeaders: new Map(
       [...transcriptHeaders].filter(([id]) => relevantIds.has(id)),
@@ -1954,6 +1980,19 @@ export async function planSessionDeletion({ recordIds, store }) {
     .reduce((total, databasePath) => total + countRowsForIds(databasePath, "stage1_outputs", "thread_id", deletionIds), 0);
   const goalRowCount = (store.goalsDatabasePaths ?? [store.goalsDatabasePath].filter(Boolean))
     .reduce((total, databasePath) => total + countRowsForIds(databasePath, "thread_goals", "thread_id", deletionIds), 0);
+  const queueRowCount = (store.queueDatabasePaths ?? [store.queueDatabasePath].filter(Boolean))
+    .reduce((total, databasePath) => total + countRowsForIds(databasePath, "queued_items", "thread_id", deletionIds), 0);
+  const queueRevisionRowCount = (store.queueDatabasePaths ?? [store.queueDatabasePath].filter(Boolean))
+    .reduce((total, databasePath) => total + (inspectSqliteTable(databasePath, "queued_thread_revisions").exists
+      ? countRowsForIds(databasePath, "queued_thread_revisions", "thread_id", deletionIds)
+      : 0), 0);
+  const threadHistoryRowCount = (store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath].filter(Boolean))
+    .reduce((total, databasePath) => total + [
+      "thread_items",
+      "thread_turns",
+      "thread_history_projection_state",
+    ].reduce((databaseTotal, tableName) =>
+      databaseTotal + countRowsForIds(databasePath, tableName, "thread_id", deletionIds), 0), 0);
   const stateTargets = (store.stateDatabases ?? [{ path: store.stateDatabasePath }]).map((database) => ({
     database,
     ids: findRowsForIds(database.path, "threads", "id", deletionIds).map((row) => String(row.id)),
@@ -1972,6 +2011,8 @@ export async function planSessionDeletion({ recordIds, store }) {
     ids: deletionIds,
     logRowCount,
     memoryRowCount,
+    queueRowCount,
+    queueRevisionRowCount,
     missingTranscriptPaths,
     newestLinkedActivityAtMs,
     records: selectedRecords,
@@ -1980,6 +2021,7 @@ export async function planSessionDeletion({ recordIds, store }) {
     stateTargets,
     transcriptBytes,
     transcriptFileCount,
+    threadHistoryRowCount,
     transcriptPaths,
   };
 }
@@ -1991,6 +2033,8 @@ function getBackupSourcePaths({ plan, scope, store }) {
   const databasePaths = [
     ...(store.stateDatabasePaths ?? [store.stateDatabasePath]),
     ...(store.logsDatabasePaths ?? [store.logsDatabasePath].filter(Boolean)),
+    ...(store.queueDatabasePaths ?? [store.queueDatabasePath].filter(Boolean)),
+    ...(store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath].filter(Boolean)),
     ...(scope === "deep" ? (store.memoryDatabasePaths ?? [store.memoryDatabasePath].filter(Boolean)) : []),
     ...(scope === "deep" ? (store.goalsDatabasePaths ?? [store.goalsDatabasePath].filter(Boolean)) : []),
   ].filter(Boolean);
@@ -2033,6 +2077,9 @@ export async function fingerprintSessionDeletion({ plan, scope, store }) {
     plan.dynamicToolRowCount,
     plan.historyMatchCount,
     plan.logRowCount,
+    plan.queueRowCount,
+    plan.queueRevisionRowCount,
+    plan.threadHistoryRowCount,
     plan.sessionIndexMatchCount,
     plan.spawnEdgeCount,
     ...(scope === "deep" ? [plan.goalRowCount, plan.memoryRowCount] : []),
@@ -2040,6 +2087,8 @@ export async function fingerprintSessionDeletion({ plan, scope, store }) {
   hash.update(`counts\0${counts.join("\0")}\0`);
   hash.update(`stores\0${[
     store.hasLogsDatabase,
+    store.hasQueueDatabase,
+    store.hasThreadHistoryDatabase,
     ...(scope === "deep" ? [
       store.hasDesktopState,
       store.hasDesktopStateBackup,
@@ -2079,6 +2128,17 @@ export async function fingerprintSessionDeletion({ plan, scope, store }) {
   for (const databasePath of store.logsDatabasePaths ?? [store.logsDatabasePath].filter(Boolean)) {
     fingerprintRowsForIds(hash, databasePath, "logs", "thread_id", plan.ids);
   }
+  for (const databasePath of store.queueDatabasePaths ?? [store.queueDatabasePath].filter(Boolean)) {
+    fingerprintRowsForIds(hash, databasePath, "queued_items", "thread_id", plan.ids);
+    if (inspectSqliteTable(databasePath, "queued_thread_revisions").exists) {
+      fingerprintRowsForIds(hash, databasePath, "queued_thread_revisions", "thread_id", plan.ids);
+    }
+  }
+  for (const databasePath of store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath].filter(Boolean)) {
+    fingerprintRowsForIds(hash, databasePath, "thread_items", "thread_id", plan.ids);
+    fingerprintRowsForIds(hash, databasePath, "thread_turns", "thread_id", plan.ids);
+    fingerprintRowsForIds(hash, databasePath, "thread_history_projection_state", "thread_id", plan.ids);
+  }
   if (scope === "deep") {
     for (const databasePath of store.memoryDatabasePaths ?? [store.memoryDatabasePath].filter(Boolean)) {
       fingerprintRowsForIds(hash, databasePath, "stage1_outputs", "thread_id", plan.ids);
@@ -2292,6 +2352,8 @@ async function createOperationBackup({ onProgress, plan, scope, store }) {
   const snapshotCandidates = [
     ...(store.stateDatabasePaths ?? [store.stateDatabasePath]).map((databasePath) => [databasePath, path.basename(databasePath), true]),
     ...(store.logsDatabasePaths ?? [store.logsDatabasePath].filter(Boolean)).map((databasePath) => [databasePath, path.basename(databasePath), true]),
+    ...(store.queueDatabasePaths ?? [store.queueDatabasePath].filter(Boolean)).map((databasePath) => [databasePath, path.basename(databasePath), true]),
+    ...(store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath].filter(Boolean)).map((databasePath) => [databasePath, path.basename(databasePath), true]),
     ...(scope === "deep" ? (store.memoryDatabasePaths ?? [store.memoryDatabasePath].filter(Boolean)) : []).map((databasePath) => [databasePath, path.basename(databasePath), true]),
     ...(scope === "deep" ? (store.goalsDatabasePaths ?? [store.goalsDatabasePath].filter(Boolean)) : []).map((databasePath) => [databasePath, path.basename(databasePath), true]),
   ];
@@ -2467,6 +2529,25 @@ export async function executeSessionDeletion({
         executeTransaction(databasePath, deleteStatements("logs", "thread_id", plan.ids));
       }
     }
+    if (store.hasQueueDatabase) {
+      for (const databasePath of store.queueDatabasePaths ?? [store.queueDatabasePath]) {
+        executeTransaction(databasePath, [
+          ...deleteStatements("queued_items", "thread_id", plan.ids),
+          ...(inspectSqliteTable(databasePath, "queued_thread_revisions").exists
+            ? deleteStatements("queued_thread_revisions", "thread_id", plan.ids)
+            : []),
+        ]);
+      }
+    }
+    if (store.hasThreadHistoryDatabase) {
+      for (const databasePath of store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath]) {
+        executeTransaction(databasePath, [
+          ...deleteStatements("thread_items", "thread_id", plan.ids),
+          ...deleteStatements("thread_turns", "thread_id", plan.ids),
+          ...deleteStatements("thread_history_projection_state", "thread_id", plan.ids),
+        ]);
+      }
+    }
     for (const { database, ids } of plan.stateTargets ?? (store.stateDatabases ?? [{ path: store.stateDatabasePath }]).map((database) => ({ database, ids: plan.ids }))) {
       const stateStatements = [];
       const schema = stateSchema(database);
@@ -2828,6 +2909,21 @@ export async function verifySessionDeletion({ plan, scope = "deep", store }) {
     ? (store.logsDatabasePaths ?? [store.logsDatabasePath]).flatMap((databasePath) =>
       findRowsForIds(databasePath, "logs", "thread_id", plan.ids, { limitOne: true }))
     : [];
+  const remainingQueueRecords = store.hasQueueDatabase
+    ? (store.queueDatabasePaths ?? [store.queueDatabasePath]).flatMap((databasePath) => [
+      ...findRowsForIds(databasePath, "queued_items", "thread_id", plan.ids, { limitOne: true }),
+      ...(inspectSqliteTable(databasePath, "queued_thread_revisions").exists
+        ? findRowsForIds(databasePath, "queued_thread_revisions", "thread_id", plan.ids, { limitOne: true })
+        : []),
+    ])
+    : [];
+  const remainingThreadHistoryRecords = store.hasThreadHistoryDatabase
+    ? (store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath]).flatMap((databasePath) => [
+      ...findRowsForIds(databasePath, "thread_items", "thread_id", plan.ids, { limitOne: true }),
+      ...findRowsForIds(databasePath, "thread_turns", "thread_id", plan.ids, { limitOne: true }),
+      ...findRowsForIds(databasePath, "thread_history_projection_state", "thread_id", plan.ids, { limitOne: true }),
+    ])
+    : [];
   const [sessionIndexMatches, historyMatches] = await Promise.all([
     inspectJsonlMatches(
       store.sessionIndexPath,
@@ -2872,6 +2968,8 @@ export async function verifySessionDeletion({ plan, scope = "deep", store }) {
       remainingMemoryRecords.length === 0 &&
       remainingGoalRecords.length === 0 &&
       remainingLogRecords.length === 0 &&
+      remainingQueueRecords.length === 0 &&
+      remainingThreadHistoryRecords.length === 0 &&
       sessionIndexMatches.count === 0 &&
       historyMatches.count === 0 &&
       remainingTranscriptPaths.length === 0 &&
@@ -2883,6 +2981,8 @@ export async function verifySessionDeletion({ plan, scope = "deep", store }) {
     remainingHistoryEntryCount: historyMatches.count,
     remainingLogRecords,
     remainingMemoryRecords,
+    remainingQueueRecords,
+    remainingThreadHistoryRecords,
     remainingSessionIndexEntries,
     remainingSessionIndexEntryCount: sessionIndexMatches.count,
     remainingThreads,