refactor(sessions): remove file-era transcript runtime (#113233)

* refactor(sessions): keep helper transcripts in memory

* refactor(sessions): remove file-era transcript storage

* test(sessions): use SQLite identity in attempt persistence

* test(codex): isolate legacy transcript fixtures

* fix(sessions): preserve SQLite transcript identity

* fix(sessions): harden transcript lifecycle invariants

* fix(sessions): validate transcript identities

* fix(sessions): close identity compatibility gaps

* fix(sessions): preserve leaf and plugin identities

* fix(sessions): retain dispatch transcript targets

* fix(sessions): preserve active transcript context

* fix(sessions): isolate artifact accounting

* fix(sessions): bound SQLite usage accounting

* fix(sessions): retain bounded latest usage

* fix(sessions): align rebased transcript targets

* test(sessions): align accessor scope fixture

* fix(telegram): derive SQLite transcript identity

* refactor(sessions): remove file-era compaction residue

* chore(sessions): lower max-lines baseline

* fix(sessions): preserve structured transcript identity

* test(sessions): align doctor identity assertions

* fix(sessions): isolate default SDK database

* refactor(sessions): remove dead file-era exports

* fix(sessions): reconcile SQLite transcript identity

* fix(sessions): pass checkpoint identity explicitly

* test(sessions): make entry field probe explicit

* test(sessions): satisfy transcript cleanup lint

* test(sessions): align diagnostics identity proof

* fix(sessions): finish transcript runtime teardown

* fix(sessions): preserve transcript identity invariants

* fix(sessions): harden transcript compatibility edges

* fix(sessions): preserve checkpoint transcript anchors

* fix(sessions): preserve SQLite lifecycle invariants

* fix(sessions): retarget compaction successors

* test(sessions): preserve transcript fixture semantics

* feat(plugin-sdk): add command transcript targets

* fix(sessions): serialize transcript rewrites

* fix(sessions): validate legacy successor identity

* fix(sessions): normalize compaction ownership

* fix(sessions): validate successor identity before adoption

* fix(sessions): preserve plugin transcript ownership

* fix(sessions): carry transcript identity through commands

* fix(sessions): import legacy checkpoint artifacts into SQLite

* fix(sessions): preserve successor transcript ownership

* fix(sessions): align transcript consumers with target identity

* fix(sessions): scope transcript token estimates

* fix(sessions): retain agent identity across lifecycle hooks

* fix(sessions): resolve scoped SQLite targets

* fix(sessions): isolate lifecycle transcript targets

* fix(sessions): validate compaction agent ownership

* fix(sessions): preserve reset and cleanup lifecycle

* fix(sessions): serialize prompt cleanup lifecycle

* fix(sessions): remove stale lock import

* fix(sessions): preserve reset target context

* fix(sessions): fence prompt reload takeover

* fix(sessions): unblock abort and default lifecycle reads

* fix(sessions): validate legacy successor scope

* fix(sessions): reject metadata-only runtime rows

* fix(sessions): propagate custom transcript stores

* fix(sessions): preserve adopted retry targets

* fix(sessions): allow unkeyed usage reads

* fix(sessions): harden runtime target boundaries

* fix(sessions): serialize retry transcript writes

* fix(sessions): bound prompt reload disposal

* fix(sessions): complete retry marker identity

* fix(sessions): keep legacy marker identity minimal

* test(sessions): tighten teardown fixture types

* fix(sessions): preserve compatibility target identity

* test(sessions): persist post-checkpoint boundary turn

* test(sessions): align runtime store mock contracts

* style(sessions): simplify persisted identity guard

* fix(sessions): prefer complete typed targets

* fix(sessions): recover legacy marker targets

* test(sessions): align marker lookup fixture scope

* fix(sessions): validate partial transcript targets

* fix(sessions): reconcile partial transcript identities

* fix(sessions): canonicalize compatibility identities

* test(sessions): cover compatibility aliases

* fix(sessions): adopt legacy successor identity

* fix(sessions): preserve usage read identity

* fix(sessions): preserve partial marker compatibility

* fix(sessions): validate legacy successor mappings

* fix(sessions): reconcile marker store mappings

* fix(sessions): preserve legacy fallback identity

* fix(sessions): harden marker alias resolution

* fix(sessions): prefer verified successor aliases

* fix(sessions): resolve preferred marker aliases

* fix(sessions): serialize cleanup admission

* fix(sessions): align marker lookup scopes

* fix(codex): type marker alias summaries

* style(sessions): satisfy changed lint

* test(sessions): align structured target assertions

* fix(sessions): reconcile latest identity contracts

* fix(sessions): validate transcript identity boundaries

* docs(sessions): explain stable registry keys

* fix(sessions): harden compatibility target round trips

* fix(sessions): port usage identity to split modules

* test(sessions): align subagent transcript identity

* fix(sessions): finish transcript identity migration

* fix(agents): route subagent completion capture through transcript targets

* fix(agents): settle SQLite prompt handoff during cleanup

* chore: shrink max-lines baseline after teardown

* fix(sessions): port teardown across split runtime owners

* fix(sessions): carry transcript targets through split owners

* test(agents): use SQLite compaction target in abort coverage

* chore: retain unrelated max-lines suppressions

* chore: shrink max-lines baseline after main splits

* style(agents): const compaction checkpoint locals

* fix(sessions): harden SQLite teardown boundaries

* test(sessions): use typed metadata in predicate isolation fixture

* test(agents): cover malformed settlement rejections lint-safely

* fix(sessions): close remaining SQLite identity races

* fix(agents): fail closed on incomplete successor targets

* fix(sessions): preserve transcript identity fallbacks

* fix(agents): preserve session-key abort admission

* fix(trajectory): validate incomplete export targets

* test(sessions): drop retired pricing cache imports

* fix(sessions): validate partial transcript identities

* fix(sessions): close transcript identity edge cases

* fix(plugins): reserve retired transcript locator slot

* fix(sessions): scope transcript locks by target

* style(sessions): simplify SDK initialization error

* fix(sessions): preserve initialized transcript state

* fix(codex): verify mirrored history session keys

* fix(sessions): reject stale transcript ownership

* fix(sessions): anchor asynchronous transcript ownership

* fix(sessions): measure active transcript state

* fix(sessions): preserve scoped transcript compaction

* fix(sessions): harden transcript identity and lifecycle

* fix(sessions): resolve scoped command transcript stores

* fix(sessions): make transcript appends failure-atomic

* fix(sessions): enforce scoped transcript ownership

* fix(sessions): reject cross-owner transcript handoffs

* fix(sessions): fence cleanup transcript ownership

* fix(sessions): retire stale write ownership contexts

* fix(sessions): preserve pending session migration state

* fix(sessions): validate migrated transcript ownership

* fix(sessions): validate usage transcript targets

* fix(sessions): clear predecessor transcript metadata

* fix(sessions): align durable session event targets

* fix(sessions): fence late prompt handoffs

* fix(sessions): fence lifecycle transcript fallbacks

* fix(sessions): bound zero-length memory capture

* fix(sessions): preserve transcript teardown ownership

* fix(sessions): reject duplicate cleanup ownership

* fix(sessions): serialize runtime writes with sqlite leases

* fix(sessions): close sqlite teardown concurrency gaps

* fix(sessions): preserve nested lifecycle failures

* fix(sessions): canonicalize sqlite transcript ownership

* fix(sessions): settle disposed prompt handoffs

* fix(sessions): resolve canonical attempt lock targets

* test(sessions): align canonical target fixtures

* test(sessions): retire redundant jsonl parser coverage

* refactor(sessions): split active transcript cursors

* test(memory): retire legacy marker fixture

* fix(sessions): preserve canonical transcript access after rebase

* fix(sessions): fence prompt lease and return transcript targets

* fix(sessions): colocate transcript leases with target store

* fix(sessions): canonicalize transcript lease and worker targets

* fix(sessions): preserve plugin and fork identity markers

* fix(sessions): complete sqlite transcript target migration

* fix(sessions): integrate canonical followup identity

* fix(sessions): preserve bounded transcript topology

* fix(sessions): validate transcript identity boundaries

* fix(context): separate caller and successor targets

* test(sessions): split persistence compatibility coverage

* test(sessions): preserve fixture topology efficiently

* chore(sdk): refresh plugin api baseline

* test(agents): align compaction lock target mocks

* test(sessions): seed malformed transcript fixtures directly

* fix(agents): canonicalize transcript compatibility inputs

* fix(agents): type optional tool result ids

* test(ci): stabilize loaded process timing

* test(tui): wait for collect queue admission

test/helpers/session-manager-file-compat.ts

@@ -0,0 +1,5 @@
+import { installSessionManagerFileCompat } from "../../src/plugin-sdk/agent-runtime-test-contracts.js";
+
+export { installSessionManagerFileCompat };
+
+installSessionManagerFileCompat();

test/helpers/sqlite-sessions-transcripts-flip-proof-assertions.ts

@@ -73,7 +73,7 @@ export function assertSqliteFlipProofCore(report: SqliteFlipProofReport): void {
     latestAssistantTextAfterAppend: "sqlite sdk consumer appended by identity",
     sessionKey: report.pluginSdkSessionKey,
   });
-  expect(report.pluginSdkConsumer?.sessionFileMarker.startsWith("sqlite:")).toBe(true);
+  expect(report.pluginSdkConsumer?.sessionIdentity).toBe(report.pluginSdkSessionKey);
   expect(report.pluginSdkConsumer?.listedSessionKeys).toContain(report.pluginSdkSessionKey);
   expect(
     report.checkpoints.some(

test/helpers/sqlite-sessions-transcripts-flip-proof.ts

@@ -13,12 +13,12 @@ import {
   readSessionArchiveContentSync,
   stripSessionArchiveCompressionSuffix,
 } from "../../src/config/sessions/archive-compression.js";
+import { formatSqliteSessionFileMarker } from "../../src/config/sessions/legacy-sqlite-marker.js";
 import {
   appendTranscriptMessage,
   type TranscriptEvent,
 } from "../../src/config/sessions/session-accessor.js";
 import { importSqliteSessionRows } from "../../src/config/sessions/session-accessor.sqlite.js";
-import { formatSqliteSessionFileMarker } from "../../src/config/sessions/sqlite-marker.js";
 import type { SessionEntry } from "../../src/config/sessions/types.js";
 import {
   connectGatewayClient,
@@ -116,7 +116,7 @@ type PluginSdkConsumerEvidence = {
   latestAssistantTextBeforeAppend: string;
   latestAssistantTextAfterAppend: string;
   listedSessionKeys: string[];
-  sessionFileMarker: string;
+  sessionIdentity: string;
   sessionId: string;
   sessionKey: string;
   storeTranscriptEvents: number;
@@ -129,7 +129,7 @@ type ManualCompactionEvidence = {
   compacted: boolean;
   rowCountAfter: number;
   rowCountBefore: number;
-  sessionFileMarker: string;
+  transcriptIdentity: string;
   sessionId: string;
   sessionKey: string;
 };
@@ -1225,12 +1225,8 @@ async function runManualCompactionProof(
   if (checkpointCount < 1) {
     throw new Error(`manual compaction did not write checkpoint metadata: ${JSON.stringify(row)}`);
   }
-  const sessionFileMarker = typeof row.entry.sessionFile === "string" ? row.entry.sessionFile : "";
-  if (!sessionFileMarker.startsWith("sqlite:")) {
-    throw new Error(`manual compaction entry did not keep a SQLite marker: ${sessionFileMarker}`);
-  }
-  if (fsSync.existsSync(sessionFileMarker)) {
-    throw new Error(`manual compaction marker unexpectedly exists as a file: ${sessionFileMarker}`);
+  if (Object.hasOwn(row.entry, "sessionFile")) {
+    throw new Error(`manual compaction entry retained file-era identity: ${JSON.stringify(row)}`);
   }
 
   return {
@@ -1238,7 +1234,7 @@ async function runManualCompactionProof(
     compacted: compacted.compacted,
     rowCountAfter: countSqliteTranscriptEvents(context.agentDbPath, row.sessionId),
     rowCountBefore,
-    sessionFileMarker,
+    transcriptIdentity: context.manualCompactionSessionKey,
     sessionId: row.sessionId,
     sessionKey: context.manualCompactionSessionKey,
   };
@@ -1265,20 +1261,8 @@ async function runPluginSdkConsumerProbe(
       `SDK session store read returned ${JSON.stringify(sessionEntry)} for ${context.pluginSdkSessionKey}`,
     );
   }
-  const expectedMarker = formatSqliteSessionFileMarker({
-    agentId: context.agentId,
-    sessionId,
-    storePath: context.storePath,
-  });
-  if (sessionEntry.sessionFile !== expectedMarker) {
-    throw new Error(
-      `SDK session store exposed unexpected transcript marker for ${context.pluginSdkSessionKey}: ${String(
-        sessionEntry.sessionFile,
-      )}`,
-    );
-  }
-  if (fsSync.existsSync(sessionEntry.sessionFile)) {
-    throw new Error(`SDK session marker unexpectedly resolves to an active file path`);
+  if (Object.hasOwn(sessionEntry, "sessionFile")) {
+    throw new Error(`SDK session store exposed retired transcript locator`);
   }
 
   const listedSessionKeys = listSdkSessionEntries({
@@ -1373,7 +1357,7 @@ async function runPluginSdkConsumerProbe(
     latestAssistantTextBeforeAppend: latestBefore.text,
     latestAssistantTextAfterAppend: latestAfter.text,
     listedSessionKeys,
-    sessionFileMarker: sessionEntry.sessionFile,
+    sessionIdentity: context.pluginSdkSessionKey,
     sessionId,
     sessionKey: context.pluginSdkSessionKey,
     storeTranscriptEvents,
@@ -2544,12 +2528,22 @@ function validateCheckpointInvariants(
     }
   }
   if (checkpoint.label === "after-shared-final-delete") {
-    requireArchiveText(checkpoint, failures, {
-      description: "final shared transcript archive",
-      includes: ["shared"],
+    const deletedArchive = findArchiveArtifact(checkpoint, {
       reason: "deleted",
       sessionId: "sqlite-shared-session",
     });
+    if (!deletedArchive) {
+      // Both legacy files claim one session id, so the importer preserves the
+      // ambiguous sources as artifacts instead of materializing duplicate rows.
+      // Final deletion must not synthesize a second archive from empty SQLite state.
+      for (const sourceName of ["sqlite-shared-a.jsonl", "sqlite-shared-b.jsonl"]) {
+        requireArchiveText(checkpoint, failures, {
+          description: `retained shared import source ${sourceName}`,
+          includes: ["shared"],
+          pathIncludes: sourceName,
+        });
+      }
+    }
   }
 }