inspeffct 1.0.3 → 1.0.5

package/dist/bin.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import * as NodeRuntime from '@effect/platform-node/NodeRuntime';
 import * as NodeServices from '@effect/platform-node/NodeServices';
-import * as Effect8 from 'effect/Effect';
-import * as Command5 from 'effect/unstable/cli/Command';
-import * as Argument2 from 'effect/unstable/cli/Argument';
-import * as Context3 from 'effect/Context';
+import * as Effect10 from 'effect/Effect';
+import * as Command6 from 'effect/unstable/cli/Command';
+import * as Argument3 from 'effect/unstable/cli/Argument';
+import * as Context4 from 'effect/Context';
 import * as Fiber from 'effect/Fiber';
 import * as FileSystem from 'effect/FileSystem';
-import * as Layer7 from 'effect/Layer';
+import * as Layer8 from 'effect/Layer';
 import * as Schema from 'effect/Schema';
 import * as Stream from 'effect/Stream';
 import * as Formatter from 'effect/Formatter';
@@ -20,10 +20,11 @@ import * as Queue2 from 'effect/Queue';
 import * as Socket from 'effect/unstable/socket/Socket';
 import * as Chunk from 'effect/Chunk';
 import * as Ref from 'effect/Ref';
+import * as Random from 'effect/Random';
 import * as SqliteClient from '@effect/sql-sqlite-node/SqliteClient';
 import * as Struct5 from 'effect/Struct';
 import * as Migrator from 'effect/unstable/sql/Migrator';
-import * as SqlClient3 from 'effect/unstable/sql/SqlClient';
+import * as SqlClient5 from 'effect/unstable/sql/SqlClient';
 import * as SqlSchema from 'effect/unstable/sql/SqlSchema';
 import * as SchemaGetter from 'effect/SchemaGetter';
 import { flow } from 'effect/Function';
@@ -35,9 +36,9 @@ import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import * as Console2 from 'effect/Console';
 import * as Option3 from 'effect/Option';
 import * as ChildProcess from 'effect/unstable/process/ChildProcess';
-import * as Console from 'effect/Console';
 import * as Duration from 'effect/Duration';
 import * as Graph from 'effect/Graph';
 
@@ -195,17 +196,17 @@ Schema.toCodecJson(
     CaptureCurrentFibersRequest
   ]).annotate({ identifier: "InMessage" })
 );
-var BootloaderPath = class extends Context3.Service()("inspeffct/BootloaderPath") {
+var BootloaderPath = class extends Context4.Service()("inspeffct/BootloaderPath") {
 };
-var getPath = Effect8.map(BootloaderPath, (service) => service.path);
-var computeBootloaderPath = Effect8.gen(function* () {
+var getPath = Effect10.map(BootloaderPath, (service) => service.path);
+var computeBootloaderPath = Effect10.gen(function* () {
   const path2 = yield* Path.Path;
   const binDir = path2.dirname(import.meta.url.replace("file://", ""));
   return path2.join(binDir, "bootloader.cjs");
 });
-var layer = Layer7.effect(
+var layer = Layer8.effect(
   BootloaderPath,
-  Effect8.map(computeBootloaderPath, (path2) => BootloaderPath.of({ path: path2 }))
+  Effect10.map(computeBootloaderPath, (path2) => BootloaderPath.of({ path: path2 }))
 );
 var CdpRequest = Schema.Struct({
   id: Schema.Number,
@@ -236,13 +237,13 @@ var CdpError = class extends Schema.TaggedErrorClass()("CdpError", {
   code: Schema.optional(Schema.Number)
 }) {
 };
-var CdpClient = class extends Context3.Service()("inspeffct/CdpClient") {
+var CdpClient = class extends Context4.Service()("inspeffct/CdpClient") {
 };
 var isCdpEvent = (msg) => typeof msg === "object" && msg !== null && "method" in msg && typeof msg.method === "string" && !("id" in msg);
 var isCdpResponse = (msg) => typeof msg === "object" && msg !== null && "id" in msg && typeof msg.id === "number";
-var makeConnection = (url) => Effect8.gen(function* () {
+var makeConnection = (url) => Effect10.gen(function* () {
   const socket = yield* Socket.makeWebSocket(url).pipe(
-    Effect8.mapError((e) => new CdpError({ message: `Failed to connect to ${url}: ${e}` }))
+    Effect10.mapError((e) => new CdpError({ message: `Failed to connect to ${url}: ${e}` }))
   );
   const outgoing = yield* Queue2.unbounded();
   const eventsPubSub = yield* PubSub2.unbounded();
@@ -256,14 +257,14 @@ var makeConnection = (url) => Effect8.gen(function* () {
       })
     ),
     Stream.runForEach(
-      (msg) => Effect8.gen(function* () {
+      (msg) => Effect10.gen(function* () {
         if (isCdpResponse(msg)) {
           const resume = pendingRequests.get(msg.id);
           if (resume) {
             pendingRequests.delete(msg.id);
             if (msg.error) {
               resume(
-                Effect8.fail(
+                Effect10.fail(
                   new CdpError({
                     message: msg.error.message,
                     code: msg.error.code
@@ -271,28 +272,28 @@ var makeConnection = (url) => Effect8.gen(function* () {
                 )
               );
             } else {
-              resume(Effect8.succeed(msg.result));
+              resume(Effect10.succeed(msg.result));
             }
           }
         }
         if (isCdpEvent(msg)) {
           const decoded = yield* Schema.decodeUnknownEffect(CdpEvent)(msg).pipe(
-            Effect8.mapError((error) => new CdpError({ message: String(error) }))
+            Effect10.mapError((error) => new CdpError({ message: String(error) }))
           );
           yield* PubSub2.publish(eventsPubSub, decoded);
         }
-      }).pipe(Effect8.catchCause(Effect8.logDebug))
+      }).pipe(Effect10.catchCause(Effect10.logDebug))
     ),
-    Effect8.ensuring(Queue2.shutdown(outgoing)),
-    Effect8.catchCause(Effect8.logDebug),
-    Effect8.forkScoped
+    Effect10.ensuring(Queue2.shutdown(outgoing)),
+    Effect10.catchCause(Effect10.logDebug),
+    Effect10.forkScoped
   );
   const request = (method, params) => {
     const id = nextId++;
-    return Effect8.callback((resume) => {
+    return Effect10.callback((resume) => {
       pendingRequests.set(id, resume);
       Queue2.offerUnsafe(outgoing, { id, method, params });
-      return Effect8.sync(() => {
+      return Effect10.sync(() => {
         pendingRequests.delete(id);
       });
     });
@@ -304,19 +305,36 @@ var makeConnection = (url) => Effect8.gen(function* () {
     events
   };
 });
-var layer2 = Layer7.effect(
+var layer2 = Layer8.effect(
   CdpClient,
-  Effect8.gen(function* () {
+  Effect10.gen(function* () {
     const wsConstructor = yield* Socket.WebSocketConstructor;
     return CdpClient.of({
       connect: (url) => makeConnection(url).pipe(
-        Effect8.provideService(Socket.WebSocketConstructor, wsConstructor)
+        Effect10.provideService(Socket.WebSocketConstructor, wsConstructor)
       )
     });
   })
 ).pipe(
-  Layer7.provide(NodeSocket.layerWebSocketConstructor)
+  Layer8.provide(NodeSocket.layerWebSocketConstructor)
 );
+var randomByte = Random.nextIntBetween(0, 256, { halfOpen: true });
+var randomUUID = Effect10.gen(function* () {
+  const bytes = yield* Effect10.all(Array.from({ length: 16 }, () => randomByte));
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytes.map((byte) => byte.toString(16).padStart(2, "0"));
+  return [
+    hex.slice(0, 4).join(""),
+    hex.slice(4, 6).join(""),
+    hex.slice(6, 8).join(""),
+    hex.slice(8, 10).join(""),
+    hex.slice(10, 16).join("")
+  ].join("-");
+});
+var RunId = class extends Context4.Service()("inspeffct/RunId") {
+};
+var layer3 = Layer8.effect(RunId, randomUUID);
 var isSchema = (u) => typeof u === "object" && u !== null && "ast" in u;
 var getMembers = (schema) => "members" in schema && Array.isArray(schema.members) ? schema.members : "cases" in schema ? Object.values(schema.cases) : [schema];
 var evolveNested = (schema, evolve2) => {
@@ -435,8 +453,8 @@ var encodeStruct = (config) => (self) => {
     })
   );
 };
-var create_otel_tables_default = Effect8.gen(function* () {
-  const sql = yield* SqlClient3.SqlClient;
+var create_otel_tables_default = Effect10.gen(function* () {
+  const sql = yield* SqlClient5.SqlClient;
   yield* sql`
     CREATE TABLE spans (
       span_id TEXT PRIMARY KEY,
@@ -457,15 +475,15 @@ var create_otel_tables_default = Effect8.gen(function* () {
       dropped_links_count INTEGER NOT NULL DEFAULT 0,
       is_external INTEGER NOT NULL DEFAULT 0
     )
-  `.pipe(Effect8.withSpan("create_spans_table"));
-  yield* sql`CREATE INDEX idx_spans_trace_id ON spans(trace_id)`.pipe(Effect8.withSpan("create_idx_spans_trace_id"));
+  `.pipe(Effect10.withSpan("create_spans_table"));
+  yield* sql`CREATE INDEX idx_spans_trace_id ON spans(trace_id)`.pipe(Effect10.withSpan("create_idx_spans_trace_id"));
   yield* sql`CREATE INDEX idx_spans_start_time ON spans(start_time)`.pipe(
-    Effect8.withSpan("create_idx_spans_start_time")
+    Effect10.withSpan("create_idx_spans_start_time")
   );
-  yield* sql`CREATE INDEX idx_spans_name ON spans(name)`.pipe(Effect8.withSpan("create_idx_spans_name"));
-  yield* sql`CREATE INDEX idx_spans_parent ON spans(parent_span_id)`.pipe(Effect8.withSpan("create_idx_spans_parent"));
+  yield* sql`CREATE INDEX idx_spans_name ON spans(name)`.pipe(Effect10.withSpan("create_idx_spans_name"));
+  yield* sql`CREATE INDEX idx_spans_parent ON spans(parent_span_id)`.pipe(Effect10.withSpan("create_idx_spans_parent"));
   yield* sql`CREATE INDEX idx_spans_running ON spans(span_id) WHERE end_time IS NULL`.pipe(
-    Effect8.withSpan("create_idx_spans_running")
+    Effect10.withSpan("create_idx_spans_running")
   );
   yield* sql`
     CREATE TABLE span_events (
@@ -477,9 +495,9 @@ var create_otel_tables_default = Effect8.gen(function* () {
       attributes TEXT NOT NULL DEFAULT '{}',
       dropped_attributes_count INTEGER NOT NULL DEFAULT 0
     )
-  `.pipe(Effect8.withSpan("create_span_events_table"));
+  `.pipe(Effect10.withSpan("create_span_events_table"));
   yield* sql`CREATE INDEX idx_span_events_span ON span_events(span_id)`.pipe(
-    Effect8.withSpan("create_idx_span_events_span")
+    Effect10.withSpan("create_idx_span_events_span")
   );
   yield* sql`
     CREATE TABLE span_links (
@@ -491,13 +509,22 @@ var create_otel_tables_default = Effect8.gen(function* () {
       attributes TEXT NOT NULL DEFAULT '{}',
       dropped_attributes_count INTEGER NOT NULL DEFAULT 0
     )
-  `.pipe(Effect8.withSpan("create_span_links_table"));
+  `.pipe(Effect10.withSpan("create_span_links_table"));
   yield* sql`CREATE INDEX idx_span_links_span ON span_links(span_id)`.pipe(
-    Effect8.withSpan("create_idx_span_links_span")
+    Effect10.withSpan("create_idx_span_links_span")
+  );
+});
+var create_span_exits_table_default = Effect10.void;
+var simplify_span_exits_default = Effect10.void;
+var add_run_id_default = Effect10.gen(function* () {
+  const sql = yield* SqlClient5.SqlClient;
+  yield* sql`ALTER TABLE spans ADD COLUMN run_id TEXT NOT NULL DEFAULT ''`.pipe(
+    Effect10.withSpan("add_spans_run_id")
+  );
+  yield* sql`CREATE INDEX idx_spans_run_id ON spans(run_id)`.pipe(
+    Effect10.withSpan("create_idx_spans_run_id")
   );
 });
-var create_span_exits_table_default = Effect8.void;
-var simplify_span_exits_default = Effect8.void;
 
 // src/services/Storage.ts
 var SpanExitJson = Schema.toCodecJson(SpanExit);
@@ -567,6 +594,7 @@ var DbExternalSpan = ExternalSpan.pipe(
 );
 var DbAnySpan = Schema.Union([DbSpan, DbExternalSpan]);
 var TraceSummary = Schema.Struct({
+  run_id: Schema.String,
   trace_id: Schema.String,
   span_count: NumberFromBigInt,
   root_span_name: Schema.NullOr(Schema.String),
@@ -586,40 +614,44 @@ var DbSpanLink = SpanLink.mapFields(
     linkedTraceId: "linked_trace_id"
   })
 );
-var Storage = class extends Context3.Service()("inspeffct/Storage") {
+var Storage = class extends Context4.Service()("inspeffct/Storage") {
 };
 var MigrationsLoader = Migrator.fromRecord({
   "0001_create_otel_tables": create_otel_tables_default,
   "0002_create_span_exits_table": create_span_exits_table_default,
-  "0003_simplify_span_exits": simplify_span_exits_default
+  "0003_simplify_span_exits": simplify_span_exits_default,
+  "0004_add_run_id": add_run_id_default
 });
 var runMigrations = Migrator.make({})({
   loader: MigrationsLoader
 });
-var layer4 = (config) => Layer7.effectContext(
-  Effect8.gen(function* () {
+var layer5 = (config) => Layer8.effectContext(
+  Effect10.gen(function* () {
     const sql = yield* SqliteClient.SqliteClient;
     yield* runMigrations;
     const storage = Storage.of({
-      persistSpan: (span) => Effect8.gen(function* () {
+      persistSpan: (span, runId) => Effect10.gen(function* () {
         const changed = yield* (
           // @ts-ignore TS28 false positive from SqlSchema service inference
           SqlSchema.findOne({
             Request: DbAnySpan,
             Result: Schema.Struct({ span_id: Schema.String }),
-            execute: (db) => sql`
-                    INSERT INTO spans ${sql.insert(db)}
+            execute: (db) => {
+              const row = { ...db, run_id: runId };
+              return sql`
+                    INSERT INTO spans ${sql.insert(row)}
                     ON CONFLICT(span_id) DO UPDATE SET
-                      ${sql.update(db, ["span_id"])}
+                      ${sql.update(row, ["span_id"])}
                     WHERE
                       is_external = 1 OR
                       (end_time IS NULL AND excluded.is_external = 0)
                     RETURNING span_id
-                  `
+                  `;
+            }
           })(span).pipe(
-            Effect8.as(true),
-            Effect8.catch(() => Effect8.succeed(false)),
-            Effect8.provideService(SqlClient3.SafeIntegers, true)
+            Effect10.as(true),
+            Effect10.catch(() => Effect10.succeed(false)),
+            Effect10.provideService(SqlClient5.SafeIntegers, true)
           )
         );
         return changed;
@@ -644,7 +676,7 @@ var layer4 = (config) => Layer7.effectContext(
                 )
               `
         }),
-        Effect8.provideService(SqlClient3.SafeIntegers, true)
+        Effect10.provideService(SqlClient5.SafeIntegers, true)
       ),
       getSpansByTraceId: (traceId) => (
         // @ts-ignore TS28 false positive from SqlSchema service inference
@@ -658,7 +690,7 @@ var layer4 = (config) => Layer7.effectContext(
                 ORDER BY s.start_time ASC
               `
         })(traceId).pipe(
-          Effect8.provideService(SqlClient3.SafeIntegers, true)
+          Effect10.provideService(SqlClient5.SafeIntegers, true)
         )
       ),
       getRecentSpans: (limit = 100) => (
@@ -673,7 +705,7 @@ var layer4 = (config) => Layer7.effectContext(
                 LIMIT ${l}
               `
         })(limit).pipe(
-          Effect8.provideService(SqlClient3.SafeIntegers, true)
+          Effect10.provideService(SqlClient5.SafeIntegers, true)
         )
       ),
       getSpanEvents: flow(
@@ -696,7 +728,7 @@ var layer4 = (config) => Layer7.effectContext(
                 ORDER BY time ASC
               `
         }),
-        Effect8.provideService(SqlClient3.SafeIntegers, true)
+        Effect10.provideService(SqlClient5.SafeIntegers, true)
       ),
       persistSpanLink: SqlSchema.void({
         Request: DbSpanLink,
@@ -725,15 +757,24 @@ var layer4 = (config) => Layer7.effectContext(
       getTraces: (filters = {}) => SqlSchema.findAll({
         Request: Schema.Struct({
           limit: Schema.optional(Schema.Number),
+          runId: Schema.optional(Schema.String),
           since: Schema.optional(Schema.BigInt),
           status: Schema.optional(Schema.Number)
         }),
         Result: TraceSummary,
         execute: (req) => sql`
                 SELECT 
+                  s.run_id,
                   s.trace_id,
                   COUNT(*) as span_count,
-                  (SELECT name FROM spans WHERE trace_id = s.trace_id AND parent_span_id IS NULL LIMIT 1) as root_span_name,
+                  (
+                    SELECT name
+                    FROM spans
+                    WHERE trace_id = s.trace_id
+                      AND run_id = s.run_id
+                      AND parent_span_id IS NULL
+                    LIMIT 1
+                  ) as root_span_name,
                   MIN(s.start_time) as start_time,
                   MAX(s.end_time) as end_time,
                   MAX(
@@ -745,6 +786,7 @@ var layer4 = (config) => Layer7.effectContext(
                   ) as status
                 FROM spans s
                 WHERE ${sql.and([
+          req.runId !== void 0 ? sql`s.run_id = ${req.runId}` : sql`1=1`,
           req.since !== void 0 ? sql`s.start_time >= ${req.since}` : sql`1=1`,
           req.status !== void 0 ? sql`
                       CASE
@@ -754,12 +796,12 @@ var layer4 = (config) => Layer7.effectContext(
                       END = ${req.status}
                     ` : sql`1=1`
         ])}
-                GROUP BY s.trace_id
+                GROUP BY s.run_id, s.trace_id
                 ORDER BY start_time DESC
                 ${req.limit !== void 0 ? sql`LIMIT ${req.limit}` : sql``}
               `
       })(filters).pipe(
-        Effect8.provideService(SqlClient3.SafeIntegers, true)
+        Effect10.provideService(SqlClient5.SafeIntegers, true)
       ),
       getSpans: (filters = {}) => (
         // @ts-ignore TS28 false positive from SqlSchema service inference
@@ -768,6 +810,8 @@ var layer4 = (config) => Layer7.effectContext(
             limit: Schema.optional(Schema.Number),
             minDuration: Schema.optional(Schema.BigInt),
             name: Schema.optional(Schema.String),
+            runId: Schema.optional(Schema.String),
+            spanId: Schema.optional(Schema.String),
             status: Schema.optional(Schema.Number),
             traceId: Schema.optional(Schema.String)
           }),
@@ -776,6 +820,8 @@ var layer4 = (config) => Layer7.effectContext(
                 SELECT s.*
                 FROM spans s
                 WHERE ${sql.and([
+            req.runId !== void 0 ? sql`s.run_id = ${req.runId}` : sql`1=1`,
+            req.spanId !== void 0 ? sql`s.span_id = ${req.spanId}` : sql`1=1`,
             req.traceId !== void 0 ? sql`s.trace_id = ${req.traceId}` : sql`1=1`,
             req.name !== void 0 ? req.name.includes("%") ? sql`s.name LIKE ${req.name}` : sql`s.name = ${req.name}` : sql`1=1`,
             req.minDuration !== void 0 ? sql`(s.end_time - s.start_time) >= ${req.minDuration}` : sql`1=1`,
@@ -791,44 +837,43 @@ var layer4 = (config) => Layer7.effectContext(
                 ${req.limit !== void 0 ? sql`LIMIT ${req.limit}` : sql``}
               `
         })(filters).pipe(
-          Effect8.provideService(SqlClient3.SafeIntegers, true)
+          Effect10.provideService(SqlClient5.SafeIntegers, true)
         )
       )
     });
-    return Context3.make(Storage, storage);
+    return Context4.make(Storage, storage);
   })
-).pipe(Layer7.provide(SqliteClient.layer(config)));
+).pipe(Layer8.provide(SqliteClient.layer(config)));
 
 // src/services/EventCollector.ts
-var EventCollector = class extends Context3.Service()("inspeffct/EventCollector") {
+var EventCollector = class extends Context4.Service()("inspeffct/EventCollector") {
 };
-var layer5 = Layer7.effect(
+var layer6 = Layer8.effect(
   EventCollector,
-  Effect8.gen(function* () {
+  Effect10.gen(function* () {
+    const runId = yield* RunId;
     const storage = yield* Storage;
     return EventCollector.of({
-      collect: (message) => Effect8.gen(function* () {
+      collect: (message) => Effect10.gen(function* () {
         switch (message._tag) {
           case "InitNotification": {
-            yield* Effect8.logDebug(
+            yield* Effect10.logDebug(
               `${message._tag} from ${message.instrumentationId} (inspectorURL: ${message.inspectorURL ?? "none"}, waitingForDebugger: ${message.waitingForDebugger})`
             );
             break;
           }
           case "TracerSpanNotification": {
             const { instrumentationId, span } = message;
-            yield* Effect8.logDebug(`${message._tag} from ${instrumentationId}`);
-            if (span._tag === "Span" && span.status._tag === "Ended") {
-              yield* storage.persistSpan(span);
-              yield* Effect8.logDebug(
-                `Persisted span ${span.name} (${span.spanId}) with exit ${span.status.exit._tag} to storage`
-              );
-            }
+            yield* Effect10.logDebug(`${message._tag} from ${instrumentationId}`);
+            yield* storage.persistSpan(span, runId);
+            yield* Effect10.logDebug(
+              `Persisted span (${span.traceId}, ${span.spanId}) to storage`
+            );
             break;
           }
           case "TracerSpanEventNotification": {
             const { event } = message;
-            yield* Effect8.logDebug(`${message._tag} from ${message.instrumentationId}`);
+            yield* Effect10.logDebug(`${message._tag} from ${message.instrumentationId}`);
             yield* storage.persistSpanEvent({
               spanId: event.spanId,
               traceId: event.traceId,
@@ -836,14 +881,14 @@ var layer5 = Layer7.effect(
               time: event.time,
               attributes: event.attributes
             });
-            yield* Effect8.logDebug(
+            yield* Effect10.logDebug(
               `Persisted span event ${event.name} for span ${event.spanId}`
             );
             break;
           }
           case "TracerSpanLinkNotification": {
             const { link } = message;
-            yield* Effect8.logDebug(`${message._tag} from ${message.instrumentationId}`);
+            yield* Effect10.logDebug(`${message._tag} from ${message.instrumentationId}`);
             yield* storage.persistSpanLink({
               spanId: link.spanId,
               traceId: link.traceId,
@@ -851,7 +896,7 @@ var layer5 = Layer7.effect(
               linkedTraceId: link.linkedTraceId,
               attributes: link.attributes
             });
-            yield* Effect8.logDebug(
+            yield* Effect10.logDebug(
               `Persisted span link from ${link.spanId} to ${link.linkedSpanId}`
             );
             break;
@@ -860,48 +905,48 @@ var layer5 = Layer7.effect(
           case "VariableReferenceInfo":
           case "ResourcesForRequestReleased":
           case "CurrentFibersInfo": {
-            yield* Effect8.logDebug(`${message._tag} from ${message.instrumentationId}`);
+            yield* Effect10.logDebug(`${message._tag} from ${message.instrumentationId}`);
             break;
           }
         }
-      }).pipe(Effect8.catch((error) => Effect8.logWarning(`Failed to persist event: ${error}`)))
+      }).pipe(Effect10.catch((error) => Effect10.logWarning(`Failed to persist event: ${error}`)))
     });
   })
 );
-Layer7.succeed(
+Layer8.succeed(
   EventCollector,
   EventCollector.of({
     collect: (message) => {
       if (message._tag === "InitNotification") {
-        return Effect8.logDebug(
+        return Effect10.logDebug(
           `${message._tag} from ${message.instrumentationId} (inspectorURL: ${message.inspectorURL ?? "none"}, waitingForDebugger: ${message.waitingForDebugger})`
         );
       }
-      return Effect8.logDebug(`${message._tag} from ${message.instrumentationId}`);
+      return Effect10.logDebug(`${message._tag} from ${message.instrumentationId}`);
     }
   })
 );
-Layer7.effect(
+Layer8.effect(
   EventCollector,
-  Effect8.gen(function* () {
+  Effect10.gen(function* () {
     const messagesRef = yield* Ref.make(Chunk.empty());
     return EventCollector.of({
       collect: (message) => Ref.update(messagesRef, Chunk.append(message)),
-      getMessages: Ref.get(messagesRef).pipe(Effect8.map(Chunk.toReadonlyArray))
+      getMessages: Ref.get(messagesRef).pipe(Effect10.map(Chunk.toReadonlyArray))
     });
   })
 );
 
 // src/services/CdpManager.ts
 var BINDING_NAME = "__inspeffct_bridge__";
-var CdpManager = class extends Context3.Service()("inspeffct/CdpManager") {
+var CdpManager = class extends Context4.Service()("inspeffct/CdpManager") {
 };
-var getBootloaderScript = Effect8.gen(function* () {
+var getBootloaderScript = Effect10.gen(function* () {
   const fs2 = yield* FileSystem.FileSystem;
   const bootloaderPath = yield* getPath;
   return yield* fs2.readFileString(bootloaderPath);
 });
-var connectAndListen = (url, bootloaderScript) => Effect8.gen(function* () {
+var connectAndListen = (url, bootloaderScript) => Effect10.gen(function* () {
   const cdp = yield* CdpClient;
   const collector = yield* EventCollector;
   const connection = yield* cdp.connect(url);
@@ -909,21 +954,21 @@ var connectAndListen = (url, bootloaderScript) => Effect8.gen(function* () {
     expression: bootloaderScript,
     contextId,
     silent: true
-  }).pipe(Effect8.ensuring(connection.request("Runtime.runIfWaitingForDebugger").pipe(Effect8.ignore({ log: true }))));
+  }).pipe(Effect10.ensuring(connection.request("Runtime.runIfWaitingForDebugger").pipe(Effect10.ignore({ log: true }))));
   const eventFiber = yield* connection.events.pipe(
     Stream.takeUntil(
       (event) => event.method === "Runtime.executionContextDestroyed" || event.method === "Runtime.executionContextsCleared" || event.method === "Inspector.detached"
     ),
     Stream.runForEach(
-      (event) => Effect8.gen(function* () {
+      (event) => Effect10.gen(function* () {
         if (event.method === "Runtime.bindingCalled") {
           const params = event.params;
           if (params.name === BINDING_NAME) {
             yield* Schema.decodeUnknownEffect(Schema.fromJsonString(OutMessage))(
               params.payload
             ).pipe(
-              Effect8.flatMap((decoded) => collector.collect(decoded)),
-              Effect8.catch(() => Effect8.logError(`Failed to decode CDP message: ${params.payload}`))
+              Effect10.flatMap((decoded) => collector.collect(decoded)),
+              Effect10.catch(() => Effect10.logError(`Failed to decode CDP message: ${params.payload}`))
             );
           }
         }
@@ -933,44 +978,44 @@ var connectAndListen = (url, bootloaderScript) => Effect8.gen(function* () {
         }
       })
     ),
-    Effect8.forkScoped
+    Effect10.forkScoped
   );
-  yield* Effect8.yieldNow;
+  yield* Effect10.yieldNow;
   yield* connection.request("Runtime.addBinding", { name: BINDING_NAME });
   yield* connection.request("Runtime.enable");
   yield* connection.request("Runtime.runIfWaitingForDebugger");
-  yield* Effect8.logDebug(`CDP connected: ${url}`);
+  yield* Effect10.logDebug(`CDP connected: ${url}`);
   yield* Fiber.join(eventFiber);
 });
-var layer6 = Layer7.effect(
+var layer7 = Layer8.effect(
   CdpManager,
-  Effect8.gen(function* () {
+  Effect10.gen(function* () {
     const bootloaderScript = yield* getBootloaderScript;
     const cdpClient = yield* CdpClient;
     const collector = yield* EventCollector;
-    const managerScope = yield* Effect8.scope;
+    const managerScope = yield* Effect10.scope;
     const activeConnections = /* @__PURE__ */ new Map();
     return CdpManager.of({
-      connect: (url) => Effect8.gen(function* () {
+      connect: (url) => Effect10.gen(function* () {
         if (activeConnections.has(url)) {
           return;
         }
         activeConnections.set(url, true);
-        yield* Effect8.logDebug(`Connecting to CDP: ${url}`);
+        yield* Effect10.logDebug(`Connecting to CDP: ${url}`);
         yield* connectAndListen(url, bootloaderScript).pipe(
-          Effect8.provideService(CdpClient, cdpClient),
-          Effect8.provideService(EventCollector, collector),
-          Effect8.scoped,
-          Effect8.catchCause((cause) => Effect8.logError(`CDP connection failed for ${url}: ${cause}`)),
+          Effect10.provideService(CdpClient, cdpClient),
+          Effect10.provideService(EventCollector, collector),
+          Effect10.scoped,
+          Effect10.catchCause((cause) => Effect10.logError(`CDP connection failed for ${url}: ${cause}`)),
           // Always remove from tracking when done (success, failure, or interruption)
-          Effect8.ensuring(
-            Effect8.sync(() => {
+          Effect10.ensuring(
+            Effect10.sync(() => {
               activeConnections.delete(url);
             }).pipe(
-              Effect8.tap(() => Effect8.logDebug(`CDP disconnected: ${url}`))
+              Effect10.tap(() => Effect10.logDebug(`CDP disconnected: ${url}`))
             )
           ),
-          Effect8.forkIn(managerScope)
+          Effect10.forkIn(managerScope)
         );
       })
     });
@@ -978,12 +1023,12 @@ var layer6 = Layer7.effect(
 );
 var namedSocketDirectory = os.platform() === "win32" ? "\\\\.\\pipe\\" : os.tmpdir();
 var pipeCounter = 0;
-var generateIpcPath = Effect8.sync(() => {
+var generateIpcPath = Effect10.sync(() => {
   const randomHex = crypto.randomBytes(4).toString("hex");
   const pipeName = `inspeffct.${process.pid}-${randomHex}-${pipeCounter++}.sock`;
   return path.join(namedSocketDirectory, pipeName);
 });
-var cleanupSocketFile = (socketPath) => Effect8.sync(() => {
+var cleanupSocketFile = (socketPath) => Effect10.sync(() => {
   if (os.platform() !== "win32") {
     try {
       fs.unlinkSync(socketPath);
@@ -991,7 +1036,7 @@ var cleanupSocketFile = (socketPath) => Effect8.sync(() => {
     }
   }
 });
-var IpcServer = class extends Context3.Service()("inspeffct/IpcServer") {
+var IpcServer = class extends Context4.Service()("inspeffct/IpcServer") {
 };
 var tryParseMessage = (message) => {
   try {
@@ -1003,13 +1048,13 @@ var tryParseMessage = (message) => {
 };
 var ACK_SUCCESS = new Uint8Array([0]);
 var parseMessages = (socket) => Stream.unwrap(
-  Effect8.gen(function* () {
+  Effect10.gen(function* () {
     const write = yield* socket.writer;
     const decoder = new TextDecoder();
     let buffer = "";
     return Stream.callback(
       (queue) => socket.run(
-        (data) => Effect8.gen(function* () {
+        (data) => Effect10.gen(function* () {
           buffer += decoder.decode(data);
           let nullIndex;
           while ((nullIndex = buffer.indexOf("\0")) !== -1) {
@@ -1024,13 +1069,13 @@ var parseMessages = (socket) => Stream.unwrap(
             }
           }
         }),
-        { onOpen: Effect8.void }
+        { onOpen: Effect10.void }
       ).pipe(
-        Effect8.andThen(() => {
+        Effect10.andThen(() => {
           if (buffer.length > 0) {
             const decoded = tryParseMessage(buffer);
             if (decoded) {
-              return Queue2.offer(queue, decoded).pipe(Effect8.andThen(Queue2.end(queue)));
+              return Queue2.offer(queue, decoded).pipe(Effect10.andThen(Queue2.end(queue)));
             }
           }
           return Queue2.end(queue);
@@ -1039,18 +1084,18 @@ var parseMessages = (socket) => Stream.unwrap(
     );
   })
 );
-var layer7 = Layer7.effect(
+var layer8 = Layer8.effect(
   IpcServer,
-  Effect8.gen(function* () {
+  Effect10.gen(function* () {
     const ipcPath = yield* generateIpcPath;
-    yield* Effect8.addFinalizer(() => cleanupSocketFile(ipcPath));
+    yield* Effect10.addFinalizer(() => cleanupSocketFile(ipcPath));
     const server = yield* NodeSocketServer.make({ path: ipcPath });
     const pubsub = yield* PubSub2.unbounded();
     yield* server.run(
       (socket) => parseMessages(socket).pipe(
         Stream.runForEach((message) => PubSub2.publish(pubsub, message))
       )
-    ).pipe(Effect8.catchCause(Effect8.logDebug), Effect8.forkScoped);
+    ).pipe(Effect10.catchCause(Effect10.logDebug), Effect10.forkScoped);
     const messages = Stream.fromPubSub(pubsub);
     const subscribe3 = PubSub2.subscribe(pubsub);
     return IpcServer.of({
@@ -1060,9 +1105,9 @@ var layer7 = Layer7.effect(
     });
   })
 );
-Effect8.map(IpcServer, (server) => server.path);
-Effect8.map(IpcServer, (server) => server.messages);
-Effect8.flatMap(IpcServer, (server) => server.subscribe);
+Effect10.map(IpcServer, (server) => server.path);
+Effect10.map(IpcServer, (server) => server.messages);
+Effect10.flatMap(IpcServer, (server) => server.subscribe);
 
 // src/cli/options.ts
 var dataOption = Flag3.string("data").pipe(
@@ -1094,45 +1139,50 @@ var buildEnv = (bootloaderPath, ipcPath) => {
   };
 };
 var makeServicesLayer = (dataPath) => {
-  const storageLayer = layer4({ filename: dataPath });
-  const eventCollectorLayer = layer5.pipe(Layer7.provide(storageLayer));
-  const bootloaderPathLayer = layer.pipe(Layer7.provide(NodePath.layer));
-  return Layer7.mergeAll(
-    layer7,
-    eventCollectorLayer,
+  const runIdLayer = layer3;
+  const storageLayer = layer5({ filename: dataPath });
+  const eventCollectorLayer = layer6.pipe(
+    Layer8.provide(runIdLayer),
+    Layer8.provide(storageLayer)
+  );
+  const bootloaderPathLayer = layer.pipe(Layer8.provide(NodePath.layer));
+  return Layer8.mergeAll(
+    layer8,
+    runIdLayer,
     bootloaderPathLayer,
-    layer6.pipe(
-      Layer7.provide(eventCollectorLayer),
-      Layer7.provide(layer2),
-      Layer7.provide(bootloaderPathLayer),
-      Layer7.provide(NodeFileSystem.layer),
-      Layer7.provide(NodePath.layer)
+    layer7.pipe(
+      Layer8.provide(layer2),
+      Layer8.provide(bootloaderPathLayer),
+      Layer8.provide(NodeFileSystem.layer),
+      Layer8.provide(NodePath.layer)
     )
+  ).pipe(
+    Layer8.provideMerge(eventCollectorLayer)
   );
 };
-var makeReadOnlyLayer = (dataPath) => layer4({ filename: dataPath });
+var makeReadOnlyLayer = (dataPath) => layer5({ filename: dataPath });
 
 // src/cli/connect.ts
-var command = Command5.make(
+var command = Command6.make(
   "connect",
   {
     data: dataOption,
-    url: Argument2.string("url").pipe(
-      Argument2.withDescription("WebSocket URL of the inspector (ws://...)")
+    url: Argument3.string("url").pipe(
+      Argument3.withDescription("WebSocket URL of the inspector (ws://...)")
     )
   },
-  ({ data, url }) => Effect8.gen(function* () {
-    yield* Effect8.logDebug(`Connecting to URL: ${url}`);
-    yield* Effect8.logDebug(`Data file: ${data}`);
+  ({ data, url }) => Effect10.gen(function* () {
+    yield* Effect10.logDebug(`Connecting to URL: ${url}`);
+    yield* Effect10.logDebug(`Data file: ${data}`);
     const cdpManager = yield* CdpManager;
     yield* cdpManager.connect(url);
-    yield* Effect8.logInfo(`Connected to ${url}`);
-    return yield* Effect8.never;
+    yield* Effect10.logInfo(`Connected to ${url}`);
+    return yield* Effect10.never;
   }).pipe(
-    Effect8.scoped,
-    Effect8.provide(makeServicesLayer(data))
+    Effect10.scoped,
+    Effect10.provide(makeServicesLayer(data))
   )
-).pipe(Command5.withDescription("Connect to an existing inspector endpoint"));
+).pipe(Command6.withDescription("Connect to an existing CDP inspector endpoint"));
 var NODE_INSPECTOR_REGEX = /Debugger listening on (ws:\/\/[^\s]+)/;
 var BUN_INSPECTOR_REGEX = /https:\/\/debug\.bun\.sh\/#([^\s]+)/;
 var parseInspectorUrl = (chunk, decoder) => {
@@ -1147,7 +1197,7 @@ var parseInspectorUrl = (chunk, decoder) => {
   }
   return void 0;
 };
-var command2 = Command5.make(
+var command2 = Command6.make(
   "run",
   {
     data: dataOption,
@@ -1155,31 +1205,33 @@ var command2 = Command5.make(
       Flag3.optional,
       Flag3.withHidden
     ),
-    args: Argument2.string("command").pipe(
-      Argument2.withDescription("The command to run"),
-      Argument2.variadic({ min: 0 })
+    args: Argument3.string("command").pipe(
+      Argument3.withDescription("The command to run"),
+      Argument3.variadic({ min: 0 })
     )
   },
-  ({ args, data, encodedCommand }) => Effect8.gen(function* () {
+  ({ args, data, encodedCommand }) => Effect10.gen(function* () {
     const resolvedArgs = Option3.isSome(encodedCommand) ? JSON.parse(Buffer.from(encodedCommand.value, "base64url").toString("utf8")) : args;
     const [rawExecutable, ...commandArgs] = resolvedArgs;
     const executable = rawExecutable === "node" ? process.execPath : rawExecutable;
-    yield* Effect8.logDebug(`Running: ${executable} ${commandArgs.join(" ")}`);
-    yield* Effect8.logDebug(`Data file: ${data}`);
+    const runId = yield* RunId;
+    yield* Console2.log(`Run ID: ${runId}`);
+    yield* Effect10.logDebug(`Running: ${executable} ${commandArgs.join(" ")}`);
+    yield* Effect10.logDebug(`Data file: ${data}`);
     const bootloaderPath = yield* getPath;
-    yield* Effect8.logDebug(`Bootloader: ${bootloaderPath}`);
+    yield* Effect10.logDebug(`Bootloader: ${bootloaderPath}`);
     const ipcServer = yield* IpcServer;
-    yield* Effect8.logDebug(`IPC socket: ${ipcServer.path}`);
+    yield* Effect10.logDebug(`IPC socket: ${ipcServer.path}`);
     const collector = yield* EventCollector;
     const cdpManager = yield* CdpManager;
     const env = buildEnv(bootloaderPath, ipcServer.path);
-    yield* Effect8.logDebug(`NODE_OPTIONS: ${env.NODE_OPTIONS}`);
-    yield* Stream.runForEach(ipcServer.messages, (message) => Effect8.gen(function* () {
+    yield* Effect10.logDebug(`NODE_OPTIONS: ${env.NODE_OPTIONS}`);
+    yield* Stream.runForEach(ipcServer.messages, (message) => Effect10.gen(function* () {
       yield* collector.collect(message);
       if (message._tag === "InitNotification" && message.inspectorURL) {
         yield* cdpManager.connect(message.inspectorURL);
       }
-    })).pipe(Effect8.forkScoped);
+    })).pipe(Effect10.forkScoped);
     const cmd = ChildProcess.make(executable, commandArgs, {
       env,
       extendEnv: true,
@@ -1188,35 +1240,35 @@ var command2 = Command5.make(
       stdout: "inherit"
     });
     const childProcess = yield* cmd;
-    yield* Effect8.logDebug(`Started process with PID: ${childProcess.pid}`);
+    yield* Effect10.logDebug(`Started process with PID: ${childProcess.pid}`);
     const textDecoder = new TextDecoder();
     yield* Stream.runForEach(
       childProcess.stderr,
-      (chunk) => Effect8.gen(function* () {
-        yield* Effect8.sync(() => process.stderr.write(chunk));
+      (chunk) => Effect10.gen(function* () {
+        yield* Effect10.sync(() => process.stderr.write(chunk));
         const inspectorUrl = parseInspectorUrl(chunk, textDecoder);
         if (inspectorUrl) {
-          yield* Effect8.logDebug(`Detected inspector URL from stderr: ${inspectorUrl}`);
+          yield* Effect10.logDebug(`Detected inspector URL from stderr: ${inspectorUrl}`);
           yield* cdpManager.connect(inspectorUrl);
         }
       })
-    ).pipe(Effect8.forkScoped);
-    const forwardSignal = (signal) => Effect8.sync(() => {
+    ).pipe(Effect10.forkScoped);
+    const forwardSignal = (signal) => Effect10.sync(() => {
       process.on(signal, () => {
-        Effect8.runPromise(childProcess.kill({ killSignal: signal }).pipe(Effect8.ignore));
+        Effect10.runPromise(childProcess.kill({ killSignal: signal }).pipe(Effect10.ignore));
       });
     });
     yield* forwardSignal("SIGTERM");
     yield* forwardSignal("SIGINT");
     yield* forwardSignal("SIGHUP");
     const exitCode = yield* childProcess.exitCode;
-    yield* Effect8.logDebug(`Process exited with code: ${exitCode}`);
-    yield* Effect8.sync(() => process.exitCode = exitCode);
+    yield* Effect10.logDebug(`Process exited with code: ${exitCode}`);
+    yield* Effect10.sync(() => process.exitCode = exitCode);
   }).pipe(
-    Effect8.scoped,
-    Effect8.provide(makeServicesLayer(data))
+    Effect10.scoped,
+    Effect10.provide(makeServicesLayer(data))
   )
-).pipe(Command5.withDescription("Run a command with Effect instrumentation"));
+).pipe(Command6.withDescription("Run a command with Effect instrumentation"));
 var getSpanId = (span) => span.spanId;
 var getTraceId = (span) => span.traceId;
 var getParentSpanId = (span) => span._tag === "Span" ? span.parentSpanId : null;
@@ -1341,11 +1393,123 @@ var renderSpanGraph = (graph) => {
   return rootDocs.filter((doc) => doc.length > 0).join("\n");
 };
 
-// src/cli/spans.ts
-var command3 = Command5.make(
+// src/cli/span.ts
+var attributesToObject = (attributes) => Object.fromEntries(attributes);
+var command3 = Command6.make(
+  "span",
+  {
+    data: dataOption,
+    json: jsonOption,
+    traceId: Argument3.string("trace-id").pipe(
+      Argument3.withDescription("The trace ID containing the span")
+    ),
+    spanId: Argument3.string("span-id").pipe(
+      Argument3.withDescription("The span ID to display")
+    )
+  },
+  ({ data, json, spanId, traceId }) => Effect10.gen(function* () {
+    const storage = yield* Storage;
+    const spans = yield* storage.getSpans({ spanId, traceId });
+    const span = spans[0];
+    if (span === void 0) {
+      yield* Console2.log(`No span found for trace: ${traceId}, span: ${spanId}`);
+      return;
+    }
+    const events = yield* storage.getSpanEvents({ traceId, spanId });
+    const links = yield* storage.getSpanLinks({ traceId, spanId });
+    const startTime = getStartTime(span);
+    const endTime = getEndTime(span);
+    const durationNanos = endTime !== null ? endTime - startTime : null;
+    if (json) {
+      const output = {
+        span: {
+          spanId: getSpanId(span),
+          traceId: getTraceId(span),
+          parentSpanId: getParentSpanId(span),
+          name: getSpanName(span),
+          kind: getSpanKind(span),
+          statusCode: getStatusCode(span),
+          statusMessage: getStatusMessage(span),
+          startTime: formatTimestamp(startTime),
+          endTime: endTime !== null ? formatTimestamp(endTime) : null,
+          durationMs: durationNanos !== null ? Number(durationNanos / 1000000n) : null,
+          attributes: getAttributes(span),
+          isExternal: isExternalSpan(span)
+        },
+        events: events.map((event) => ({
+          name: event.name,
+          time: formatTimestamp(event.time),
+          attributes: attributesToObject(event.attributes)
+        })),
+        links: links.map((link) => ({
+          linkedSpanId: link.linkedSpanId,
+          linkedTraceId: link.linkedTraceId,
+          attributes: attributesToObject(link.attributes)
+        }))
+      };
+      yield* Console2.log(JSON.stringify(output, null, 2));
+    } else {
+      const fields = [
+        field("Span", getSpanId(span)),
+        field("Name", getSpanName(span)),
+        field("Trace", getTraceId(span)),
+        field("Kind", String(getSpanKind(span))),
+        field("Status", formatStatusDoc(getStatusCode(span))),
+        field("Started", formatTimestamp(startTime)),
+        field("Duration", durationNanos !== null ? formatDuration(durationNanos) : "running")
+      ];
+      const parentSpanId = getParentSpanId(span);
+      if (parentSpanId !== null) {
+        fields.push(field("Parent", parentSpanId));
+      }
+      if (endTime !== null) {
+        fields.push(field("Ended", formatTimestamp(endTime)));
+      }
+      const statusMessage = getStatusMessage(span);
+      if (statusMessage !== null) {
+        fields.push(field("Status Message", statusMessage));
+      }
+      const attrs = getAttributes(span);
+      if (Object.keys(attrs).length > 0) {
+        fields.push(field("Attrs", JSON.stringify(attrs)));
+      }
+      const eventDocs = events.length === 0 ? ["Events: none"] : [
+        `Events (${events.length}):`,
+        ...events.map((event) => {
+          const attrs2 = attributesToObject(event.attributes);
+          const lines = [`  ${event.name} @ ${formatTimestamp(event.time)}`];
+          if (Object.keys(attrs2).length > 0) {
+            lines.push(`    ${field("Attrs", JSON.stringify(attrs2))}`);
+          }
+          return lines.join("\n");
+        })
+      ];
+      const linkDocs = links.length === 0 ? ["Links: none"] : [
+        `Links (${links.length}):`,
+        ...links.map((link) => {
+          const attrs2 = attributesToObject(link.attributes);
+          const lines = [`  ${link.linkedTraceId}/${link.linkedSpanId}`];
+          if (Object.keys(attrs2).length > 0) {
+            lines.push(`    ${field("Attrs", JSON.stringify(attrs2))}`);
+          }
+          return lines.join("\n");
+        })
+      ];
+      yield* Console2.log(renderDoc([...fields, "", ...eventDocs, "", ...linkDocs].join("\n")));
+    }
+  }).pipe(
+    Effect10.scoped,
+    Effect10.provide(makeReadOnlyLayer(data))
+  )
+).pipe(Command6.withDescription("Show detailed span information"));
+var command4 = Command6.make(
   "spans",
   {
     data: dataOption,
+    runId: Flag3.string("run-id").pipe(
+      Flag3.withDescription("Filter by run ID"),
+      Flag3.optional
+    ),
     json: jsonOption,
     limit: limitOption,
     minDuration: Flag3.string("min-duration").pipe(
@@ -1356,17 +1520,21 @@ var command3 = Command5.make(
       Flag3.withDescription("Filter by span name (use % for wildcards)"),
       Flag3.optional
     ),
+    spanId: Flag3.string("span-id").pipe(
+      Flag3.withDescription("Filter by span ID"),
+      Flag3.optional
+    ),
     status: Flag3.string("status").pipe(
       Flag3.withDescription("Filter by status: ok, error, unset"),
       Flag3.optional
     ),
-    trace: Flag3.string("trace").pipe(
+    trace: Flag3.string("trace-id").pipe(
       Flag3.withAlias("t"),
       Flag3.withDescription("Filter by trace ID"),
       Flag3.optional
     )
   },
-  ({ data, json, limit, minDuration, name, status, trace }) => Effect8.gen(function* () {
+  ({ data, json, limit, minDuration, name, runId, spanId, status, trace }) => Effect10.gen(function* () {
     const storage = yield* Storage;
     let statusCode;
     if (Option3.isSome(status)) {
@@ -1381,10 +1549,12 @@ var command3 = Command5.make(
           statusCode = 0;
           break;
         default:
-          yield* Effect8.logWarning(`Unknown status: ${status.value}, ignoring filter`);
+          yield* Effect10.logWarning(`Unknown status: ${status.value}, ignoring filter`);
       }
     }
     const filters = {
+      ...Option3.isSome(runId) ? { runId: runId.value } : {},
+      ...Option3.isSome(spanId) ? { spanId: spanId.value } : {},
       ...Option3.isSome(trace) ? { traceId: trace.value } : {},
       ...Option3.isSome(name) ? { name: name.value } : {},
       ...statusCode !== void 0 ? { status: statusCode } : {},
@@ -1411,10 +1581,10 @@ var command3 = Command5.make(
           isExternal: isExternalSpan(s)
         };
       });
-      yield* Console.log(JSON.stringify(output, null, 2));
+      yield* Console2.log(JSON.stringify(output, null, 2));
     } else {
       if (spans.length === 0) {
-        yield* Console.log("No spans found.");
+        yield* Console2.log("No spans found.");
       } else {
         const spanItems = spans.map((s) => {
           const endTime = getEndTime(s);
@@ -1444,28 +1614,28 @@ var command3 = Command5.make(
           "",
           ...spanItems
         ].join("\n");
-        yield* Console.log(renderDoc(doc));
+        yield* Console2.log(renderDoc(doc));
       }
     }
   }).pipe(
-    Effect8.scoped,
-    Effect8.provide(makeReadOnlyLayer(data))
+    Effect10.scoped,
+    Effect10.provide(makeReadOnlyLayer(data))
   )
-).pipe(Command5.withDescription("List spans with optional filters"));
-var command4 = Command5.make(
+).pipe(Command6.withDescription("List spans with optional filters"));
+var command5 = Command6.make(
   "trace",
   {
     data: dataOption,
     json: jsonOption,
-    traceId: Argument2.string("trace-id").pipe(
-      Argument2.withDescription("The trace ID to display")
+    traceId: Argument3.string("trace-id").pipe(
+      Argument3.withDescription("The trace ID to display")
     )
   },
-  ({ data, json, traceId }) => Effect8.gen(function* () {
+  ({ data, json, traceId }) => Effect10.gen(function* () {
     const storage = yield* Storage;
     const spans = yield* storage.getSpans({ traceId });
     if (spans.length === 0) {
-      yield* Console.log(`No spans found for trace: ${traceId}`);
+      yield* Console2.log(`No spans found for trace: ${traceId}`);
       return;
     }
     const traces = yield* storage.getTraces({ limit: 1 });
@@ -1507,7 +1677,7 @@ var command4 = Command5.make(
         spanCount: spans.length,
         spans: roots.map((r) => buildJsonTree(graph, r.index))
       };
-      yield* Console.log(JSON.stringify(output, null, 2));
+      yield* Console2.log(JSON.stringify(output, null, 2));
     } else {
       const header = [
         field("Trace", traceId),
@@ -1515,18 +1685,22 @@ var command4 = Command5.make(
         ""
       ].join("\n");
       const treeDoc = renderSpanGraph(graph);
-      yield* Console.log(renderDoc([header, treeDoc].filter((line) => line.length > 0).join("\n")));
+      yield* Console2.log(renderDoc([header, treeDoc].filter((line) => line.length > 0).join("\n")));
     }
   }).pipe(
-    Effect8.scoped,
-    Effect8.provide(makeReadOnlyLayer(data))
+    Effect10.scoped,
+    Effect10.provide(makeReadOnlyLayer(data))
   )
-).pipe(Command5.withDescription("Show a trace as a tree view"));
-var command5 = Command5.make(
+).pipe(Command6.withDescription("Show a trace as a tree view"));
+var command6 = Command6.make(
   "traces",
   {
     data: dataOption,
     json: jsonOption,
+    runId: Flag3.string("run-id").pipe(
+      Flag3.withDescription("Filter by run ID"),
+      Flag3.optional
+    ),
     limit: limitOption,
     since: Flag3.string("since").pipe(
       Flag3.withDescription("Filter by time range (e.g., '1h', '30m')"),
@@ -1537,7 +1711,7 @@ var command5 = Command5.make(
       Flag3.optional
     )
   },
-  ({ data, json, limit, since, status }) => Effect8.gen(function* () {
+  ({ data, json, limit, runId, since, status }) => Effect10.gen(function* () {
     const storage = yield* Storage;
     let statusCode;
     if (Option3.isSome(status)) {
@@ -1552,7 +1726,7 @@ var command5 = Command5.make(
           statusCode = 0;
           break;
         default:
-          yield* Effect8.logWarning(`Unknown status: ${status.value}, ignoring filter`);
+          yield* Effect10.logWarning(`Unknown status: ${status.value}, ignoring filter`);
       }
     }
     let sinceNanos;
@@ -1562,6 +1736,7 @@ var command5 = Command5.make(
       sinceNanos = nowNanos - durationNanos;
     }
     const filters = {
+      ...Option3.isSome(runId) ? { runId: runId.value } : {},
       ...statusCode !== void 0 ? { status: statusCode } : {},
       ...sinceNanos !== void 0 ? { since: sinceNanos } : {},
       ...Option3.isSome(limit) ? { limit: limit.value } : {}
@@ -1577,10 +1752,10 @@ var command5 = Command5.make(
         endTime: t.end_time ? formatTimestamp(t.end_time) : null,
         durationMs: t.end_time ? Number((t.end_time - t.start_time) / 1000000n) : null
       }));
-      yield* Console.log(JSON.stringify(output, null, 2));
+      yield* Console2.log(JSON.stringify(output, null, 2));
     } else {
       if (traces.length === 0) {
-        yield* Console.log("No traces found.");
+        yield* Console2.log("No traces found.");
       } else {
         const traceItems = traces.map((t) => {
           const duration = t.end_time ? formatDuration(t.end_time - t.start_time) : "running";
@@ -1598,21 +1773,24 @@ var command5 = Command5.make(
           "",
           ...traceItems
         ].join("\n");
-        yield* Console.log(renderDoc(doc));
+        yield* Console2.log(renderDoc(doc));
       }
     }
   }).pipe(
-    Effect8.scoped,
-    Effect8.provide(makeReadOnlyLayer(data))
+    Effect10.scoped,
+    Effect10.provide(makeReadOnlyLayer(data))
   )
-).pipe(Command5.withDescription("List traces with optional filters"));
+).pipe(Command6.withDescription("List traces with optional filters"));
 
 // src/cli.ts
-var command6 = Command5.make("inspeffct").pipe(
-  Command5.withDescription("Inspect Effect applications without code changes"),
-  Command5.withSubcommands([command2, command, command5, command4, command3])
+var command7 = Command6.make("inspeffct").pipe(
+  Command6.withDescription("Inspect Effect applications without code changes"),
+  Command6.withSubcommands([
+    { group: "Capture", commands: [command2, command] },
+    { group: "Inspect", commands: [command6, command5, command4, command3] }
+  ])
 );
-var cli = Command5.runWith(command6, {
+var cli = Command6.runWith(command7, {
   version: "0.0.1"
 });
 var encodeRunSeparator = (args) => {
@@ -1629,6 +1807,6 @@ var run = (args) => cli(encodeRunSeparator(args));
 
 // src/bin.ts
 run(process.argv.slice(2)).pipe(
-  Effect8.provide(NodeServices.layer),
+  Effect10.provide(NodeServices.layer),
   NodeRuntime.runMain
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inspeffct",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "type": "module",
   "description": "A CLI to help agents and humans inspect Effect applications",
   "license": "MIT",