test: state one invocation the same way everywhere

Every test that needed an invocation record built its own copy of the
opening fact: eight near-identical constructors plus a dozen inline
literals, all restating defaults nothing asserts on. Fold them onto the
one fixture, which now merges configuration field by field so a test
states only the setting it is about, and writes failureClass where the
read model looks for it.

Drop the cases that only restate a schema — protocol literal, enum
member, empty lineage, each empty legacy field — and keep the ones that
carry a rule: which routes may name a connection, which roots exist,
that a continuation names its boundary, that a malformed opening fails
the whole decode.

Generated-by: Claude Code

Author: Astro-Han

packages/core/src/__tests__/runtime-invocation-opened.test.ts

@@ -94,79 +94,30 @@ describe('invocation_opened content contract', () => {
     assert.equal(runtimeEventHasModelVisibleContent(event), false);
   });
 
-  test('accepts the unknown route provenance without connection identity', () => {
-    const fact = decodeRuntimeInvocationOpened(
-      opening({
-        route: {
-          provenance: 'unknown',
-          backendKind: 'ai-sdk',
-          llmConnectionSlug: 'legacy',
-          modelId: 'legacy-model',
-        },
-      }),
-    );
-    assert.equal(fact.route.provenance, 'unknown');
-  });
-
-  test('rejects an unknown route that still carries a connection identity', () => {
-    assert.throws(() =>
-      decodeRuntimeInvocationOpened(
-        opening({
-          route: {
-            provenance: 'unknown',
-            backendKind: 'ai-sdk',
-            llmConnectionSlug: 'legacy',
-            modelId: 'legacy-model',
-            llmConnectionId: 'conn-1',
-          } as never,
-        }),
-      ),
-    );
-  });
-
-  test('rejects a runtime route with no connection identity', () => {
-    assert.throws(() =>
-      decodeRuntimeInvocationOpened(
-        opening({
-          route: {
-            provenance: 'runtime',
-            backendKind: 'ai-sdk',
-            llmConnectionSlug: 'anthropic',
-            modelId: 'claude-x',
-          } as never,
-        }),
-      ),
-    );
-  });
-
-  test('rejects an unversioned or misversioned protocol', () => {
-    assert.throws(() => decodeRuntimeInvocationOpened(opening({ protocol: 'v2' as never })));
-    const { protocol: _protocol, ...withoutProtocol } = opening();
-    assert.throws(() => decodeRuntimeInvocationOpened(withoutProtocol));
-  });
-
-  test('rejects an unknown extra field anywhere in the closed shape', () => {
-    assert.throws(() =>
-      decodeRuntimeInvocationOpened({ ...opening(), runComposition: {} } as never),
+  test('binds connection identity to where the route came from, both ways', () => {
+    const unknownRoute = {
+      provenance: 'unknown',
+      backendKind: 'ai-sdk',
+      llmConnectionSlug: 'legacy',
+      modelId: 'legacy-model',
+    } as const;
+    assert.equal(
+      decodeRuntimeInvocationOpened(opening({ route: unknownRoute })).route.provenance,
+      'unknown',
     );
     assert.throws(() =>
       decodeRuntimeInvocationOpened(
-        opening({
-          configuration: { ...opening().configuration, sessionMode: 'agent' } as never,
-        }),
+        opening({ route: { ...unknownRoute, llmConnectionId: 'conn-1' } as never }),
       ),
     );
-  });
-
-  test('rejects a root authority that mixes two roots', () => {
     assert.throws(() =>
       decodeRuntimeInvocationOpened(
-        opening({ root: { kind: 'goal', goalId: 'g1', scheduledTaskId: 's1' } as never }),
+        opening({ route: { ...unknownRoute, provenance: 'runtime' } as never }),
       ),
     );
   });
 
-  test('accepts every root authority the runtime can open', () => {
+  test('accepts every root authority the runtime can open, and no mixture of them', () => {
     for (const root of [
       { kind: 'user' },
       { kind: 'context_compact' },
@@ -177,49 +128,42 @@ describe('invocation_opened content contract', () => {
     ] as const) {
       assert.equal(decodeRuntimeInvocationOpened(opening({ root })).root.kind, root.kind);
     }
+    assert.throws(() =>
+      decodeRuntimeInvocationOpened(
+        opening({ root: { kind: 'goal', goalId: 'g1', scheduledTaskId: 's1' } as never }),
+      ),
+    );
   });
 
-  test('carries the continuation source identity when the invocation continues one', () => {
+  test('carries a continuation source only with the boundary position it resumes from', () => {
+    const source = {
+      kind: 'continuation',
+      sourceInvocationId: 'inv-0',
+      sourceRunId: 'inv-0',
+      sourceTurnId: 'turn-0',
+    } as const;
     const fact = decodeRuntimeInvocationOpened(
       opening({
         source: {
-          kind: 'continuation',
-          sourceInvocationId: 'inv-0',
-          sourceRunId: 'inv-0',
-          sourceTurnId: 'turn-0',
+          ...source,
           sourceRuntimeEventHighWater: 7,
           claimId: 'claim-1',
           boundaryDigest: DIGEST,
         },
       }),
     );
     assert.equal(fact.source.kind, 'continuation');
+    assert.throws(() => decodeRuntimeInvocationOpened(opening({ source: source as never })));
   });
 
-  test('rejects a continuation source missing its boundary position', () => {
+  test('rejects anything the closed shape does not name', () => {
     assert.throws(() =>
-      decodeRuntimeInvocationOpened(
-        opening({
-          source: {
-            kind: 'continuation',
-            sourceInvocationId: 'inv-0',
-            sourceRunId: 'inv-0',
-            sourceTurnId: 'turn-0',
-          } as never,
-        }),
-      ),
+      decodeRuntimeInvocationOpened({ ...opening(), runComposition: {} } as never),
     );
-  });
-
-  test('rejects an empty lineage object rather than storing a meaningless key', () => {
-    assert.throws(() => decodeRuntimeInvocationOpened(opening({ lineage: {} })));
-  });
-
-  test('rejects an invalid enum member in configuration', () => {
     assert.throws(() =>
       decodeRuntimeInvocationOpened(
         opening({
-          configuration: { ...opening().configuration, toolMode: 'telepathy' } as never,
+          configuration: { ...opening().configuration, sessionMode: 'agent' } as never,
         }),
       ),
     );

packages/runtime/src/__tests__/agent-graph-timeline.test.ts

@@ -31,6 +31,7 @@ import {
   readAgentGraphTimelinePage,
 } from '../agent-graph-timeline.js';
 import { readCommittedAgentGraphProjection } from '../stream-graph-projection.js';
+import { testInvocationRecord } from './invocation-fixture.js';
 
 describe('agent graph replay timeline', () => {
   test('reconstructs control, child records, parent completion, and supervisor wake chronologically', async () => {
@@ -570,57 +571,27 @@ function runInvocation(input: {
   status?: 'completed' | 'failed' | 'aborted';
   wake?: { wakeId: string; attemptId: string };
 }): RuntimeInvocationRecord {
-  const identity = {
+  return testInvocationRecord({
     sessionId: input.sessionId,
     invocationId: `invocation-${input.runId}`,
     runId: input.runId,
     turnId: input.turnId,
-  };
-  return {
-    ...identity,
     openedAt: input.createdAt,
-    opening: {
-      kind: 'invocation_opened',
-      protocol: 'invocation_opened_v1',
-      route: {
-        provenance: 'runtime',
-        backendKind: 'ai-sdk',
-        llmConnectionId: 'deepseek-connection',
-        llmConnectionSlug: 'deepseek',
-        modelId: 'deepseek-chat',
-      },
-      configuration: {
-        cwd: '/workspace',
-        permissionMode: 'explore',
-        collaborationMode: 'agent',
-        orchestrationMode: 'default',
-        orchestrationSource: 'session',
-        toolMode: 'direct',
-      },
-      root: input.wake
-        ? {
-            kind: 'agent_graph_supervisor_wake',
-            wakeId: input.wake.wakeId,
-            attemptId: input.wake.attemptId,
-          }
-        : { kind: 'user' },
-      source: { kind: 'fresh' },
-    },
-    ...(input.completedAt !== undefined
+    ...(input.wake
       ? {
-          terminalEvent: {
-            ...identity,
-            id: `${input.runId}-terminal`,
-            ts: input.completedAt,
-            partial: false,
-            role: 'system',
-            author: 'system',
-            status: input.status ?? 'completed',
-            actions: { endInvocation: true },
-          } satisfies RuntimeEvent,
+          opening: {
+            root: {
+              kind: 'agent_graph_supervisor_wake',
+              wakeId: input.wake.wakeId,
+              attemptId: input.wake.attemptId,
+            },
+          },
         }
       : {}),
-  };
+    ...(input.completedAt !== undefined
+      ? { closedAt: input.completedAt, outcome: input.status ?? 'completed' }
+      : {}),
+  });
 }
 
 function runtimeEvent(

packages/runtime/src/__tests__/agent-run-inspect.test.ts

@@ -28,6 +28,7 @@ import {
   runtimeInvocationsFromSessionEvents,
 } from '@maka/core/runtime-invocation';
 import { inspectAgentRunReadModel } from '../agent-run-inspect.js';
+import { testInvocationOpening } from './invocation-fixture.js';
 
 const sessionId = 'session-1';
 const invocationId = 'inv-1';
@@ -243,27 +244,9 @@ class MemoryAgentRunStore implements AgentRunStore, RuntimeEventStore {
 }
 
 function makeOpening(): RuntimeEventInvocationOpenedContent {
-  return {
-    kind: 'invocation_opened',
-    protocol: 'invocation_opened_v1',
-    route: {
-      provenance: 'runtime',
-      backendKind: 'fake',
-      llmConnectionId: 'fake-connection',
-      llmConnectionSlug: 'fake',
-      modelId: 'fake-model',
-    },
-    configuration: {
-      cwd: '/tmp/cwd',
-      permissionMode: 'ask',
-      collaborationMode: 'agent',
-      orchestrationMode: 'default',
-      orchestrationSource: 'session',
-      toolMode: 'direct',
-    },
-    root: { kind: 'user' },
-    source: { kind: 'fresh' },
-  };
+  return testInvocationOpening({
+    configuration: { cwd: '/tmp/cwd' },
+  });
 }
 
 /** The invocation a run is named by, for the cases whose ledger is unreadable. */

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

@@ -21,6 +21,7 @@ import assert from 'node:assert/strict';
 import { describe, test } from 'node:test';
 import type { RuntimeInvocationRecord } from '@maka/core/runtime-invocation';
 import { classifyAgentRunRecovery } from '../agent-run-recovery.js';
+import { testInvocationOpening } from './invocation-fixture.js';
 
 describe('AgentRun startup recovery', () => {
   test('fails a graph supervisor permission handoff once its live waiter is lost', () => {
@@ -30,27 +31,17 @@ describe('AgentRun startup recovery', () => {
       runId: 'run-1',
       turnId: 'turn-1',
       openedAt: 1,
-      opening: {
-        kind: 'invocation_opened',
-        protocol: 'invocation_opened_v1',
+      opening: testInvocationOpening({
         route: {
           provenance: 'runtime',
           backendKind: 'fake',
           llmConnectionId: 'fake-connection',
           llmConnectionSlug: 'fake',
           modelId: 'fake-model',
         },
-        configuration: {
-          cwd: '/tmp/workspace',
-          permissionMode: 'ask',
-          collaborationMode: 'agent',
-          orchestrationMode: 'default',
-          orchestrationSource: 'session',
-          toolMode: 'direct',
-        },
+        configuration: { cwd: '/tmp/workspace' },
         root: { kind: 'agent_graph_supervisor_wake', wakeId: 'wake-1', attemptId: 'attempt-1' },
-        source: { kind: 'fresh' },
-      },
+      }),
     };
 
     const decision = classifyAgentRunRecovery(invocation, [

packages/runtime/src/__tests__/ai-sdk-backend.test.ts

@@ -95,6 +95,7 @@ import type { OpenAiResponsesSemanticBaseline } from '../openai-responses-contin
 import type { OpenAiResponsesTransportState } from '../openai-responses-websocket.js';
 import { getAIModel } from '../model-factory.js';
 import { waitFor as pollFor } from '@maka/core/test-only/async-primitives';
+import { testInvocationOpening } from './invocation-fixture.js';
 
 describe('AiSdkBackend ApplyPatch routing', () => {
   test('advertises apply_patch only to supported native OpenAI models', async () => {
@@ -16071,9 +16072,7 @@ function priorModelInvocation(input: {
   return {
     ...identity,
     openedAt: 1,
-    opening: {
-      kind: 'invocation_opened',
-      protocol: 'invocation_opened_v1',
+    opening: testInvocationOpening({
       route: {
         provenance: 'runtime',
         backendKind: 'ai-sdk',
@@ -16082,17 +16081,9 @@ function priorModelInvocation(input: {
         modelId: input.modelId,
         providerStateIdentity: input.providerStateIdentity ?? `sha256:${'1'.repeat(64)}`,
       },
-      configuration: {
-        cwd: '/tmp/maka',
-        permissionMode: 'ask',
-        collaborationMode: 'agent',
-        orchestrationMode: 'default',
-        orchestrationSource: 'session',
-        toolMode: 'direct',
-      },
+      configuration: { cwd: '/tmp/maka' },
       root: input.root ?? { kind: 'user' },
-      source: { kind: 'fresh' },
-    },
+    }),
     terminalEvent: {
       id: `${identity.runId}-terminal`,
       ...identity,

packages/runtime/src/__tests__/computer-use-provider-protocol.test.ts

@@ -42,6 +42,7 @@ import { backfillRuntimeEventsFromStoredMessages } from '../runtime-event-backfi
 import { createDurableTurnHarness } from './durable-turn-harness.js';
 import { createTestAiSdkBackend } from './execution-boundary-test-helpers.js';
 import { latestObservationIn } from './observation-text-reader.js';
+import { testInvocationOpening } from './invocation-fixture.js';
 
 const servers: Array<{ close(): Promise<void> }> = [];
 const PROVIDER_STATE_IDENTITY = `sha256:${'1'.repeat(64)}` as const;
@@ -1604,9 +1605,7 @@ function sourceInvocation(input: {
   return {
     ...identity,
     openedAt: input.openedAt,
-    opening: {
-      kind: 'invocation_opened',
-      protocol: 'invocation_opened_v1',
+    opening: testInvocationOpening({
       route: {
         provenance: 'runtime',
         backendKind: 'ai-sdk',
@@ -1623,9 +1622,7 @@ function sourceInvocation(input: {
         orchestrationSource: 'session',
         toolMode: 'direct',
       },
-      root: { kind: 'user' },
-      source: { kind: 'fresh' },
-    },
+    }),
     terminalEvent: {
       ...identity,
       id: `${input.runId}-terminal`,