session-steward 0.6.0 → 0.7.0

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,

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/storage/jsonl.mjs

@@ -41,7 +41,12 @@ export async function* readJsonlEntries(filePath) {
 }
 
 function appendLineBytes(state, bytes, maxLineBytes) {
-  if (state.oversized || bytes.length === 0) return;
+  if (bytes.length === 0) return;
+
+  // Counted even once a line is oversized, because the largest records in a
+  // transcript are exactly the ones that stop being buffered.
+  state.totalBytes += bytes.length;
+  if (state.oversized) return;
 
   if (state.length + bytes.length > maxLineBytes) {
     state.length = 0;
@@ -69,17 +74,20 @@ function createLineState(maxLineBytes) {
     buffer: Buffer.allocUnsafe(Math.min(JSONL_STARTING_LINE_BYTES, maxLineBytes)),
     length: 0,
     oversized: false,
+    totalBytes: 0,
   };
 }
 
 function resetLineState(state) {
   state.length = 0;
   state.oversized = false;
+  state.totalBytes = 0;
 }
 
 function snapshotEntry(state, index) {
   if (state.oversized) {
     return {
+      bytes: state.totalBytes,
       index,
       oversized: true,
       parsed: null,
@@ -93,6 +101,7 @@ function snapshotEntry(state, index) {
 
   const entry = parseLine(bytes.toString("utf8"), index);
   return {
+    bytes: state.totalBytes,
     index: entry.index,
     oversized: false,
     parsed: entry.parsed,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "session-steward",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Codex and Claude Code session manager - browse, back up, and delete old sessions. Local browser UI + CLI.",
   "license": "MIT",
   "author": "Mallik Cheripally",