agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/mcp.spec.ts

@@ -24,7 +24,7 @@ async function boot() {
   await kernel.ensureLoaded();
   return {
     kernel,
-    tooling: await createToolingRuntime(repoRoot, kernel)
+    tooling: await createToolingRuntime(repoRoot, kernel),
   };
 }
 
@@ -33,13 +33,13 @@ function identity(runId: string, actorType: string, actorId: string, sessionId:
     run_id: runId,
     session_id: sessionId,
     actor_type: actorType,
-    actor_id: actorId
+    actor_id: actorId,
   };
 }
 
 function selectClient(
   tooling: Awaited<ReturnType<typeof createToolingRuntime>>,
-  transport: 'inprocess' | 'mcp'
+  transport: 'inprocess' | 'mcp',
 ): ToolClient {
   return transport === 'mcp' ? tooling.mcpClient : tooling.inProcessClient;
 }
@@ -61,7 +61,11 @@ async function writeRunLease(data: Record<string, unknown>) {
 }
 
 async function writeIndex(index: Record<string, unknown>) {
-  await fs.writeFile(path.join(repoRoot, '.aop', 'features', 'index.json'), `${JSON.stringify(index, null, 2)}\n`, 'utf8');
+  await fs.writeFile(
+    path.join(repoRoot, '.aop', 'features', 'index.json'),
+    `${JSON.stringify(index, null, 2)}\n`,
+    'utf8',
+  );
 }
 
 async function setReattachTimeoutMs(timeoutMs: number) {
@@ -69,7 +73,7 @@ async function setReattachTimeoutMs(timeoutMs: number) {
   const policy = await fs.readFile(policyPath, 'utf8');
   const updated = policy.replace(
     /orchestrator_session_reattach_timeout_ms:\s*\d+/,
-    `orchestrator_session_reattach_timeout_ms: ${timeoutMs}`
+    `orchestrator_session_reattach_timeout_ms: ${timeoutMs}`,
   );
   await fs.writeFile(policyPath, updated, 'utf8');
 }
@@ -110,13 +114,18 @@ async function writeFastTestGates(root: string): Promise<void> {
       '      coverage:',
       '        type: none',
       'capabilities:',
-      '  - none'
+      '  - none',
     ].join('\n'),
-    'utf8'
+    'utf8',
   );
 }
 
-function buildPlan(featureId: string, modifyPath: string, planVersion = 1, revisionOf: number | null = null) {
+function buildPlan(
+  featureId: string,
+  modifyPath: string,
+  planVersion = 1,
+  revisionOf: number | null = null,
+) {
   const plan = {
     feature_id: featureId,
     plan_version: planVersion,
@@ -127,15 +136,15 @@ function buildPlan(featureId: string, modifyPath: string, planVersion = 1, revis
     files: {
       create: [],
       modify: [modifyPath],
-      delete: []
+      delete: [],
     },
     contracts: {
       openapi: 'none',
       events: 'none',
-      db: 'none'
+      db: 'none',
     },
     acceptance_criteria: ['Deterministic transport parity is preserved'],
-    gate_profile: 'parity'
+    gate_profile: 'parity',
   };
 
   if (revisionOf != null) {
@@ -145,7 +154,11 @@ function buildPlan(featureId: string, modifyPath: string, planVersion = 1, revis
   return plan;
 }
 
-async function buildUnifiedDiff(featureId: string, relativeFilePath: string, nextContent: string): Promise<string> {
+async function buildUnifiedDiff(
+  featureId: string,
+  relativeFilePath: string,
+  nextContent: string,
+): Promise<string> {
   const worktreePath = path.join(repoRoot, '.worktrees', featureId);
   const samplePath = path.join(worktreePath, relativeFilePath);
   const original = await fs.readFile(samplePath, 'utf8');
@@ -161,13 +174,13 @@ function normalizeEnvelope(response: any): Record<string, unknown> {
   if (response?.ok) {
     return {
       ok: true,
-      data_keys: Object.keys(response.data ?? {}).sort((a, b) => a.localeCompare(b))
+      data_keys: Object.keys(response.data ?? {}).sort((a, b) => a.localeCompare(b)),
     };
   }
   return {
     ok: false,
     error_code: response?.error?.code ?? 'unknown_error',
-    detail_keys: Object.keys(response?.error?.details ?? {}).sort((a, b) => a.localeCompare(b))
+    detail_keys: Object.keys(response?.error?.details ?? {}).sort((a, b) => a.localeCompare(b)),
   };
 }
 
@@ -179,7 +192,7 @@ class TimeoutReattachProvider extends NullWorkerProvider {
       provider: 'custom',
       model: 'test-model',
       provider_config_env: null,
-      provider_config_ref: null
+      provider_config_ref: null,
     });
     this.orchestratorSessionIds = [];
   }
@@ -192,7 +205,9 @@ class TimeoutReattachProvider extends NullWorkerProvider {
     return created;
   }
 
-  async reattachSession(_sessionId: string): Promise<Awaited<ReturnType<NullWorkerProvider['reattachSession']>>> {
+  async reattachSession(
+    _sessionId: string,
+  ): Promise<Awaited<ReturnType<NullWorkerProvider['reattachSession']>>> {
     return await new Promise<Awaited<ReturnType<NullWorkerProvider['reattachSession']>>>(() => {
       // Intentional unresolved promise to force timeout fallback.
     });
@@ -203,16 +218,23 @@ describe('MCP formalization', () => {
   it('lists tools from registry and keeps tools.md generated from catalog', async () => {
     const { tooling } = await boot();
     const listed = await tooling.mcpAdapter.toolsList();
-    const catalogNames = [...tooling.registry.toolsByName.keys()].sort((a, b) => a.localeCompare(b));
+    const catalogNames = [...tooling.registry.toolsByName.keys()].sort((a, b) =>
+      a.localeCompare(b),
+    );
     const listedNames = listed.tools.map((tool) => tool.name).sort((a, b) => a.localeCompare(b));
 
     expect(listedNames).toEqual(catalogNames);
 
-    const toolsMd = await fs.readFile(path.join(repoRoot, 'agentic', 'orchestrator', 'tools.md'), 'utf8');
+    const toolsMd = await fs.readFile(
+      path.join(repoRoot, 'agentic', 'orchestrator', 'tools.md'),
+      'utf8',
+    );
     expect(toolsMd).toContain('Generated from `agentic/orchestrator/tools/catalog.json`.');
     expect(toolsMd).toContain('- feature.delete');
     expect(toolsMd).toContain('- feature.init');
-    expect(tooling.registry.protocol.mcp_protocol_version).toBe(MCP_PROTOCOL_PIN.mcp_protocol_version);
+    expect(tooling.registry.protocol.mcp_protocol_version).toBe(
+      MCP_PROTOCOL_PIN.mcp_protocol_version,
+    );
     expect(tooling.registry.protocol.sdk.package).toBe(MCP_PROTOCOL_PIN.sdk.package);
     expect(tooling.registry.protocol.sdk.version).toBe(MCP_PROTOCOL_PIN.sdk.version);
     for (const transport of REQUIRED_MCP_TRANSPORTS) {
@@ -225,7 +247,7 @@ describe('MCP formalization', () => {
 
     const invalid = await tooling.mcpAdapter.toolsCall({
       name: 'report.dashboard',
-      arguments: {}
+      arguments: {},
     });
     expect(invalid.ok).toBe(false);
     expect((invalid as any).error.code).toBe('unauthenticated');
@@ -235,12 +257,12 @@ describe('MCP formalization', () => {
       session_id: 'session-expired',
       actor_type: 'orchestrator',
       actor_id: 'actor-expired',
-      expires_at: new Date(Date.now() - 60_000).toISOString()
+      expires_at: new Date(Date.now() - 60_000).toISOString(),
     });
     const expired = await tooling.mcpAdapter.toolsCall({
       name: 'report.dashboard',
       arguments: {},
-      session_token: expiredToken
+      session_token: expiredToken,
     });
     expect(expired.ok).toBe(false);
     expect((expired as any).error.code).toBe('unauthenticated');
@@ -249,15 +271,15 @@ describe('MCP formalization', () => {
       run_id: 'run-valid',
       session_id: 'session-valid',
       actor_type: 'orchestrator',
-      actor_id: 'actor-valid'
+      actor_id: 'actor-valid',
     });
     const mismatch = await tooling.mcpAdapter.toolsCall({
       name: 'report.dashboard',
       arguments: {
         actor_type: 'qa',
-        actor_id: 'qa-user'
+        actor_id: 'qa-user',
       },
-      session_token: valid
+      session_token: valid,
     });
     expect(mismatch.ok).toBe(false);
     expect((mismatch as any).error.code).toBe('invalid_actor_claim');
@@ -267,8 +289,8 @@ describe('MCP formalization', () => {
         run_id: 'run-system',
         session_id: 'worker:system',
         actor_type: 'system',
-        actor_id: 'system:worker'
-      })
+        actor_id: 'system:worker',
+      }),
     ).toThrow();
   });
 
@@ -280,22 +302,34 @@ describe('MCP formalization', () => {
     const claims = identity(runId, 'orchestrator', 'orch:idem', 'session-idem');
     const operationId = 'op-idempotent-0001';
 
-    const first = await tooling.inProcessClient.call('feature.init', {
-      feature_id: 'idem_feature',
-      operation_id: operationId
-    }, claims);
+    const first = await tooling.inProcessClient.call(
+      'feature.init',
+      {
+        feature_id: 'idem_feature',
+        operation_id: operationId,
+      },
+      claims,
+    );
     expect(first.ok).toBe(true);
 
-    const second = await tooling.inProcessClient.call('feature.init', {
-      feature_id: 'idem_feature',
-      operation_id: operationId
-    }, claims);
+    const second = await tooling.inProcessClient.call(
+      'feature.init',
+      {
+        feature_id: 'idem_feature',
+        operation_id: operationId,
+      },
+      claims,
+    );
     expect(second.ok).toBe(true);
 
-    const mismatch = await tooling.inProcessClient.call('feature.init', {
-      feature_id: 'different_feature',
-      operation_id: operationId
-    }, claims);
+    const mismatch = await tooling.inProcessClient.call(
+      'feature.init',
+      {
+        feature_id: 'different_feature',
+        operation_id: operationId,
+      },
+      claims,
+    );
     expect(mismatch.ok).toBe(false);
     expect((mismatch as any).error.code).toBe('operation_id_reuse_mismatch');
 
@@ -314,7 +348,9 @@ describe('MCP formalization', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
 
-    await expect(createToolingRuntime(repoRoot, kernel)).rejects.toThrow('policy_role_outside_supported_roles');
+    await expect(createToolingRuntime(repoRoot, kernel)).rejects.toThrow(
+      'policy_role_outside_supported_roles',
+    );
   });
 
   it('preserves transport parity for full critical path envelopes and deterministic state transitions', async () => {
@@ -322,7 +358,11 @@ describe('MCP formalization', () => {
 
     await writeFeatureSpec(repoRoot, 'parity_inprocess');
     await writeFeatureSpec(repoRoot, 'parity_mcp');
-    await fs.writeFile(path.join(repoRoot, 'src', 'parity_inprocess.txt'), 'hello parity inprocess\n', 'utf8');
+    await fs.writeFile(
+      path.join(repoRoot, 'src', 'parity_inprocess.txt'),
+      'hello parity inprocess\n',
+      'utf8',
+    );
     await fs.writeFile(path.join(repoRoot, 'src', 'parity_mcp.txt'), 'hello parity mcp\n', 'utf8');
     await runGit(repoRoot, ['add', '.']);
     await runGit(repoRoot, ['commit', '-m', 'add parity transport fixtures']);
@@ -332,7 +372,7 @@ describe('MCP formalization', () => {
       featureId: 'parity_inprocess',
       actorType: 'orchestrator',
       actorId: 'orchestrator:in',
-      sessionId: 'session:in'
+      sessionId: 'session:in',
     });
 
     const mcpResult = await runCriticalFlow(tooling.mcpClient, {
@@ -340,10 +380,17 @@ describe('MCP formalization', () => {
       featureId: 'parity_mcp',
       actorType: 'orchestrator',
       actorId: 'orchestrator:mcp',
-      sessionId: 'session:mcp'
+      sessionId: 'session:mcp',
     });
 
-    expect(inprocessResult.statusTimeline).toEqual(['planning', 'building', 'qa', 'ready_to_merge', 'ready_to_merge', 'merged']);
+    expect(inprocessResult.statusTimeline).toEqual([
+      'planning',
+      'building',
+      'qa',
+      'ready_to_merge',
+      'ready_to_merge',
+      'merged',
+    ]);
     expect(mcpResult.statusTimeline).toEqual(inprocessResult.statusTimeline);
     expect(mcpResult.envelopes).toEqual(inprocessResult.envelopes);
     expect(mcpResult.gateProfile).toBe('parity');
@@ -355,7 +402,10 @@ describe('MCP formalization', () => {
     kernel.policy.collision_policy = 'block';
     kernel.policy.locks.acquire_behavior = 'fail';
 
-    const inprocessResult = await runLockAndCollisionFlow(selectClient(tooling, 'inprocess'), 'inprocess');
+    const inprocessResult = await runLockAndCollisionFlow(
+      selectClient(tooling, 'inprocess'),
+      'inprocess',
+    );
     const mcpResult = await runLockAndCollisionFlow(selectClient(tooling, 'mcp'), 'mcp');
 
     expect(inprocessResult).toEqual({
@@ -364,13 +414,13 @@ describe('MCP formalization', () => {
       queueCounts: {
         afterQueue: 2,
         afterFirstReplay: 1,
-        afterSecondReplay: 0
+        afterSecondReplay: 0,
       },
       replayOrder: ['second_feature', 'third_feature'],
       acceptedVersions: {
         second: 1,
-        third: 1
-      }
+        third: 1,
+      },
     });
     expect(mcpResult).toEqual(inprocessResult);
   });
@@ -380,14 +430,18 @@ describe('MCP formalization', () => {
     const { kernel, tooling } = await boot();
     await kernel.ensureFeatureLayout('global');
 
-    const inprocessResult = await runTakeoverAndRecoveryFlow(kernel, selectClient(tooling, 'inprocess'), 'inprocess');
+    const inprocessResult = await runTakeoverAndRecoveryFlow(
+      kernel,
+      selectClient(tooling, 'inprocess'),
+      'inprocess',
+    );
     const mcpResult = await runTakeoverAndRecoveryFlow(kernel, selectClient(tooling, 'mcp'), 'mcp');
 
     expect(inprocessResult).toEqual({
       noTakeoverCode: 'run_already_active',
       takeoverSucceeded: true,
       epochIncrementedOnRecovery: true,
-      orchestratorSessionRotated: true
+      orchestratorSessionRotated: true,
     });
     expect(mcpResult).toEqual(inprocessResult);
   });
@@ -409,7 +463,8 @@ describe('MCP utility functions', () => {
   it('GIVEN_generateToolsMarkdown_false_WHEN_createToolingRuntime_called_THEN_succeeds', async () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
-    const { createToolingRuntime: ctRt, resolveToolClient: rtc } = await import('../src/mcp/runtime-factory.js');
+    const { createToolingRuntime: ctRt, resolveToolClient: rtc } =
+      await import('../src/mcp/runtime-factory.js');
     const tooling = await ctRt(repoRoot, kernel, { generateToolsMarkdown: false });
     expect(tooling.inProcessClient).toBeDefined();
     const mcpClient = rtc('mcp', tooling);
@@ -427,26 +482,35 @@ async function runCriticalFlow(
     actorType: string;
     actorId: string;
     sessionId: string;
-  }
+  },
 ): Promise<{
   statusTimeline: string[];
   gateProfile: string;
   envelopes: Record<string, Record<string, unknown>>;
 }> {
   const orchestratorClaims = identity(input.runId, input.actorType, input.actorId, input.sessionId);
-  const builderClaims = identity(input.runId, 'builder', `${input.actorId}:builder`, `${input.sessionId}:builder`);
+  const builderClaims = identity(
+    input.runId,
+    'builder',
+    `${input.actorId}:builder`,
+    `${input.sessionId}:builder`,
+  );
 
   const init = await client.call(
     'feature.init',
     {
       feature_id: input.featureId,
-      operation_id: createOperationId('feature.init', input.featureId)
+      operation_id: createOperationId('feature.init', input.featureId),
     },
-    orchestratorClaims
+    orchestratorClaims,
   );
   expect(init.ok).toBe(true);
 
-  const planningState = await client.call('feature.state_get', { feature_id: input.featureId }, orchestratorClaims);
+  const planningState = await client.call(
+    'feature.state_get',
+    { feature_id: input.featureId },
+    orchestratorClaims,
+  );
   expect(planningState.ok).toBe(true);
 
   const plannedFilePath = `src/${input.featureId}.txt`;
@@ -456,24 +520,32 @@ async function runCriticalFlow(
     {
       feature_id: input.featureId,
       plan_json: initialPlan,
-      operation_id: createOperationId('plan.submit', input.featureId)
+      operation_id: createOperationId('plan.submit', input.featureId),
     },
-    orchestratorClaims
+    orchestratorClaims,
   );
   expect(planSubmit.ok).toBe(true);
 
-  const buildingState = await client.call('feature.state_get', { feature_id: input.featureId }, orchestratorClaims);
+  const buildingState = await client.call(
+    'feature.state_get',
+    { feature_id: input.featureId },
+    orchestratorClaims,
+  );
   expect(buildingState.ok).toBe(true);
 
-  const diff = await buildUnifiedDiff(input.featureId, plannedFilePath, `hello parity ${input.featureId}\n`);
+  const diff = await buildUnifiedDiff(
+    input.featureId,
+    plannedFilePath,
+    `hello parity ${input.featureId}\n`,
+  );
   const applyPatch = await client.call(
     'repo.apply_patch',
     {
       feature_id: input.featureId,
       unified_diff: diff,
-      operation_id: createOperationId('repo.apply_patch', input.featureId)
+      operation_id: createOperationId('repo.apply_patch', input.featureId),
     },
-    builderClaims
+    builderClaims,
   );
   expect(applyPatch.ok).toBe(true);
 
@@ -483,13 +555,17 @@ async function runCriticalFlow(
       feature_id: input.featureId,
       profile: 'parity',
       mode: 'fast',
-      operation_id: createOperationId('gates.run.fast', input.featureId)
+      operation_id: createOperationId('gates.run.fast', input.featureId),
     },
-    builderClaims
+    builderClaims,
   );
   expect(gateFast.ok).toBe(true);
 
-  const qaState = await client.call('feature.state_get', { feature_id: input.featureId }, orchestratorClaims);
+  const qaState = await client.call(
+    'feature.state_get',
+    { feature_id: input.featureId },
+    orchestratorClaims,
+  );
   expect(qaState.ok).toBe(true);
 
   const gateFull = await client.call(
@@ -498,13 +574,17 @@ async function runCriticalFlow(
       feature_id: input.featureId,
       profile: 'parity',
       mode: 'full',
-      operation_id: createOperationId('gates.run.full', input.featureId)
+      operation_id: createOperationId('gates.run.full', input.featureId),
     },
-    builderClaims
+    builderClaims,
   );
   expect(gateFull.ok).toBe(true);
 
-  const readyState = await client.call('feature.state_get', { feature_id: input.featureId }, orchestratorClaims);
+  const readyState = await client.call(
+    'feature.state_get',
+    { feature_id: input.featureId },
+    orchestratorClaims,
+  );
   expect(readyState.ok).toBe(true);
 
   const gateMerge = await client.call(
@@ -513,13 +593,17 @@ async function runCriticalFlow(
       feature_id: input.featureId,
       profile: 'parity',
       mode: 'merge',
-      operation_id: createOperationId('gates.run.merge', input.featureId)
+      operation_id: createOperationId('gates.run.merge', input.featureId),
     },
-    builderClaims
+    builderClaims,
   );
   expect(gateMerge.ok).toBe(true);
 
-  const stillReadyState = await client.call('feature.state_get', { feature_id: input.featureId }, orchestratorClaims);
+  const stillReadyState = await client.call(
+    'feature.state_get',
+    { feature_id: input.featureId },
+    orchestratorClaims,
+  );
   expect(stillReadyState.ok).toBe(true);
 
   const missingApproval = await client.call(
@@ -528,9 +612,9 @@ async function runCriticalFlow(
       feature_id: input.featureId,
       commit_message: `feat: merge ${input.featureId}`,
       merge_strategy: 'merge_commit',
-      operation_id: createOperationId('feature.ready_to_merge.reject', input.featureId)
+      operation_id: createOperationId('feature.ready_to_merge.reject', input.featureId),
     },
-    orchestratorClaims
+    orchestratorClaims,
   );
   expect(missingApproval.ok).toBe(false);
 
@@ -541,13 +625,15 @@ async function runCriticalFlow(
       commit_message: `feat: merge ${input.featureId}`,
       merge_strategy: 'merge_commit',
       user_approval_token: 'approved',
-      operation_id: createOperationId('feature.ready_to_merge.pass', input.featureId)
+      operation_id: createOperationId('feature.ready_to_merge.pass', input.featureId),
     },
-    orchestratorClaims
+    orchestratorClaims,
   );
   expect(merged.ok).toBe(true);
 
-  await expect(fs.stat(path.join(repoRoot, '.aop', 'features', input.featureId))).resolves.toBeDefined();
+  await expect(
+    fs.stat(path.join(repoRoot, '.aop', 'features', input.featureId)),
+  ).resolves.toBeDefined();
 
   return {
     statusTimeline: [
@@ -556,7 +642,7 @@ async function runCriticalFlow(
       (qaState as any).data.front_matter.status,
       (readyState as any).data.front_matter.status,
       (stillReadyState as any).data.front_matter.status,
-      (merged as any).data.status
+      (merged as any).data.status,
     ],
     gateProfile: (stillReadyState as any).data.front_matter.gate_profile,
     envelopes: {
@@ -567,14 +653,14 @@ async function runCriticalFlow(
       gateFull: normalizeEnvelope(gateFull),
       gateMerge: normalizeEnvelope(gateMerge),
       readyWithoutApproval: normalizeEnvelope(missingApproval),
-      readyWithApproval: normalizeEnvelope(merged)
-    }
+      readyWithApproval: normalizeEnvelope(merged),
+    },
   };
 }
 
 async function runLockAndCollisionFlow(
   client: ToolClient,
-  label: string
+  label: string,
 ): Promise<{
   lockConflictCode: string;
   queuedCodes: string[];
@@ -592,27 +678,40 @@ async function runLockAndCollisionFlow(
     await writeFeatureSpec(repoRoot, featureId);
   }
 
-  const orchestrator = identity(`run:${label}:collision`, 'orchestrator', `orch:${label}`, `session:${label}:orch`);
+  const orchestrator = identity(
+    `run:${label}:collision`,
+    'orchestrator',
+    `orch:${label}`,
+    `session:${label}:orch`,
+  );
   for (const featureId of [firstFeature, secondFeature, thirdFeature]) {
     const init = await client.call(
       'feature.init',
       { feature_id: featureId, operation_id: createOperationId('feature.init', featureId) },
-      orchestrator
+      orchestrator,
     );
     expect(init.ok).toBe(true);
   }
 
   const acquireFirst = await client.call(
     'locks.acquire',
-    { resource: 'openapi', feature_id: firstFeature, operation_id: createOperationId('locks.acquire', firstFeature) },
-    orchestrator
+    {
+      resource: 'openapi',
+      feature_id: firstFeature,
+      operation_id: createOperationId('locks.acquire', firstFeature),
+    },
+    orchestrator,
   );
   expect(acquireFirst.ok).toBe(true);
 
   const acquireConflict = await client.call(
     'locks.acquire',
-    { resource: 'openapi', feature_id: secondFeature, operation_id: createOperationId('locks.acquire', secondFeature) },
-    orchestrator
+    {
+      resource: 'openapi',
+      feature_id: secondFeature,
+      operation_id: createOperationId('locks.acquire', secondFeature),
+    },
+    orchestrator,
   );
   expect(acquireConflict.ok).toBe(false);
 
@@ -621,9 +720,9 @@ async function runLockAndCollisionFlow(
     {
       feature_id: firstFeature,
       plan_json: buildPlan(firstFeature, sharedPath, 1),
-      operation_id: createOperationId('plan.submit', firstFeature)
+      operation_id: createOperationId('plan.submit', firstFeature),
     },
-    orchestrator
+    orchestrator,
   );
   expect(acceptedFirst.ok).toBe(true);
 
@@ -632,18 +731,18 @@ async function runLockAndCollisionFlow(
     {
       feature_id: secondFeature,
       plan_json: buildPlan(secondFeature, sharedPath, 1),
-      operation_id: createOperationId('plan.submit', secondFeature)
+      operation_id: createOperationId('plan.submit', secondFeature),
     },
-    orchestrator
+    orchestrator,
   );
   const queuedThird = await client.call(
     'plan.submit',
     {
       feature_id: thirdFeature,
       plan_json: buildPlan(thirdFeature, sharedPath, 1),
-      operation_id: createOperationId('plan.submit', thirdFeature)
+      operation_id: createOperationId('plan.submit', thirdFeature),
     },
-    orchestrator
+    orchestrator,
   );
   expect(queuedSecond.ok).toBe(false);
   expect(queuedThird.ok).toBe(false);
@@ -654,8 +753,8 @@ async function runLockAndCollisionFlow(
     ...queuedIndex,
     blocked_queue: queuedIndex.blocked_queue.map((entry: any) => ({
       ...entry,
-      detected_at: '2026-02-28T12:00:00Z'
-    }))
+      detected_at: '2026-02-28T12:00:00Z',
+    })),
   });
 
   const revisedFirst = await client.call(
@@ -664,23 +763,27 @@ async function runLockAndCollisionFlow(
       feature_id: firstFeature,
       expected_plan_version: 1,
       plan_json: buildPlan(firstFeature, leaderPath, 2, 1),
-      operation_id: createOperationId('plan.update', firstFeature)
+      operation_id: createOperationId('plan.update', firstFeature),
     },
-    orchestrator
+    orchestrator,
   );
   expect(revisedFirst.ok).toBe(true);
 
   const firstRelease = await client.call(
     'locks.release',
-    { resource: 'openapi', feature_id: firstFeature, operation_id: createOperationId('locks.release.1', firstFeature) },
-    orchestrator
+    {
+      resource: 'openapi',
+      feature_id: firstFeature,
+      operation_id: createOperationId('locks.release.1', firstFeature),
+    },
+    orchestrator,
   );
   expect(firstRelease.ok).toBe(true);
 
   const indexAfterFirstReplay = await readIndex();
   expect(indexAfterFirstReplay.blocked_queue).toHaveLength(1);
   const remainingAfterFirstReplay = indexAfterFirstReplay.blocked_queue.map((entry: any) =>
-    String(entry.feature_id).replace(`${label}_`, '')
+    String(entry.feature_id).replace(`${label}_`, ''),
   );
   expect(remainingAfterFirstReplay).toEqual(['third_feature']);
 
@@ -693,23 +796,31 @@ async function runLockAndCollisionFlow(
       feature_id: secondFeature,
       expected_plan_version: 1,
       plan_json: buildPlan(secondFeature, secondUniquePath, 2, 1),
-      operation_id: createOperationId('plan.update', secondFeature)
+      operation_id: createOperationId('plan.update', secondFeature),
     },
-    orchestrator
+    orchestrator,
   );
   expect(revisedSecond.ok).toBe(true);
 
   const reacquireFirst = await client.call(
     'locks.acquire',
-    { resource: 'openapi', feature_id: firstFeature, operation_id: createOperationId('locks.acquire.re', firstFeature) },
-    orchestrator
+    {
+      resource: 'openapi',
+      feature_id: firstFeature,
+      operation_id: createOperationId('locks.acquire.re', firstFeature),
+    },
+    orchestrator,
   );
   expect(reacquireFirst.ok).toBe(true);
 
   const secondRelease = await client.call(
     'locks.release',
-    { resource: 'openapi', feature_id: firstFeature, operation_id: createOperationId('locks.release.2', firstFeature) },
-    orchestrator
+    {
+      resource: 'openapi',
+      feature_id: firstFeature,
+      operation_id: createOperationId('locks.release.2', firstFeature),
+    },
+    orchestrator,
   );
   expect(secondRelease.ok).toBe(true);
 
@@ -727,20 +838,20 @@ async function runLockAndCollisionFlow(
     queueCounts: {
       afterQueue: queuedIndex.blocked_queue.length,
       afterFirstReplay: indexAfterFirstReplay.blocked_queue.length,
-      afterSecondReplay: indexAfterSecondReplay.blocked_queue.length
+      afterSecondReplay: indexAfterSecondReplay.blocked_queue.length,
     },
     replayOrder,
     acceptedVersions: {
       second: (secondPlan as any).data.plan.plan_version,
-      third: (thirdPlan as any).data.plan.plan_version
-    }
+      third: (thirdPlan as any).data.plan.plan_version,
+    },
   };
 }
 
 async function runTakeoverAndRecoveryFlow(
   kernel: AopKernel,
   client: ToolClient,
-  label: string
+  label: string,
 ): Promise<{
   noTakeoverCode: string;
   takeoverSucceeded: boolean;
@@ -755,18 +866,23 @@ async function runTakeoverAndRecoveryFlow(
   const provider = new TimeoutReattachProvider();
   const featureId = `${label}_recovery_feature`;
   await writeFeatureSpec(repoRoot, featureId, '# Spec\n\nRecover stale run.\n');
-  const orchestrator = identity(`run:${label}:recovery`, 'orchestrator', `orch:${label}:recovery`, `session:${label}:recovery`);
+  const orchestrator = identity(
+    `run:${label}:recovery`,
+    'orchestrator',
+    `orch:${label}:recovery`,
+    `session:${label}:recovery`,
+  );
 
   const init = await client.call(
     'feature.init',
     { feature_id: featureId, operation_id: createOperationId('feature.init', featureId) },
-    orchestrator
+    orchestrator,
   );
   expect(init.ok).toBe(true);
 
   const sourceRuntime = new SupervisorRuntime(kernel, provider, client, {
     run_id: `run:${label}:source`,
-    max_iterations_per_phase: 0
+    max_iterations_per_phase: 0,
   });
   await sourceRuntime.start([{ feature_id: featureId }]);
 
@@ -777,7 +893,7 @@ async function runTakeoverAndRecoveryFlow(
   const noTakeoverRuntime = new SupervisorRuntime(kernel, provider, client, {
     run_id: `run:${label}:target:no-takeover`,
     max_iterations_per_phase: 0,
-    takeover_stale_run: false
+    takeover_stale_run: false,
   });
 
   let noTakeoverCode = 'unknown';
@@ -788,7 +904,7 @@ async function runTakeoverAndRecoveryFlow(
   const takeoverRuntime = new SupervisorRuntime(kernel, provider, client, {
     run_id: `run:${label}:target:takeover`,
     max_iterations_per_phase: 0,
-    takeover_stale_run: true
+    takeover_stale_run: true,
   });
   await takeoverRuntime.start([{ feature_id: featureId }]);
 
@@ -806,6 +922,6 @@ async function runTakeoverAndRecoveryFlow(
     noTakeoverCode,
     takeoverSucceeded: postTakeover.run_id === `run:${label}:target:takeover`,
     epochIncrementedOnRecovery: Number(postRecovery.orchestrator_epoch ?? 0) === takeoverEpoch + 1,
-    orchestratorSessionRotated: postRecovery.orchestrator_session_id !== takeoverSessionId
+    orchestratorSessionRotated: postRecovery.orchestrator_session_id !== takeoverSessionId,
   };
 }