storage: retire legacy execution writer exports (#1744)

Author: likun666661

apps/desktop/src/main/__tests__/execution-store-wiring.test.ts

@@ -4,13 +4,16 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { test } from 'node:test';
 import type { AgentRunEvent, AgentRunHeader, ShellRunRecord } from '@maka/core';
-import { createAgentRunStore, createShellRunStore } from '@maka/storage';
+import {
+  createLegacyAgentRunStoreForTest,
+  createLegacyShellRunStoreForTest,
+} from '@maka/storage/legacy-execution-test-support';
 import { openDesktopExecutionStoreWiring } from '../execution-store-wiring.js';
 
 test('Desktop cuts legacy execution state over before use and keeps later writes SQLite-only', async () => {
   const root = await mkdtemp(join(tmpdir(), 'maka-desktop-execution-stores-'));
   try {
-    const legacyRuns = createAgentRunStore(root);
+    const legacyRuns = createLegacyAgentRunStoreForTest(root);
     const firstRun = runHeader('run-1', 'turn-1');
     await legacyRuns.createRun(firstRun);
     await legacyRuns.appendEvent('session-1', 'run-1', runEvent('event-1', 'run-1', 'turn-1', 1));
@@ -24,7 +27,7 @@ test('Desktop cuts legacy execution state over before use and keeps later writes
     );
     const legacyRunBytes = await readFile(legacyRunEventsPath);
 
-    const legacyShellRuns = createShellRunStore(root);
+    const legacyShellRuns = createLegacyShellRunStoreForTest(root);
     await legacyShellRuns.createShellRun(shellRun('shell-1'));
     const legacyShellPath = join(
       root,

packages/cli/src/__tests__/inspect-command.test.ts

@@ -5,7 +5,11 @@ import { join } from 'node:path';
 import { describe, test } from 'node:test';
 import type { AgentRunHeader } from '@maka/core';
 import { createInMemoryTaskRunStore, runTaskOnce } from '@maka/headless';
-import { createAgentRunStore, createRuntimeEventStore, createSessionStore } from '@maka/storage';
+import { createSessionStore } from '@maka/storage';
+import {
+  createLegacyAgentRunStoreForTest,
+  createLegacyRuntimeEventStoreForTest,
+} from '@maka/storage/legacy-execution-test-support';
 import {
   openHeadlessExecutionStoresForWrite,
   openInteractiveExecutionStoresForWrite,
@@ -241,8 +245,8 @@ describe('inspect CLI storage authority boundary', () => {
 
 type InspectCommandTestStores = {
   sessionStore: ReturnType<typeof createSessionStore>;
-  agentRunStore: ReturnType<typeof createAgentRunStore>;
-  runtimeEventStore: ReturnType<typeof createRuntimeEventStore>;
+  agentRunStore: ReturnType<typeof createLegacyAgentRunStoreForTest>;
+  runtimeEventStore: ReturnType<typeof createLegacyRuntimeEventStoreForTest>;
   taskRunStore: ReturnType<typeof createInMemoryTaskRunStore>;
 };
 
@@ -283,8 +287,8 @@ async function withStores(run: (stores: InspectCommandTestStores) => Promise<voi
   try {
     await run({
       sessionStore: createSessionStore(root),
-      agentRunStore: createAgentRunStore(root),
-      runtimeEventStore: createRuntimeEventStore(root),
+      agentRunStore: createLegacyAgentRunStoreForTest(root),
+      runtimeEventStore: createLegacyRuntimeEventStoreForTest(root),
       taskRunStore: createInMemoryTaskRunStore(),
     });
   } finally {

packages/headless/src/__tests__/task-run-inspect.test.ts

@@ -5,7 +5,10 @@ import { join } from 'node:path';
 import { describe, test } from 'node:test';
 import type { AgentRunEvent, AgentRunHeader, RuntimeEvent } from '@maka/core';
 import { buildHistoryCompactCheckpoint } from '@maka/runtime';
-import { createAgentRunStore, createRuntimeEventStore } from '@maka/storage';
+import {
+  createLegacyAgentRunStoreForTest,
+  createLegacyRuntimeEventStoreForTest,
+} from '@maka/storage/legacy-execution-test-support';
 import type { HeavyTaskSemanticSelfCheckState, TaskEvent } from '../task-contracts.js';
 import { taskAttemptExecutionEvidence } from '../task-execution-lineage.js';
 import { createInMemoryTaskRunStore } from '../task-run-store.js';
@@ -350,16 +353,16 @@ const TURN_ID = 'turn-1';
 async function withStores(
   run: (stores: {
     taskRunStore: ReturnType<typeof createInMemoryTaskRunStore>;
-    agentRunStore: ReturnType<typeof createAgentRunStore>;
-    runtimeEventStore: ReturnType<typeof createRuntimeEventStore>;
+    agentRunStore: ReturnType<typeof createLegacyAgentRunStoreForTest>;
+    runtimeEventStore: ReturnType<typeof createLegacyRuntimeEventStoreForTest>;
   }) => Promise<void>,
 ): Promise<void> {
   const root = await mkdtemp(join(tmpdir(), 'maka-task-run-inspect-'));
   try {
     await run({
       taskRunStore: createInMemoryTaskRunStore(),
-      agentRunStore: createAgentRunStore(root),
-      runtimeEventStore: createRuntimeEventStore(root),
+      agentRunStore: createLegacyAgentRunStoreForTest(root),
+      runtimeEventStore: createLegacyRuntimeEventStoreForTest(root),
     });
   } finally {
     await rm(root, { recursive: true, force: true });

packages/runtime-host/src/__tests__/root-admission-owner.test.ts

@@ -4,11 +4,11 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { test } from 'node:test';
 import {
-  createAgentRunStore,
   type RootTurnAdmission,
   type RootTurnAdmissionStore,
   type RootTurnSourceMessage,
 } from '@maka/storage';
+import { createLegacyAgentRunStoreForTest } from '@maka/storage/legacy-execution-test-support';
 import { RootAdmissionOwner } from '../server/root-admission-owner.js';
 import { SessionAdmissionGate } from '../server/session-admission-gate.js';
 
@@ -379,11 +379,11 @@ function mutableAdmission(): RootTurnAdmission {
 }
 
 async function withStore(
-  run: (store: ReturnType<typeof createAgentRunStore>) => Promise<void>,
+  run: (store: ReturnType<typeof createLegacyAgentRunStoreForTest>) => Promise<void>,
 ): Promise<void> {
   const root = await mkdtemp(join(tmpdir(), 'maka-root-admission-owner-'));
   try {
-    await run(createAgentRunStore(root));
+    await run(createLegacyAgentRunStoreForTest(root));
   } finally {
     await rm(root, { recursive: true, force: true });
   }

packages/runtime/src/__tests__/agent-run-steering-recovery.test.ts

@@ -5,11 +5,11 @@ import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import type { AgentRunHeader, RuntimeEvent } from '@maka/core';
 import type { SessionEvent } from '@maka/core/events';
+import { createLegacyFileSessionStore } from '@maka/storage';
 import {
-  createAgentRunStore,
-  createLegacyFileSessionStore,
-  createRuntimeEventStore,
-} from '@maka/storage';
+  createLegacyAgentRunStoreForTest,
+  createLegacyRuntimeEventStoreForTest,
+} from '@maka/storage/legacy-execution-test-support';
 import { AgentRun } from '../agent-run.js';
 import { buildStatusPatch } from '../session-projection-helpers.js';
 
@@ -24,7 +24,7 @@ test('does not re-append atomically committed tool facts through the generic eve
       model: 'fake-model',
       permissionMode: 'ask',
     });
-    const runtimeEventStore = createRuntimeEventStore(root);
+    const runtimeEventStore = createLegacyRuntimeEventStoreForTest(root);
     const runId = 'run-atomic-tool';
     const turnId = 'turn-atomic-tool';
     const run = new AgentRun({
@@ -99,8 +99,8 @@ test('acks a steering event whose canonical append preceded proof publication fa
       model: 'fake-model',
       permissionMode: 'ask',
     });
-    const runStore = createAgentRunStore(root);
-    const runtimeEventStore = createRuntimeEventStore(root);
+    const runStore = createLegacyAgentRunStoreForTest(root);
+    const runtimeEventStore = createLegacyRuntimeEventStoreForTest(root);
     const runId = 'run-1';
     const turnId = 'turn-1';
     await runStore.createRun(makeRunHeader(session.id, runId, turnId));
@@ -154,7 +154,7 @@ test('acks a steering event whose canonical append preceded proof publication fa
 
     await chmod(proofDirectory, 0o700);
     await rm(proofDirectory, { recursive: true });
-    const recovered = createRuntimeEventStore(root);
+    const recovered = createLegacyRuntimeEventStoreForTest(root);
     await recovered.repairImmutableSteeringMessageProofsForRecovery(session.id);
     assert.deepEqual(await recovered.readImmutableRuntimeEvents(session.id, runId), [runtimeEvent]);
     assert.deepEqual(
@@ -177,8 +177,8 @@ test('awaits canonical Run status persistence before accepting an interaction re
       model: 'fake-model',
       permissionMode: 'ask',
     });
-    const runStore = createAgentRunStore(root);
-    const runtimeEventStore = createRuntimeEventStore(root);
+    const runStore = createLegacyAgentRunStoreForTest(root);
+    const runtimeEventStore = createLegacyRuntimeEventStoreForTest(root);
     const runId = 'run-status-barrier';
     const turnId = 'turn-status-barrier';
     await store.updateHeader(session.id, buildStatusPatch('waiting_for_user', 1));
@@ -257,8 +257,8 @@ test('required interaction resume recovers a failed best-effort Run Store latch
       model: 'fake-model',
       permissionMode: 'ask',
     });
-    const runStore = createAgentRunStore(root);
-    const runtimeEventStore = createRuntimeEventStore(root);
+    const runStore = createLegacyAgentRunStoreForTest(root);
+    const runtimeEventStore = createLegacyRuntimeEventStoreForTest(root);
     const runId = 'run-status-latch';
     const turnId = 'turn-status-latch';
     await store.updateHeader(session.id, buildStatusPatch('waiting_for_user', 1));
@@ -372,8 +372,8 @@ test('required interaction resume stays fail-closed until a later required write
       model: 'fake-model',
       permissionMode: 'ask',
     });
-    const runStore = createAgentRunStore(root);
-    const runtimeEventStore = createRuntimeEventStore(root);
+    const runStore = createLegacyAgentRunStoreForTest(root);
+    const runtimeEventStore = createLegacyRuntimeEventStoreForTest(root);
     const runId = 'run-status-latch-failure';
     const turnId = 'turn-status-latch-failure';
     await store.updateHeader(session.id, buildStatusPatch('waiting_for_user', 1));

packages/runtime/src/__tests__/context-diagnostics.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { test } from 'node:test';
 import type { AgentRunEvent, AgentRunHeader, AgentRunStore } from '@maka/core';
-import { createAgentRunStore } from '@maka/storage';
+import { createLegacyAgentRunStoreForTest } from '@maka/storage/legacy-execution-test-support';
 import { readLatestContextDiagnostics } from '../context-diagnostics.js';
 
 test('reads the latest completed provider request instead of a later failed attempt', async () => {
@@ -159,7 +159,7 @@ test('reports the latest history compaction that preceded the displayed request'
 test('reads the same diagnostics after reopening the durable run ledger', async () => {
   const root = await mkdtemp(join(tmpdir(), 'maka-context-diagnostics-'));
   try {
-    const writer = createAgentRunStore(root);
+    const writer = createLegacyAgentRunStoreForTest(root);
     const header = runHeader('run-1', 1);
     await writer.createRun(header);
     await writer.appendEvent(
@@ -168,7 +168,10 @@ test('reads the same diagnostics after reopening the durable run ledger', async
       attemptEvent('run-1', 'attempt-1', 10, 'completed', 'model', 40, 200),
     );
 
-    const diagnostics = await readLatestContextDiagnostics(createAgentRunStore(root), 'session-1');
+    const diagnostics = await readLatestContextDiagnostics(
+      createLegacyAgentRunStoreForTest(root),
+      'session-1',
+    );
 
     assert.equal(diagnostics.status, 'available');
     if (diagnostics.status !== 'available') return;

packages/runtime/src/__tests__/conversation-copy.test.ts

@@ -15,12 +15,11 @@ import {
   decodeCanonicalToolResultContent,
   isSessionInlineRun,
 } from '@maka/core';
+import { createSqliteAgentRunStore, createSqliteRuntimeStore } from '@maka/storage';
 import {
-  createAgentRunStore,
-  createRuntimeEventStore,
-  createSqliteAgentRunStore,
-  createSqliteRuntimeStore,
-} from '@maka/storage';
+  createLegacyAgentRunStoreForTest,
+  createLegacyRuntimeEventStoreForTest,
+} from '@maka/storage/legacy-execution-test-support';
 import {
   archivedToolResultContainsConversationOwnedReferences,
   cloneConversationRuntimeLedger,
@@ -412,8 +411,8 @@ test('conversation copy turn closure includes legacy children but excludes later
 test('conversation copy rejects a retained AgentRun without RuntimeEvent facts', async () => {
   const root = await mkdtemp(join(tmpdir(), 'maka-conversation-missing-runtime-copy-'));
   try {
-    const runStore = createAgentRunStore(root);
-    const runtimeEventStore = createRuntimeEventStore(root);
+    const runStore = createLegacyAgentRunStoreForTest(root);
+    const runtimeEventStore = createLegacyRuntimeEventStoreForTest(root);
     const rootRun = agentRunHeader({
       runId: 'run-root',
       invocationId: 'invocation-root',
@@ -693,8 +692,8 @@ test('conversation copy rewrites a complete tool recovery bundle atomically', as
 test('conversation copy validates operational events before persisting target ledgers', async () => {
   const root = await mkdtemp(join(tmpdir(), 'maka-conversation-copy-preflight-'));
   try {
-    const runStore = createAgentRunStore(root);
-    const runtimeEventStore = createRuntimeEventStore(root);
+    const runStore = createLegacyAgentRunStoreForTest(root);
+    const runtimeEventStore = createLegacyRuntimeEventStoreForTest(root);
     await runStore.createRun(
       agentRunHeader({
         runId: 'run-source',
@@ -763,8 +762,8 @@ test('conversation copy validates operational events before persisting target le
 test('conversation copy clones one terminal Runtime ledger with new owned identities', async () => {
   const root = await mkdtemp(join(tmpdir(), 'maka-conversation-runtime-copy-'));
   try {
-    const runStore = createAgentRunStore(root);
-    const runtimeEventStore = createRuntimeEventStore(root);
+    const runStore = createLegacyAgentRunStoreForTest(root);
+    const runtimeEventStore = createLegacyRuntimeEventStoreForTest(root);
     const sourceRun: AgentRunHeader = {
       runId: 'run-source',
       invocationId: 'invocation-source',
@@ -1130,8 +1129,8 @@ test('conversation copy clones one terminal Runtime ledger with new owned identi
 test('conversation copy rebuilds an inline checkpoint without legacy child events in its prefix', async () => {
   const root = await mkdtemp(join(tmpdir(), 'maka-conversation-checkpoint-copy-'));
   try {
-    const runStore = createAgentRunStore(root);
-    const runtimeEventStore = createRuntimeEventStore(root);
+    const runStore = createLegacyAgentRunStoreForTest(root);
+    const runtimeEventStore = createLegacyRuntimeEventStoreForTest(root);
     const firstRun = agentRunHeader({
       runId: 'run-1',
       invocationId: 'invocation-1',
@@ -1306,8 +1305,8 @@ test('conversation copy rebuilds an inline checkpoint without legacy child event
 test('conversation copy rebuilds a resumed child checkpoint over its child run chain', async () => {
   const root = await mkdtemp(join(tmpdir(), 'maka-conversation-child-checkpoint-copy-'));
   try {
-    const runStore = createAgentRunStore(root);
-    const runtimeEventStore = createRuntimeEventStore(root);
+    const runStore = createLegacyAgentRunStoreForTest(root);
+    const runtimeEventStore = createLegacyRuntimeEventStoreForTest(root);
     const rootRun = agentRunHeader({
       runId: 'run-root',
       invocationId: 'invocation-root',

packages/runtime/src/__tests__/execution-inspect.test.ts

@@ -4,7 +4,11 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { describe, test } from 'node:test';
 import type { AgentRunEvent, AgentRunHeader, RuntimeEvent } from '@maka/core';
-import { createAgentRunStore, createRuntimeEventStore, createSessionStore } from '@maka/storage';
+import { createSessionStore } from '@maka/storage';
+import {
+  createLegacyAgentRunStoreForTest,
+  createLegacyRuntimeEventStoreForTest,
+} from '@maka/storage/legacy-execution-test-support';
 import {
   AGENT_RUN_INSPECT_DOCUMENT_VERSION,
   SESSION_INSPECT_DOCUMENT_VERSION,
@@ -18,8 +22,8 @@ describe('versioned execution inspect documents', () => {
   test('reports unknown tool outcomes without copying Runtime payloads', async () => {
     await withWorkspace(async (root) => {
       const sessionStore = createSessionStore(root);
-      const runStore = createAgentRunStore(root);
-      const runtimeStore = createRuntimeEventStore(root);
+      const runStore = createLegacyAgentRunStoreForTest(root);
+      const runtimeStore = createLegacyRuntimeEventStoreForTest(root);
       const session = await sessionStore.create({
         cwd: '/tmp/workspace',
         backend: 'fake',
@@ -86,8 +90,8 @@ describe('versioned execution inspect documents', () => {
   test('projects a Session as bounded AgentRun documents without reading messages', async () => {
     await withWorkspace(async (root) => {
       const sessionStore = createSessionStore(root);
-      const runStore = createAgentRunStore(root);
-      const runtimeStore = createRuntimeEventStore(root);
+      const runStore = createLegacyAgentRunStoreForTest(root);
+      const runtimeStore = createLegacyRuntimeEventStoreForTest(root);
       const session = await sessionStore.create({
         cwd: '/tmp/workspace',
         name: 'Inspectable session',

packages/runtime/src/__tests__/runtime-continuation-crash.test.ts

@@ -8,7 +8,8 @@ import { fileURLToPath } from 'node:url';
 import { describe, test } from 'node:test';
 
 import type { AgentRunHeader, RuntimeEvent } from '@maka/core';
-import { createAgentRunStore, createSessionStore, createSqliteRuntimeStore } from '@maka/storage';
+import { createSessionStore, createSqliteRuntimeStore } from '@maka/storage';
+import { createLegacyAgentRunStoreForTest } from '@maka/storage/legacy-execution-test-support';
 
 import { type RuntimeContinuationFailpoint } from '../agent-run.js';
 import { BackendRegistry, SessionManager } from '../session-manager.js';
@@ -37,7 +38,7 @@ if (process.env[CRASH_CHILD_ENV] === '1') {
           await crashContinuationAt(workspaceRoot, failpoint);
 
           const store = createSessionStore(workspaceRoot);
-          const runStore = createAgentRunStore(workspaceRoot);
+          const runStore = createLegacyAgentRunStoreForTest(workspaceRoot);
           const runtimeEventStore = createCrashRuntimeStore(workspaceRoot);
           const [session] = await store.list();
           assert.ok(session, `${failpoint} did not persist a session`);
@@ -122,7 +123,7 @@ async function runCrashChild(): Promise<void> {
     'MAKA_RUNTIME_CONTINUATION_FAILPOINT',
   ) as RuntimeContinuationFailpoint;
   const store = createSessionStore(workspaceRoot);
-  const runStore = createAgentRunStore(workspaceRoot);
+  const runStore = createLegacyAgentRunStoreForTest(workspaceRoot);
   const runtimeEventStore = createCrashRuntimeStore(workspaceRoot);
   const backends = new BackendRegistry();
   backends.register(
@@ -215,7 +216,7 @@ function createManager(workspaceRoot: string): {
   sessionStore: ReturnType<typeof createSessionStore>;
 } {
   const store = createSessionStore(workspaceRoot);
-  const runStore = createAgentRunStore(workspaceRoot);
+  const runStore = createLegacyAgentRunStoreForTest(workspaceRoot);
   const runtimeEventStore = createCrashRuntimeStore(workspaceRoot);
   const backends = new BackendRegistry();
   backends.register(