session-steward 0.5.2 → 0.7.0

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

@@ -2,10 +2,14 @@ import { createHash, randomBytes } from "node:crypto";
 import { once } from "node:events";
 import { createReadStream, createWriteStream } from "node:fs";
 import { promises as fs } from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import { finished, pipeline } from "node:stream/promises";
 
+import {
+  expandHomePath,
+  getClaudeDesktopDataHome,
+  invalidateClaudeDesktopDataHome,
+} from "../../platform.mjs";
 import { measurePath } from "../../storage/files.mjs";
 import { readJsonlEntries, rewriteJsonlFile } from "../../storage/jsonl.mjs";
 
@@ -13,8 +17,8 @@ const PROVIDER_ID = "claude-code";
 const COMPATIBILITY_PROFILE = Object.freeze({
   id: "claude-local-store-2026-08",
   builtFor: {
-    claudeCli: ["2.1.199", "2.1.220", "2.1.228"],
-    claudeDesktop: ["1.24012.9", "1.28929.0"],
+    claudeCli: ["2.1.199", "2.1.220", "2.1.228", "2.1.237"],
+    claudeDesktop: ["1.24012.9", "1.28929.0", "1.32885.1"],
   },
 });
 const SUPPORTED_ENTRYPOINTS = new Set(["cli", "claude-desktop"]);
@@ -34,19 +38,11 @@ const SESSION_SORTS = new Set(["created", "cwd", "name", "size", "updated"]);
 const discoveryCache = new Map();
 const transcriptActivityCache = new Map();
 
-function expandHome(value) {
-  if (value === "~") return os.homedir();
-  if (value?.startsWith("~/")) return path.join(os.homedir(), value.slice(2));
-  return value;
-}
-
 function getPaths(claudeHomeInput, desktopDataHomeInput) {
-  const claudeHome = path.resolve(expandHome(claudeHomeInput || process.env.CLAUDE_CONFIG_DIR || "~/.claude"));
+  const claudeHome = path.resolve(expandHomePath(claudeHomeInput || process.env.CLAUDE_CONFIG_DIR || "~/.claude"));
   const desktopDataHome = desktopDataHomeInput
-    ? path.resolve(expandHome(desktopDataHomeInput))
-    : process.platform === "darwin"
-      ? path.join(os.homedir(), "Library", "Application Support", "Claude")
-      : null;
+    ? path.resolve(expandHomePath(desktopDataHomeInput))
+    : getClaudeDesktopDataHome();
   return {
     backupRoot: path.join(claudeHome, "session-steward-backups"),
     claudeHome,
@@ -401,6 +397,9 @@ async function discover(claudeHome, desktopDataHome) {
 }
 
 async function discoverCached(claudeHome, desktopDataHome, { refresh = false } = {}) {
+  if (refresh && !desktopDataHome) {
+    invalidateClaudeDesktopDataHome();
+  }
   const paths = getPaths(claudeHome, desktopDataHome);
   const key = `${paths.claudeHome}\0${paths.desktopDataHome || ""}`;
   const cached = discoveryCache.get(key);
@@ -416,6 +415,7 @@ async function discoverCached(claudeHome, desktopDataHome, { refresh = false } =
 export function invalidateSessionCache({ claudeHome, desktopDataHome }) {
   const paths = getPaths(claudeHome, desktopDataHome);
   discoveryCache.delete(`${paths.claudeHome}\0${paths.desktopDataHome || ""}`);
+  invalidateClaudeDesktopDataHome();
 }
 
 function filterRecords(records, options) {

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,8 +1,11 @@
 import {
   createSessionEvent,
+  createSessionEventComposition,
   createSessionEventCoverage,
   createSessionEventHeader,
+  createSessionEventSummary,
   createSessionEventsResult,
+  finalizeSessionEventComposition,
   SESSION_EVENT_KIND,
   SESSION_EVENT_REASON,
 } from "../../session-events.mjs";
@@ -53,6 +56,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;
@@ -339,6 +366,8 @@ export async function readSessionEvents({
   }
 
   const coverage = createSessionEventCoverage();
+  const summary = createSessionEventSummary();
+  const composition = createSessionEventComposition();
   const readState = createSessionEventReadState({ limit, mode });
   const unmappedTypes = createUnmappedSessionEventTracker();
   const duplicateTexts = createDuplicateTextTracker();
@@ -350,6 +379,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 +767,17 @@ 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;
         const result = handleRecord(entry.parsed, entry.index);
         coverage[result.classification] += 1;
         if (result.duplicate) coverage.duplicates += 1;
@@ -774,6 +809,8 @@ export async function readSessionEvents({
     reason: events.length === 0 && read.complete
       ? SESSION_EVENT_REASON.NO_RECOGNIZED_EVENTS
       : null,
+    composition: finalizeSessionEventComposition(composition, read.snapshotBytes),
+    summary,
     window: readState.window(read),
   });
 }

package/lib/providers/codex/store.mjs

@@ -1,7 +1,6 @@
 import { createHash } from "node:crypto";
 import { constants as fsConstants, createReadStream } from "node:fs";
 import { promises as fs } from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 
@@ -25,18 +24,7 @@ import {
   invalidateCodexDatabaseResolution,
   resolveCodexDatabases,
 } from "./database-families.mjs";
-
-function expandHome(value) {
-  if (!value || value === "~") {
-    return os.homedir();
-  }
-
-  if (value.startsWith("~/")) {
-    return path.join(os.homedir(), value.slice(2));
-  }
-
-  return value;
-}
+import { expandHomePath } from "../../platform.mjs";
 
 function normalizeText(value) {
   if (typeof value !== "string") {
@@ -448,15 +436,17 @@ function deriveDisplayName({
 }
 
 export function getCodexPaths(codexHomeInput, { refresh = false } = {}) {
-  const codexHome = path.resolve(expandHome(codexHomeInput || "~/.codex"));
+  const codexHome = path.resolve(expandHomePath(codexHomeInput || "~/.codex"));
   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,
@@ -472,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,
@@ -479,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],
   };
 }
@@ -581,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();
@@ -780,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,
@@ -794,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,
@@ -1017,7 +1021,7 @@ async function getSessionSizeIndex(paths, { refresh = false } = {}) {
 }
 
 export function invalidateSessionCache({ codexHome }) {
-  const resolvedHome = path.resolve(expandHome(codexHome || "~/.codex"));
+  const resolvedHome = path.resolve(expandHomePath(codexHome || "~/.codex"));
   sessionSizeCache.delete(resolvedHome);
   invalidateCodexDatabaseResolution(resolvedHome);
 }
@@ -1229,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 {
@@ -1243,6 +1251,8 @@ async function getStoreAvailability(paths) {
     hasGoalsDatabase,
     hasLogsDatabase,
     hasMemoryDatabase,
+    hasQueueDatabase,
+    hasThreadHistoryDatabase,
   };
 }
 
@@ -1497,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,
@@ -1507,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)),
@@ -1966,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)),
@@ -1984,6 +2011,8 @@ export async function planSessionDeletion({ recordIds, store }) {
     ids: deletionIds,
     logRowCount,
     memoryRowCount,
+    queueRowCount,
+    queueRevisionRowCount,
     missingTranscriptPaths,
     newestLinkedActivityAtMs,
     records: selectedRecords,
@@ -1992,6 +2021,7 @@ export async function planSessionDeletion({ recordIds, store }) {
     stateTargets,
     transcriptBytes,
     transcriptFileCount,
+    threadHistoryRowCount,
     transcriptPaths,
   };
 }
@@ -2003,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);
@@ -2045,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] : []),
@@ -2052,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,
@@ -2091,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);
@@ -2304,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]),
   ];
@@ -2479,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);
@@ -2840,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,
@@ -2884,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 &&
@@ -2895,6 +2981,8 @@ export async function verifySessionDeletion({ plan, scope = "deep", store }) {
     remainingHistoryEntryCount: historyMatches.count,
     remainingLogRecords,
     remainingMemoryRecords,
+    remainingQueueRecords,
+    remainingThreadHistoryRecords,
     remainingSessionIndexEntries,
     remainingSessionIndexEntryCount: sessionIndexMatches.count,
     remainingThreads,

package/lib/server.mjs

@@ -12,6 +12,7 @@ import {
 } from "./session-event-reader.mjs";
 import { createProviderSettings } from "./settings.mjs";
 import { classifyInstalledVersion } from "./version-support.mjs";
+import { getCommandInvocation } from "./platform.mjs";
 
 const MAX_BODY_BYTES = 64 * 1024;
 const ALLOWED_SCOPES = new Set(["core", "deep"]);
@@ -32,7 +33,12 @@ const staticAssets = new Map([
 
 function readCommandVersion(command, args) {
   try {
-    return execFileSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+    const invocation = getCommandInvocation(command, args);
+    return execFileSync(invocation.command, invocation.args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: invocation.windowsHide,
+    }).trim() || null;
   } catch {
     return null;
   }

package/lib/session-events.mjs

@@ -206,6 +206,72 @@ export function createSessionEventCoverage({
   };
 }
 
+export function createSessionEventSummary({ asks = 0, commands = 0, edits = 0 } = {}) {
+  return {
+    asks: requiredCount(asks, "summary.asks"),
+    commands: requiredCount(commands, "summary.commands"),
+    edits: requiredCount(edits, "summary.edits"),
+  };
+}
+
+// Ordered largest-concept-first so the bar and its legend agree
+export const SESSION_EVENT_COMPOSITION_SEGMENTS = Object.freeze([
+  "toolOutput",
+  "largeRecords",
+  "compaction",
+  "attachments",
+  "messages",
+  "edits",
+  "reasoning",
+  "other",
+]);
+
+export function createSessionEventComposition({
+  attachments = 0,
+  compaction = 0,
+  edits = 0,
+  largeRecords = 0,
+  messages = 0,
+  other = 0,
+  reasoning = 0,
+  toolOutput = 0,
+  total = 0,
+} = {}) {
+  const composition = {
+    attachments: requiredCount(attachments, "composition.attachments"),
+    compaction: requiredCount(compaction, "composition.compaction"),
+    edits: requiredCount(edits, "composition.edits"),
+    largeRecords: requiredCount(largeRecords, "composition.largeRecords"),
+    messages: requiredCount(messages, "composition.messages"),
+    other: requiredCount(other, "composition.other"),
+    reasoning: requiredCount(reasoning, "composition.reasoning"),
+    toolOutput: requiredCount(toolOutput, "composition.toolOutput"),
+    total: requiredCount(total, "composition.total"),
+  };
+
+  const segments = SESSION_EVENT_COMPOSITION_SEGMENTS
+    .reduce((sum, segment) => sum + composition[segment], 0);
+
+  if (segments !== composition.total) {
+    throw new TypeError("Session event composition segments must add up to the transcript size.");
+  }
+
+  return composition;
+}
+
+export function finalizeSessionEventComposition(composition, transcriptBytes) {
+  const attributed = SESSION_EVENT_COMPOSITION_SEGMENTS
+    .filter((segment) => segment !== "other")
+    .reduce((sum, segment) => sum + (composition[segment] ?? 0), 0);
+  const total = Math.max(transcriptBytes ?? 0, attributed);
+
+  return createSessionEventComposition({
+    ...composition,
+    other: total - attributed,
+    total,
+  });
+}
+
 export function sessionEventCoveragePercent(coverage) {
   const normalizedCoverage = createSessionEventCoverage(coverage);
   const considered = normalizedCoverage.total - normalizedCoverage.skipped;
@@ -246,13 +312,17 @@ export function createSessionEventHeader({
 }
 
 export function createSessionEventsResult({
+  composition,
   coverage,
   events = [],
   header,
   reason = null,
+  summary,
   window = {},
 } = {}) {
   const normalizedCoverage = createSessionEventCoverage(coverage);
+  const normalizedSummary = createSessionEventSummary(summary);
+  const normalizedComposition = createSessionEventComposition(composition);
 
   if (
     normalizedCoverage.recognized
@@ -298,6 +368,8 @@ export function createSessionEventsResult({
     events: [...events],
     header: createSessionEventHeader(header),
     reason,
+    composition: normalizedComposition,
+    summary: normalizedSummary,
     window: {
       complete,
       end,

package/lib/settings.mjs

@@ -3,6 +3,11 @@ import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
+import {
+  expandHomePath,
+  getDefaultConfigDirectory as resolveDefaultConfigDirectory,
+} from "./platform.mjs";
+
 const CONFIG_VERSION = 1;
 const PROVIDERS = {
   codex: {
@@ -21,24 +26,12 @@ const PROVIDERS = {
   },
 };
 
-function expandHome(value) {
-  if (value === "~") {
-    return os.homedir();
-  }
-
-  if (value.startsWith("~/")) {
-    return path.join(os.homedir(), value.slice(2));
-  }
-
-  return value;
-}
-
 function normalizeHome(value) {
   if (typeof value !== "string" || value.includes("\0")) {
     throw new Error("Enter a valid folder path.");
   }
 
-  const expanded = expandHome(value.trim());
+  const expanded = expandHomePath(value.trim());
 
   if (!expanded || !path.isAbsolute(expanded)) {
     throw new Error("Enter a full folder path, such as ~/.codex.");
@@ -58,17 +51,7 @@ function getProviderDefinition(providerId) {
 }
 
 export function getDefaultConfigDirectory() {
-  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
-
-  if (xdgConfigHome && path.isAbsolute(xdgConfigHome)) {
-    return path.join(xdgConfigHome, "session-steward");
-  }
-
-  if (process.platform === "darwin") {
-    return path.join(os.homedir(), "Library", "Application Support", "session-steward");
-  }
-
-  return path.join(os.homedir(), ".config", "session-steward");
+  return resolveDefaultConfigDirectory();
 }
 
 async function readConfig(configPath) {