@auto-engineer/pipeline 1.65.0 → 1.67.0

package/src/server/pipeline-server.specs.ts

@@ -1,3 +1,8 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { readMessagesBatch, sqliteConnection } from '@event-driven-io/emmett-sqlite';
+import { nanoid } from 'nanoid';
 import { define } from '../builder/define';
 import { PipelineServer } from './pipeline-server';
 
@@ -427,7 +432,7 @@ describe('PipelineServer', () => {
       await server.stop();
     });
 
-    it('should have status from computeSettledStats on settled nodes when correlationId provided', async () => {
+    it('should have status from computeSettledStats on settled nodes in current session', async () => {
       const handler = {
         name: 'CheckTests',
         events: ['TestsPassed'],
@@ -444,7 +449,7 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      const commandResponse = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'CheckTests', data: {} }),
@@ -452,9 +457,7 @@ describe('PipelineServer', () => {
 
       await new Promise((r) => setTimeout(r, 100));
 
-      const data = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${commandResponse.correlationId}`,
-      );
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const settledNode = data.nodes.find((n) => n.id === 'settled:CheckTests');
       expect(settledNode?.status).toBeDefined();
       expect(settledNode?.pendingCount).toBeDefined();
@@ -481,7 +484,7 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      const commandResponse = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'SlowCmd', data: {} }),
@@ -489,9 +492,7 @@ describe('PipelineServer', () => {
 
       await new Promise((r) => setTimeout(r, 50));
 
-      const data = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${commandResponse.correlationId}`,
-      );
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const cmdNode = data.nodes.find((n) => n.id === 'cmd:SlowCmd');
       expect(cmdNode?.status).toBe('running');
 
@@ -511,7 +512,7 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      const commandResponse = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'SuccessCmd', data: {} }),
@@ -519,9 +520,7 @@ describe('PipelineServer', () => {
 
       await new Promise((r) => setTimeout(r, 100));
 
-      const data = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${commandResponse.correlationId}`,
-      );
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const cmdNode = data.nodes.find((n) => n.id === 'cmd:SuccessCmd');
       expect(cmdNode?.status).toBe('success');
       await server.stop();
@@ -539,7 +538,7 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      const commandResponse = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'FailCmd', data: {} }),
@@ -547,15 +546,13 @@ describe('PipelineServer', () => {
 
       await new Promise((r) => setTimeout(r, 100));
 
-      const data = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${commandResponse.correlationId}`,
-      );
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const cmdNode = data.nodes.find((n) => n.id === 'cmd:FailCmd');
       expect(cmdNode?.status).toBe('error');
       await server.stop();
     });
 
-    it('should broadcast PipelineRunStarted event when new correlationId is first seen', async () => {
+    it('should broadcast PipelineRunStarted event once per session on server start', async () => {
       const handler = {
         name: 'StartCmd',
         events: ['Started'],
@@ -567,7 +564,7 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      const commandResponse = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'StartCmd', data: {} }),
@@ -578,12 +575,9 @@ describe('PipelineServer', () => {
       const msgs = await fetchAs<StoredMessage[]>(`http://localhost:${server.port}/messages`);
       const pipelineRunStarted = msgs.find((m) => m.message.type === 'PipelineRunStarted');
       expect(pipelineRunStarted).toBeDefined();
-      expect((pipelineRunStarted?.message as { correlationId?: string }).correlationId).toBe(
-        commandResponse.correlationId,
-      );
-      expect((pipelineRunStarted?.message as { data?: { triggerCommand?: string } }).data?.triggerCommand).toBe(
-        'StartCmd',
-      );
+      const prsMessage = pipelineRunStarted?.message as { correlationId?: string; data?: { triggerCommand?: string } };
+      expect(prsMessage.correlationId).toMatch(/^session-/);
+      expect(prsMessage.data?.triggerCommand).toBe('PipelineStarted');
       await server.stop();
     });
 
@@ -626,7 +620,7 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      const commandResponse = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'RunCmd', data: {} }),
@@ -647,7 +641,7 @@ describe('PipelineServer', () => {
       expect(runningEvent).toBeDefined();
       expect((runningEvent?.message as NodeStatusChangedMessage).data?.nodeId).toBe('cmd:RunCmd');
       expect((runningEvent?.message as NodeStatusChangedMessage).data?.previousStatus).toBe('idle');
-      expect((runningEvent?.message as NodeStatusChangedMessage).correlationId).toBe(commandResponse.correlationId);
+      expect((runningEvent?.message as NodeStatusChangedMessage).correlationId).toMatch(/^session-/);
       await server.stop();
     });
 
@@ -663,7 +657,7 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      const commandResponse = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'CompleteCmd', data: {} }),
@@ -684,7 +678,7 @@ describe('PipelineServer', () => {
       expect(successEvent).toBeDefined();
       expect((successEvent?.message as NodeStatusChangedMessage).data?.nodeId).toBe('cmd:CompleteCmd');
       expect((successEvent?.message as NodeStatusChangedMessage).data?.previousStatus).toBe('running');
-      expect((successEvent?.message as NodeStatusChangedMessage).correlationId).toBe(commandResponse.correlationId);
+      expect((successEvent?.message as NodeStatusChangedMessage).correlationId).toMatch(/^session-/);
       await server.stop();
     });
 
@@ -700,7 +694,7 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      const commandResponse = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'PersistCmd', data: {} }),
@@ -708,20 +702,16 @@ describe('PipelineServer', () => {
 
       await new Promise((r) => setTimeout(r, 100));
 
-      const firstCall = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${commandResponse.correlationId}`,
-      );
+      const firstCall = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       expect(firstCall.nodes.find((n) => n.id === 'cmd:PersistCmd')?.status).toBe('success');
 
-      const secondCall = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${commandResponse.correlationId}`,
-      );
+      const secondCall = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       expect(secondCall.nodes.find((n) => n.id === 'cmd:PersistCmd')?.status).toBe('success');
 
       await server.stop();
     });
 
-    it('should track status independently for different correlationIds', async () => {
+    it('should track all commands under the same session', async () => {
       const handler = {
         name: 'IndependentCmd',
         events: ['IndependentDone'],
@@ -731,15 +721,16 @@ describe('PipelineServer', () => {
       const server = new PipelineServer({ port: 0 });
       server.registerCommandHandlers([handler]);
       server.registerPipeline(pipeline);
+      server.registerItemKeyExtractor('IndependentCmd', (_d) => undefined);
       await server.start();
 
-      const run1 = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'IndependentCmd', data: {} }),
       });
 
-      const run2 = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'IndependentCmd', data: {} }),
@@ -747,22 +738,15 @@ describe('PipelineServer', () => {
 
       await new Promise((r) => setTimeout(r, 100));
 
-      expect(run1.correlationId).not.toBe(run2.correlationId);
-
-      const pipeline1 = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${run1.correlationId}`,
-      );
-      const pipeline2 = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${run2.correlationId}`,
-      );
-
-      expect(pipeline1.nodes.find((n) => n.id === 'cmd:IndependentCmd')?.status).toBe('success');
-      expect(pipeline2.nodes.find((n) => n.id === 'cmd:IndependentCmd')?.status).toBe('success');
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
+      const cmdNode = data.nodes.find((n) => n.id === 'cmd:IndependentCmd');
+      expect(cmdNode?.status).toBe('success');
+      expect(cmdNode?.endedCount).toBe(2);
 
       await server.stop();
     });
 
-    it('should show idle status for all command nodes when no correlationId provided', async () => {
+    it('should show session status when no correlationId query param provided', async () => {
       const handler = {
         name: 'IdleCmd',
         events: ['IdleDone'],
@@ -774,7 +758,7 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'IdleCmd', data: {} }),
@@ -782,14 +766,14 @@ describe('PipelineServer', () => {
 
       await new Promise((r) => setTimeout(r, 100));
 
-      const pipelineWithoutCorrelation = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
-      const cmdNode = pipelineWithoutCorrelation.nodes.find((n) => n.id === 'cmd:IdleCmd');
-      expect(cmdNode?.status).toBe('idle');
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
+      const cmdNode = data.nodes.find((n) => n.id === 'cmd:IdleCmd');
+      expect(cmdNode?.status).toBe('success');
 
       await server.stop();
     });
 
-    it('should return latestRun with the most recent correlationId', async () => {
+    it('should return latestRun as the session id', async () => {
       const handler = {
         name: 'LatestCmd',
         events: ['LatestDone'],
@@ -801,7 +785,7 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      const run1 = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'LatestCmd', data: {} }),
@@ -809,7 +793,7 @@ describe('PipelineServer', () => {
 
       await new Promise((r) => setTimeout(r, 50));
 
-      const run2 = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'LatestCmd', data: {} }),
@@ -818,8 +802,7 @@ describe('PipelineServer', () => {
       await new Promise((r) => setTimeout(r, 50));
 
       const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
-      expect(data.latestRun).toBe(run2.correlationId);
-      expect(data.latestRun).not.toBe(run1.correlationId);
+      expect(data.latestRun).toMatch(/^session-/);
 
       await server.stop();
     });
@@ -1553,7 +1536,7 @@ describe('PipelineServer', () => {
       server.registerItemKeyExtractor('ImplementSlice', (d) => (d as { slicePath?: string }).slicePath);
       await server.start();
 
-      const commandResponse = await fetchAs<{ correlationId: string }>(`http://localhost:${server.port}/command`, {
+      await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ type: 'ImplementSlice', data: { slicePath: '/server/slice-1' } }),
@@ -1561,9 +1544,7 @@ describe('PipelineServer', () => {
 
       await new Promise((r) => setTimeout(r, 100));
 
-      const data = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${commandResponse.correlationId}`,
-      );
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const cmdNode = data.nodes.find((n) => n.id === 'cmd:ImplementSlice');
       expect(cmdNode?.pendingCount).toBe(0);
       expect(cmdNode?.endedCount).toBe(1);
@@ -1584,43 +1565,27 @@ describe('PipelineServer', () => {
       server.registerItemKeyExtractor('ImplementSlice', (d) => (d as { slicePath?: string }).slicePath);
       await server.start();
 
-      const correlationId = `corr-parallel-test`;
-
       await Promise.all([
         fetch(`http://localhost:${server.port}/command`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            type: 'ImplementSlice',
-            data: { slicePath: '/server/slice-1' },
-            correlationId,
-          }),
+          body: JSON.stringify({ type: 'ImplementSlice', data: { slicePath: '/server/slice-1' } }),
         }),
         fetch(`http://localhost:${server.port}/command`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            type: 'ImplementSlice',
-            data: { slicePath: '/server/slice-2' },
-            correlationId,
-          }),
+          body: JSON.stringify({ type: 'ImplementSlice', data: { slicePath: '/server/slice-2' } }),
         }),
         fetch(`http://localhost:${server.port}/command`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            type: 'ImplementSlice',
-            data: { slicePath: '/server/slice-3' },
-            correlationId,
-          }),
+          body: JSON.stringify({ type: 'ImplementSlice', data: { slicePath: '/server/slice-3' } }),
         }),
       ]);
 
       await new Promise((r) => setTimeout(r, 100));
 
-      const data = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${correlationId}`,
-      );
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const cmdNode = data.nodes.find((n) => n.id === 'cmd:ImplementSlice');
       expect(cmdNode?.pendingCount).toBe(0);
       expect(cmdNode?.endedCount).toBe(3);
@@ -1647,32 +1612,27 @@ describe('PipelineServer', () => {
       server.registerItemKeyExtractor('SlowSlice', (d) => (d as { id?: string }).id);
       await server.start();
 
-      const correlationId = `corr-slow-test`;
-
       void fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'SlowSlice', data: { id: 'item-1' }, correlationId }),
+        body: JSON.stringify({ type: 'SlowSlice', data: { id: 'item-1' } }),
       });
       void fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'SlowSlice', data: { id: 'item-2' }, correlationId }),
+        body: JSON.stringify({ type: 'SlowSlice', data: { id: 'item-2' } }),
       });
       void fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'SlowSlice', data: { id: 'item-3' }, correlationId }),
+        body: JSON.stringify({ type: 'SlowSlice', data: { id: 'item-3' } }),
       });
 
-      // Wait for all 3 handlers to start (deterministic instead of timeout)
       while (resolveHandlers.length < 3) {
         await new Promise((r) => setTimeout(r, 10));
       }
 
-      const midwayData = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${correlationId}`,
-      );
+      const midwayData = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const midwayNode = midwayData.nodes.find((n) => n.id === 'cmd:SlowSlice');
       expect(midwayNode?.pendingCount).toBe(3);
       expect(midwayNode?.endedCount).toBe(0);
@@ -1681,9 +1641,7 @@ describe('PipelineServer', () => {
       resolveHandlers.forEach((r) => r());
       await new Promise((r) => setTimeout(r, 50));
 
-      const finalData = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${correlationId}`,
-      );
+      const finalData = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const finalNode = finalData.nodes.find((n) => n.id === 'cmd:SlowSlice');
       expect(finalNode?.pendingCount).toBe(0);
       expect(finalNode?.endedCount).toBe(3);
@@ -1710,31 +1668,27 @@ describe('PipelineServer', () => {
       server.registerItemKeyExtractor('MixedSlice', (d) => (d as { id?: string }).id);
       await server.start();
 
-      const correlationId = `corr-mixed-test`;
-
       await Promise.all([
         fetch(`http://localhost:${server.port}/command`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ type: 'MixedSlice', data: { id: 'pass-1' }, correlationId }),
+          body: JSON.stringify({ type: 'MixedSlice', data: { id: 'pass-1' } }),
         }),
         fetch(`http://localhost:${server.port}/command`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ type: 'MixedSlice', data: { id: 'fail-1', shouldFail: true }, correlationId }),
+          body: JSON.stringify({ type: 'MixedSlice', data: { id: 'fail-1', shouldFail: true } }),
         }),
         fetch(`http://localhost:${server.port}/command`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ type: 'MixedSlice', data: { id: 'pass-2' }, correlationId }),
+          body: JSON.stringify({ type: 'MixedSlice', data: { id: 'pass-2' } }),
         }),
       ]);
 
       await new Promise((r) => setTimeout(r, 100));
 
-      const data = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${correlationId}`,
-      );
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const cmdNode = data.nodes.find((n) => n.id === 'cmd:MixedSlice');
       expect(cmdNode?.pendingCount).toBe(0);
       expect(cmdNode?.endedCount).toBe(3);
@@ -1763,31 +1717,26 @@ describe('PipelineServer', () => {
       server.registerItemKeyExtractor('RetrySlice', (d) => (d as { slicePath?: string }).slicePath);
       await server.start();
 
-      const correlationId = `corr-retry-test`;
       const slicePath = '/server/retry-slice';
 
       await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'RetrySlice', data: { slicePath }, correlationId }),
+        body: JSON.stringify({ type: 'RetrySlice', data: { slicePath } }),
       });
       await new Promise((r) => setTimeout(r, 50));
 
-      const afterFailure = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${correlationId}`,
-      );
+      const afterFailure = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       expect(afterFailure.nodes.find((n) => n.id === 'cmd:RetrySlice')?.status).toBe('error');
 
       await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'RetrySlice', data: { slicePath }, correlationId }),
+        body: JSON.stringify({ type: 'RetrySlice', data: { slicePath } }),
       });
       await new Promise((r) => setTimeout(r, 50));
 
-      const afterRetry = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${correlationId}`,
-      );
+      const afterRetry = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const node = afterRetry.nodes.find((n) => n.id === 'cmd:RetrySlice');
       expect(node?.status).toBe('success');
       expect(node?.pendingCount).toBe(0);
@@ -1809,12 +1758,10 @@ describe('PipelineServer', () => {
       server.registerItemKeyExtractor('CountSlice', (d) => (d as { id?: string }).id);
       await server.start();
 
-      const correlationId = `corr-counts-event-test`;
-
       await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'CountSlice', data: { id: 'item-1' }, correlationId }),
+        body: JSON.stringify({ type: 'CountSlice', data: { id: 'item-1' } }),
       });
 
       await new Promise((r) => setTimeout(r, 100));
@@ -1854,19 +1801,15 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      const correlationId = `corr-no-extractor-test`;
-
       await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'NoExtractorCmd', data: {}, correlationId }),
+        body: JSON.stringify({ type: 'NoExtractorCmd', data: {} }),
       });
 
       await new Promise((r) => setTimeout(r, 100));
 
-      const data = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${correlationId}`,
-      );
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const cmdNode = data.nodes.find((n) => n.id === 'cmd:NoExtractorCmd');
       expect(cmdNode?.pendingCount).toBe(0);
       expect(cmdNode?.endedCount).toBe(1);
@@ -1875,7 +1818,7 @@ describe('PipelineServer', () => {
       await server.stop();
     });
 
-    it('should show idle status with zero counts when no correlationId provided', async () => {
+    it('should show zero counts for commands not yet executed in session', async () => {
       const handler = {
         name: 'IdleCountCmd',
         events: ['IdleCountDone'],
@@ -1889,7 +1832,6 @@ describe('PipelineServer', () => {
 
       const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const cmdNode = data.nodes.find((n) => n.id === 'cmd:IdleCountCmd');
-      expect(cmdNode?.status).toBe('idle');
       expect(cmdNode?.pendingCount).toBe(0);
       expect(cmdNode?.endedCount).toBe(0);
 
@@ -1915,30 +1857,24 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
 
-      const correlationId = `corr-retry-no-extractor-bug`;
-
       await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'RetryNoExtractor', data: { targetDir: '/slice1' }, correlationId }),
+        body: JSON.stringify({ type: 'RetryNoExtractor', data: { targetDir: '/slice1' } }),
       });
       await new Promise((r) => setTimeout(r, 50));
 
-      const afterFailure = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${correlationId}`,
-      );
+      const afterFailure = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       expect(afterFailure.nodes.find((n) => n.id === 'cmd:RetryNoExtractor')?.status).toBe('error');
 
       await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'RetryNoExtractor', data: { targetDir: '/slice1' }, correlationId }),
+        body: JSON.stringify({ type: 'RetryNoExtractor', data: { targetDir: '/slice1' } }),
       });
       await new Promise((r) => setTimeout(r, 50));
 
-      const afterRetry = await fetchAs<PipelineResponse>(
-        `http://localhost:${server.port}/pipeline?correlationId=${correlationId}`,
-      );
+      const afterRetry = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
       const node = afterRetry.nodes.find((n) => n.id === 'cmd:RetryNoExtractor');
       expect(node?.status).toBe('error');
       expect(node?.endedCount).toBe(2);
@@ -2207,4 +2143,261 @@ describe('PipelineServer', () => {
       await server.stop();
     });
   });
+
+  describe('SQLite persistence', () => {
+    it('should persist events to SQLite when storeFileName is set', async () => {
+      const tmpFile = path.join(os.tmpdir(), `pipeline-test-${nanoid()}.db`);
+      const handler = {
+        name: 'TestCmd',
+        events: ['TestDone'],
+        handle: async () => ({ type: 'TestDone', data: {} }),
+      };
+      const pipeline = define('test').on('Trigger').emit('TestCmd', {}).build();
+      const server = new PipelineServer({ port: 0, storeFileName: tmpFile });
+      server.registerCommandHandlers([handler]);
+      server.registerPipeline(pipeline);
+      await server.start();
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'TestCmd', data: {} }),
+      });
+
+      await new Promise((r) => setTimeout(r, 200));
+      await server.stop();
+
+      const connection = sqliteConnection({ fileName: tmpFile });
+      const { messages } = await readMessagesBatch(connection, {
+        after: 0n,
+        batchSize: 1000,
+      });
+      connection.close();
+
+      expect(messages.length).toBeGreaterThan(0);
+      expect(messages.some((m) => m.type === 'CommandDispatched')).toBe(true);
+      expect(messages.some((m) => m.type === 'PipelineRunStarted')).toBe(true);
+
+      fs.unlinkSync(tmpFile);
+    });
+
+    it('should restore pipeline state after server restart', async () => {
+      const tmpFile = path.join(os.tmpdir(), `pipeline-test-${nanoid()}.db`);
+      const handler = {
+        name: 'RestartCmd',
+        events: ['RestartDone'],
+        handle: async () => ({ type: 'RestartDone', data: {} }),
+      };
+      const pipeline = define('test').on('Trigger').emit('RestartCmd', {}).build();
+
+      const server1 = new PipelineServer({ port: 0, storeFileName: tmpFile });
+      server1.registerCommandHandlers([handler]);
+      server1.registerPipeline(pipeline);
+      await server1.start();
+
+      const beforeRestart = await fetchAs<PipelineResponse>(`http://localhost:${server1.port}/pipeline`);
+      const session1 = beforeRestart.latestRun!;
+
+      await fetch(`http://localhost:${server1.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'RestartCmd', data: {} }),
+      });
+      await new Promise((r) => setTimeout(r, 200));
+
+      const beforeStop = await fetchAs<PipelineResponse>(`http://localhost:${server1.port}/pipeline`);
+      expect(beforeStop.nodes.find((n) => n.id === 'cmd:RestartCmd')?.status).toBe('success');
+
+      await server1.stop();
+
+      const server2 = new PipelineServer({ port: 0, storeFileName: tmpFile });
+      server2.registerCommandHandlers([handler]);
+      server2.registerPipeline(pipeline);
+      await server2.start();
+
+      const afterRestart = await fetchAs<PipelineResponse>(
+        `http://localhost:${server2.port}/pipeline?correlationId=${session1}`,
+      );
+      expect(afterRestart.nodes.find((n) => n.id === 'cmd:RestartCmd')?.status).toBe('success');
+      expect(afterRestart.nodes.find((n) => n.id === 'cmd:RestartCmd')?.endedCount).toBe(1);
+
+      await server2.stop();
+      fs.unlinkSync(tmpFile);
+    });
+
+    it('should create new session on restart while old session remains queryable', async () => {
+      const tmpFile = path.join(os.tmpdir(), `pipeline-test-${nanoid()}.db`);
+      const handler = {
+        name: 'SessionCmd',
+        events: ['SessionDone'],
+        handle: async () => ({ type: 'SessionDone', data: {} }),
+      };
+      const pipeline = define('test').on('Trigger').emit('SessionCmd', {}).build();
+
+      const server1 = new PipelineServer({ port: 0, storeFileName: tmpFile });
+      server1.registerCommandHandlers([handler]);
+      server1.registerPipeline(pipeline);
+      await server1.start();
+
+      const initial = await fetchAs<PipelineResponse>(`http://localhost:${server1.port}/pipeline`);
+      const session1 = initial.latestRun!;
+
+      await fetch(`http://localhost:${server1.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'SessionCmd', data: {} }),
+      });
+      await new Promise((r) => setTimeout(r, 200));
+
+      await server1.stop();
+
+      const server2 = new PipelineServer({ port: 0, storeFileName: tmpFile });
+      server2.registerCommandHandlers([handler]);
+      server2.registerPipeline(pipeline);
+      await server2.start();
+
+      const restored = await fetchAs<PipelineResponse>(`http://localhost:${server2.port}/pipeline`);
+      expect(restored.latestRun).toBe(session1);
+
+      await fetch(`http://localhost:${server2.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'RestartPipeline', data: {} }),
+      });
+      await new Promise((r) => setTimeout(r, 100));
+
+      const afterNewSession = await fetchAs<PipelineResponse>(`http://localhost:${server2.port}/pipeline`);
+      const session2 = afterNewSession.latestRun!;
+      expect(session2).not.toBe(session1);
+
+      const oldSessionData = await fetchAs<PipelineResponse>(
+        `http://localhost:${server2.port}/pipeline?correlationId=${session1}`,
+      );
+      expect(oldSessionData.nodes.find((n) => n.id === 'cmd:SessionCmd')?.status).toBe('success');
+
+      const newSessionData = await fetchAs<PipelineResponse>(
+        `http://localhost:${server2.port}/pipeline?correlationId=${session2}`,
+      );
+      expect(newSessionData.nodes.find((n) => n.id === 'cmd:SessionCmd')?.status).toBe('idle');
+
+      await server2.stop();
+      fs.unlinkSync(tmpFile);
+    });
+  });
+
+  describe('RestartPipeline command', () => {
+    it('should emit PipelineRestarted event when RestartPipeline command is sent', async () => {
+      const server = new PipelineServer({ port: 0 });
+      await server.start();
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'RestartPipeline', data: {} }),
+      });
+
+      await new Promise((r) => setTimeout(r, 100));
+
+      const msgs = await fetchAs<StoredMessage[]>(`http://localhost:${server.port}/messages`);
+      const restartedEvent = msgs.find((m) => m.message.type === 'PipelineRestarted');
+      expect(restartedEvent).toBeDefined();
+
+      await server.stop();
+    });
+  });
+
+  describe('session-based status tracking', () => {
+    it('should not overwrite session status when sub-commands use different correlationIds', async () => {
+      const parentHandler = {
+        name: 'ParentCmd',
+        events: ['ParentDone'],
+        handle: async (
+          _cmd: { data: Record<string, unknown> },
+          ctx?: { sendCommand: (type: string, data: unknown, correlationId?: string) => Promise<void> },
+        ) => {
+          if (ctx !== undefined) {
+            await ctx.sendCommand('ChildCmd', { index: 0 }, 'sub-0');
+            await ctx.sendCommand('ChildCmd', { index: 1 }, 'sub-1');
+            await ctx.sendCommand('ChildCmd', { index: 2 }, 'sub-2');
+          }
+          return { type: 'ParentDone', data: {} };
+        },
+      };
+      const childHandler = {
+        name: 'ChildCmd',
+        events: ['ChildDone'],
+        handle: async () => ({ type: 'ChildDone', data: {} }),
+      };
+      const pipeline = define('test').on('Trigger').emit('ParentCmd', {}).build();
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers([parentHandler, childHandler]);
+      server.registerPipeline(pipeline);
+      await server.start();
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'ParentCmd', data: {} }),
+      });
+
+      await new Promise((r) => setTimeout(r, 200));
+
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
+      expect(data.latestRun).not.toBe('sub-0');
+      expect(data.latestRun).not.toBe('sub-1');
+      expect(data.latestRun).not.toBe('sub-2');
+      const parentNode = data.nodes.find((n) => n.id === 'cmd:ParentCmd');
+      expect(parentNode?.status).toBe('success');
+
+      await server.stop();
+    });
+
+    it('should count sub-command items under unified session view', async () => {
+      const parentHandler = {
+        name: 'ParentCmd',
+        events: ['ParentDone'],
+        handle: async (
+          _cmd: { data: Record<string, unknown> },
+          ctx?: { sendCommand: (type: string, data: unknown, correlationId?: string) => Promise<void> },
+        ) => {
+          if (ctx !== undefined) {
+            await ctx.sendCommand('ChildCmd', { index: 0 }, 'sub-0');
+            await ctx.sendCommand('ChildCmd', { index: 1 }, 'sub-1');
+            await ctx.sendCommand('ChildCmd', { index: 2 }, 'sub-2');
+          }
+          return { type: 'ParentDone', data: {} };
+        },
+      };
+      const childHandler = {
+        name: 'ChildCmd',
+        events: ['ChildDone'],
+        handle: async () => ({ type: 'ChildDone', data: {} }),
+      };
+      const pipeline = define('test')
+        .on('Trigger')
+        .emit('ParentCmd', {})
+        .on('ChildDone')
+        .handle(async () => {})
+        .build();
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers([parentHandler, childHandler]);
+      server.registerPipeline(pipeline);
+      server.registerItemKeyExtractor('ChildCmd', (d) => String((d as { index: number }).index));
+      await server.start();
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'ParentCmd', data: {} }),
+      });
+
+      await new Promise((r) => setTimeout(r, 200));
+
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
+      const childNode = data.nodes.find((n) => n.id === 'cmd:ChildCmd');
+      expect(childNode?.endedCount).toBe(3);
+
+      await server.stop();
+    });
+  });
 });