@contrail/cli 3.5.0-alpha.11f30e6 → 3.5.0-alpha.7efeaa8

package/README.md

@@ -17,7 +17,7 @@ $ npm install -g @contrail/cli
 $ contrail COMMAND
 running command...
 $ contrail (--version)
-@contrail/cli/3.5.0-alpha.11f30e6 linux-x64 node-v24.14.1
+@contrail/cli/3.5.0-alpha.7efeaa8 linux-x64 node-v24.14.1
 $ contrail --help [COMMAND]
 USAGE
   $ contrail COMMAND

package/dist/api/dash0/spans.d.ts

@@ -1,12 +1,7 @@
 import { Dash0Client } from './client';
 import { AttributeFilter, FlatSpan, OtlpAttribute, OtlpResourceSpans, OtlpSpan, TimeReferenceRange } from './types';
 export declare function paginateSpans(client: Dash0Client, filter: AttributeFilter[], timeRange: TimeReferenceRange, limit?: number): AsyncGenerator<OtlpResourceSpans, void, void>;
-export interface SampledTrace {
-    traceId: string;
-    anchorNs: bigint;
-}
-export declare function sampleTraceIdsForAction(client: Dash0Client, actionIdentifier: string, timeRange: TimeReferenceRange, maxTraces: number): Promise<SampledTrace[]>;
-export declare function bracketWindowAround(anchorNs: bigint, halfWindowMin?: number): TimeReferenceRange;
+export declare function sampleTraceIdsForAction(client: Dash0Client, actionIdentifier: string, timeRange: TimeReferenceRange, maxTraces: number): Promise<string[]>;
 export declare function fetchTraceSpans(client: Dash0Client, traceIdHex: string, timeRange: TimeReferenceRange): Promise<FlatSpan[]>;
 export declare function toFlat(sp: OtlpSpan, resourceAttrs: Record<string, string | number | boolean>): FlatSpan;
 export declare function flattenAttrs(attrs: OtlpAttribute[]): Record<string, string | number | boolean>;

package/dist/api/dash0/spans.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.b64ToHex = exports.flattenAttrs = exports.toFlat = exports.fetchTraceSpans = exports.bracketWindowAround = exports.sampleTraceIdsForAction = exports.paginateSpans = void 0;
+exports.b64ToHex = exports.flattenAttrs = exports.toFlat = exports.fetchTraceSpans = exports.sampleTraceIdsForAction = exports.paginateSpans = void 0;
 const PAGE_LIMIT = 50;
 const MAX_PAGES_PER_QUERY = 200;
 async function* paginateSpans(client, filter, timeRange, limit = PAGE_LIMIT) {
@@ -21,8 +21,8 @@ async function* paginateSpans(client, filter, timeRange, limit = PAGE_LIMIT) {
 }
 exports.paginateSpans = paginateSpans;
 async function sampleTraceIdsForAction(client, actionIdentifier, timeRange, maxTraces) {
-    const seen = new Map();
-    outer: for await (const rs of paginateSpans(client, [
+    const seen = new Set();
+    for await (const rs of paginateSpans(client, [
         {
             key: 'contrail.event_workflow.action.identifier',
             operator: 'is',
@@ -31,33 +31,15 @@ async function sampleTraceIdsForAction(client, actionIdentifier, timeRange, maxT
     ], timeRange)) {
         for (const ss of rs.scopeSpans ?? []) {
             for (const sp of ss.spans ?? []) {
-                const traceId = b64ToHex(sp.traceId);
-                const startNs = BigInt(sp.startTimeUnixNano);
-                const existing = seen.get(traceId);
-                if (existing === undefined || startNs < existing) {
-                    seen.set(traceId, startNs);
-                }
+                seen.add(b64ToHex(sp.traceId));
                 if (seen.size >= maxTraces)
-                    break outer;
+                    return [...seen];
             }
         }
     }
-    return [...seen.entries()].map(([traceId, anchorNs]) => ({ traceId, anchorNs }));
+    return [...seen];
 }
 exports.sampleTraceIdsForAction = sampleTraceIdsForAction;
-// Build a Dash0 absolute time range bracketing a trace anchor. ±halfWindowMin
-// around the anchor in ISO RFC3339; resilient to clock drift between sample
-// and fetch and wide enough to capture the full trace.
-function bracketWindowAround(anchorNs, halfWindowMin = 5) {
-    const halfMs = BigInt(halfWindowMin) * 60000n;
-    const fromMs = Number((anchorNs - halfMs * 1000000n) / 1000000n);
-    const toMs = Number((anchorNs + halfMs * 1000000n) / 1000000n);
-    return {
-        from: new Date(fromMs).toISOString(),
-        to: new Date(toMs).toISOString(),
-    };
-}
-exports.bracketWindowAround = bracketWindowAround;
 async function fetchTraceSpans(client, traceIdHex, timeRange) {
     const out = [];
     for await (const rs of paginateSpans(client, [{ key: 'otel.trace.id', operator: 'is', value: traceIdHex }], timeRange)) {

package/dist/api/dash0/types.d.ts

@@ -79,6 +79,4 @@ export interface FlatSpan {
     durationNs: bigint;
     attrs: Record<string, string | number | boolean>;
     resourceAttrs: Record<string, string | number | boolean>;
-    depthFromAction?: number;
-    serverAncestorCount?: number;
 }

package/dist/commands/event-workflows/assess-impact.js

@@ -60,31 +60,25 @@ class AssessImpact extends basecommand_1.BaseCommand {
         this.log(`Samples:   target ${samples}`);
         this.log('');
         this.log('Sampling trace IDs...');
-        const sampled = await (0, spans_1.sampleTraceIdsForAction)(client, identifier, timeRange, samples);
-        if (sampled.length === 0) {
+        const traceIds = await (0, spans_1.sampleTraceIdsForAction)(client, identifier, timeRange, samples);
+        if (traceIds.length === 0) {
             this.warn(`No spans found for action.identifier="${identifier}" in the last ${lookback}. ` +
                 'Verify the identifier and dataset.');
             return;
         }
-        this.log(`Got ${sampled.length} trace(s). Fetching subtrees...`);
+        this.log(`Got ${traceIds.length} trace(s). Fetching subtrees...`);
         const perTraceDescendants = [];
-        const actionDurationsNs = [];
         let dropped = 0;
         let totalOrphans = 0;
         let preciseRootCount = 0;
-        for (const { traceId, anchorNs } of sampled) {
-            // Bracket each trace fetch on the absolute timestamp captured at sample
-            // time. Avoids sliding-window edge effects where a trace at the boundary
-            // of the lookback window has its earliest spans excluded.
-            const traceWindow = (0, spans_1.bracketWindowAround)(anchorNs);
-            const spans = await (0, spans_1.fetchTraceSpans)(client, traceId, traceWindow);
+        for (const traceId of traceIds) {
+            const spans = await (0, spans_1.fetchTraceSpans)(client, traceId, timeRange);
             const result = (0, subtree_1.extractActionSubtree)(spans, identifier);
             if (!result) {
                 dropped++;
                 continue;
             }
             perTraceDescendants.push(result.descendants);
-            actionDurationsNs.push(result.actionSpan.durationNs);
             totalOrphans += result.orphanCount;
             if (result.preciseRoot)
                 preciseRootCount++;
@@ -104,7 +98,6 @@ class AssessImpact extends basecommand_1.BaseCommand {
             tracesDropped: dropped,
             totalOrphanCount: totalOrphans,
             preciseRootCount,
-            actionDuration: (0, aggregate_1.summarizeDurations)(actionDurationsNs),
         }));
     }
 }

package/dist/helpers/event-workflow-impact/aggregate.d.ts

@@ -21,12 +21,3 @@ export interface AggregateResult {
 }
 export declare function aggregate(input: AggregateInput): AggregateResult;
 export declare function percentile(values: number[], p: number): number;
-export interface DurationStats {
-    count: number;
-    meanMs: number;
-    p50Ms: number;
-    p95Ms: number;
-    p99Ms: number;
-    maxMs: number;
-}
-export declare function summarizeDurations(durationsNs: bigint[]): DurationStats;

package/dist/helpers/event-workflow-impact/aggregate.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.summarizeDurations = exports.percentile = exports.aggregate = void 0;
+exports.percentile = exports.aggregate = void 0;
 const classify_1 = require("./classify");
 const keyId = (k) => `${k.category}\x1f${k.service}\x1f${k.operation}`;
 function aggregate(input) {
@@ -47,19 +47,3 @@ function percentile(values, p) {
     return sorted[idx];
 }
 exports.percentile = percentile;
-function summarizeDurations(durationsNs) {
-    const ms = durationsNs.map((n) => Number(n / 1000000n));
-    if (ms.length === 0) {
-        return { count: 0, meanMs: 0, p50Ms: 0, p95Ms: 0, p99Ms: 0, maxMs: 0 };
-    }
-    const sum = ms.reduce((a, b) => a + b, 0);
-    return {
-        count: ms.length,
-        meanMs: sum / ms.length,
-        p50Ms: percentile(ms, 0.5),
-        p95Ms: percentile(ms, 0.95),
-        p99Ms: percentile(ms, 0.99),
-        maxMs: ms.reduce((a, b) => Math.max(a, b), 0),
-    };
-}
-exports.summarizeDurations = summarizeDurations;

package/dist/helpers/event-workflow-impact/aggregate.spec.js

@@ -13,7 +13,6 @@ function clientHttp(target, service = 'contrail-items') {
         durationNs: 0n,
         attrs: { 'http.request.method': 'GET', 'http.target': target },
         resourceAttrs: { 'service.name': service },
-        depthFromAction: 1,
     };
 }
 function dynamoQuery() {
@@ -70,7 +69,7 @@ describe('aggregate', () => {
         ];
         const result = (0, aggregate_1.aggregate)({ perTraceDescendants: perTrace });
         expect(result.traceCount).toBe(4);
-        const items = result.buckets.find((b) => b.key.category === 'http_direct' && b.key.operation === 'GET /api/items');
+        const items = result.buckets.find((b) => b.key.category === 'http' && b.key.operation === 'GET /api/items');
         expect(items).toBeDefined();
         // counts vector [2,4,0,1] sorted [0,1,2,4]; nearest-rank p50=1, p95=4.
         expect(items.median).toBe(1);
@@ -107,28 +106,3 @@ describe('aggregate', () => {
         expect(result.buckets).toHaveLength(0);
     });
 });
-describe('summarizeDurations', () => {
-    it('returns zeros for empty input', () => {
-        expect((0, aggregate_1.summarizeDurations)([])).toEqual({
-            count: 0,
-            meanMs: 0,
-            p50Ms: 0,
-            p95Ms: 0,
-            p99Ms: 0,
-            maxMs: 0,
-        });
-    });
-    it('converts ns to ms and computes mean + nearest-rank percentiles', () => {
-        // 10 values: 100ms, 200ms, ..., 1000ms.
-        const ns = [];
-        for (let i = 1; i <= 10; i++)
-            ns.push(BigInt(i * 100) * 1000000n);
-        const stats = (0, aggregate_1.summarizeDurations)(ns);
-        expect(stats.count).toBe(10);
-        expect(stats.meanMs).toBe(550); // sum=5500, n=10
-        expect(stats.p50Ms).toBe(500); // ceil(0.5*10)-1 = 4 → sorted[4] = 500
-        expect(stats.p95Ms).toBe(1000); // ceil(0.95*10)-1 = 9 → sorted[9] = 1000
-        expect(stats.p99Ms).toBe(1000);
-        expect(stats.maxMs).toBe(1000);
-    });
-});

package/dist/helpers/event-workflow-impact/classify.d.ts

@@ -1,5 +1,5 @@
 import { FlatSpan } from '../../api/dash0/types';
-export type Category = 'http_direct' | 'http_transitive' | 'opensearch' | 'dynamodb' | 's3' | 'timestream' | 'lambda' | 'other';
+export type Category = 'http' | 'opensearch' | 'dynamodb' | 's3' | 'timestream' | 'lambda' | 'other';
 export declare const CATEGORY_ORDER: Category[];
 export declare const CATEGORY_LABEL: Record<Category, string>;
 export interface Classified {

package/dist/helpers/event-workflow-impact/classify.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeRouteName = exports.looksLikeId = exports.templatePath = exports.classifySpan = exports.CATEGORY_LABEL = exports.CATEGORY_ORDER = void 0;
 exports.CATEGORY_ORDER = [
-    'http_direct',
-    'http_transitive',
+    'http',
     'opensearch',
     'dynamodb',
     's3',
@@ -12,8 +11,7 @@ exports.CATEGORY_ORDER = [
     'other',
 ];
 exports.CATEGORY_LABEL = {
-    http_direct: 'HTTP — direct (called by the action)',
-    http_transitive: 'HTTP — transitive (called by downstream services)',
+    http: 'HTTP',
     opensearch: 'OpenSearch',
     dynamodb: 'DynamoDB',
     s3: 'S3',
@@ -63,13 +61,8 @@ function classifySpan(span) {
         // when we have a path; otherwise normalize the leading verb in name so
         // "get /x" and "GET /x" don't split into two buckets.
         const operation = path ? `${method} ${path}` : normalizeRouteName(name);
-        // Direct HTTP = called by the action's own code (no SERVER boundary
-        // between this span and the action root). Transitive = inside a service
-        // the action invoked (1+ SERVER ancestors). Spans without subtree info
-        // (e.g. unit tests) default to direct.
-        const serverAncestors = span.serverAncestorCount ?? 0;
         return {
-            category: serverAncestors === 0 ? 'http_direct' : 'http_transitive',
+            category: 'http',
             service: service || 'unknown',
             operation,
         };

package/dist/helpers/event-workflow-impact/classify.spec.js

@@ -67,9 +67,7 @@ describe('classifySpan', () => {
     it('classifies Timestream AWS SDK spans', () => {
         expect((0, classify_1.classifySpan)(span({ name: 'TimestreamWrite.WriteRecords' }))?.category).toBe('timestream');
     });
-    it('classifies HTTP with no SERVER ancestor as http_direct', () => {
-        // Apps lambda's outbound HTTP CLIENT — sits below the action span via a
-        // lambda-invoke CLIENT, no SERVER boundary in between.
+    it('classifies generic HTTP CLIENT spans, templating the path', () => {
         const s = span({
             name: 'GET',
             attrs: {
@@ -78,29 +76,13 @@ describe('classifySpan', () => {
                 'http.host': 'api.vibeiq.com:443',
             },
             resourceAttrs: { 'service.name': 'contrail-event-workflow-apps' },
-            serverAncestorCount: 0,
         });
         expect((0, classify_1.classifySpan)(s)).toEqual({
-            category: 'http_direct',
+            category: 'http',
             service: 'contrail-event-workflow-apps',
             operation: 'GET /prod/api/items',
         });
     });
-    it('classifies HTTP behind a SERVER boundary as http_transitive', () => {
-        // Outbound HTTP from a downstream service the action called — there is a
-        // SERVER span between this and the action.
-        const s = span({
-            name: 'GET',
-            attrs: {
-                'http.request.method': 'GET',
-                'http.target': '/prod/api/open-search',
-                'http.host': 'api.vibeiq.com:443',
-            },
-            resourceAttrs: { 'service.name': 'contrail-items' },
-            serverAncestorCount: 1,
-        });
-        expect((0, classify_1.classifySpan)(s)?.category).toBe('http_transitive');
-    });
     it('classifies lambda-to-lambda invokes (no HTTP attrs, aws.lambda resource)', () => {
         const s = span({
             name: 'contrail-items-prod-api',
@@ -127,10 +109,8 @@ describe('classifySpan', () => {
             name: 'get /prod/api/custom-entities',
             attrs: { 'http.host': 'api.vibeiq.com:443' },
             resourceAttrs: { 'service.name': 'contrail-custom-entities' },
-            serverAncestorCount: 1,
         });
         expect((0, classify_1.classifySpan)(lower)?.operation).toBe('GET /prod/api/custom-entities');
-        expect((0, classify_1.classifySpan)(lower)?.category).toBe('http_transitive');
     });
     it('falls back to "other" for unknown CLIENT spans without aws.lambda resource', () => {
         expect((0, classify_1.classifySpan)(span({ name: 'mystery-step' }))?.category).toBe('other');

package/dist/helpers/event-workflow-impact/render.d.ts

@@ -1,4 +1,4 @@
-import { AggregateResult, DurationStats } from './aggregate';
+import { AggregateResult } from './aggregate';
 export interface RenderOptions {
     identifier: string;
     dataset: string;
@@ -8,6 +8,5 @@ export interface RenderOptions {
     tracesDropped: number;
     totalOrphanCount: number;
     preciseRootCount: number;
-    actionDuration: DurationStats;
 }
 export declare function renderReport(result: AggregateResult, opts: RenderOptions): string;

package/dist/helpers/event-workflow-impact/render.js

@@ -15,15 +15,7 @@ function renderReport(result, opts) {
         lines.push(`Rooting:   ${opts.preciseRootCount} precise / ${fallback} fallback (no inner action span — framework AWS-SDK direct children stripped heuristically)`);
     }
     lines.push('');
-    const d = opts.actionDuration;
-    if (d.count > 0) {
-        const note = opts.preciseRootCount < opts.samplesObtained
-            ? ' (includes some framework overhead on fallback-rooted traces)'
-            : '';
-        lines.push(`Action duration: mean ${fmtMs(d.meanMs)} · p50 ${fmtMs(d.p50Ms)} · p95 ${fmtMs(d.p95Ms)} · p99 ${fmtMs(d.p99Ms)} · max ${fmtMs(d.maxMs)}${note}`);
-        lines.push('');
-    }
-    lines.push('Per-invocation downstream calls. "% of traces" is how often the bucket appears in any invocation; median/p95/max include zeros.');
+    lines.push('Per-invocation downstream calls (median / p95 / max / coverage):');
     lines.push('');
     const byCategory = new Map();
     for (const b of result.buckets) {
@@ -39,7 +31,7 @@ function renderReport(result, opts) {
         any = true;
         lines.push(classify_1.CATEGORY_LABEL[cat]);
         const table = new cli_table3_1.default({
-            head: ['service', 'operation', 'median', 'p95', 'max', '% of traces'],
+            head: ['service', 'operation', 'median', 'p95', 'max', 'coverage'],
             style: { head: [], border: [] },
         });
         buckets
@@ -68,10 +60,3 @@ exports.renderReport = renderReport;
 function fmt(n) {
     return Number.isInteger(n) ? n.toString() : n.toFixed(1);
 }
-function fmtMs(ms) {
-    if (ms < 1)
-        return `${ms.toFixed(2)}ms`;
-    if (ms < 1000)
-        return `${Math.round(ms)}ms`;
-    return `${(ms / 1000).toFixed(2)}s`;
-}

package/dist/helpers/event-workflow-impact/subtree.js

@@ -49,17 +49,9 @@ function extractActionSubtree(spans, identifier) {
         return null;
     const preciseRoot = !!inner;
     const descendants = [];
-    // BFS tracking depth and "service boundary crossings" level-by-level. A
-    // service boundary is a SERVER span (kind=2) that represents code running
-    // in another service. The action's own executor SERVER — the SERVER span
-    // emitted on the receive side of the lambda invocation that runs the
-    // action — is NOT counted, because it represents the action's own
-    // execution context, not downstream work.
-    const queue = [
-        { spanId: actionSpan.spanId, depth: 0, serverAncestors: 0 },
-    ];
-    while (queue.length) {
-        const { spanId: parentId, depth, serverAncestors } = queue.shift();
+    const stack = [actionSpan.spanId];
+    while (stack.length) {
+        const parentId = stack.pop();
         const children = byParent.get(parentId) ?? [];
         for (const c of children) {
             // Fallback path: when rooting at the consumer, AWS-SDK spans that are a
@@ -70,30 +62,14 @@ function extractActionSubtree(spans, identifier) {
             if (!preciseRoot && parentId === actionSpan.spanId && isFrameworkAwsSdk(c)) {
                 continue;
             }
-            c.depthFromAction = depth + 1;
-            c.serverAncestorCount = serverAncestors;
             descendants.push(c);
-            // Skip the action's executor SERVER from boundary counting: a SERVER
-            // span that is a *direct* child of a non-SERVER action span is the
-            // server side of the invocation that runs the action's code itself.
-            const isExecutorServer = c.kind === 2 &&
-                parentId === actionSpan.spanId &&
-                actionSpan.kind !== 2;
-            const childServerCount = c.kind === 2 && !isExecutorServer ? serverAncestors + 1 : serverAncestors;
-            queue.push({ spanId: c.spanId, depth: depth + 1, serverAncestors: childServerCount });
+            stack.push(c.spanId);
         }
     }
-    // An orphan is a span whose parent was never observed AND whose time range
-    // falls inside the action span's time range. Orphans outside that range are
-    // unrelated trace spans (siblings of the action's lineage) and shouldn't
-    // taint the propagation-gap warning.
     let orphanCount = 0;
     for (const s of spans) {
-        if (!s.parentSpanId || byId.has(s.parentSpanId))
-            continue;
-        if (s.startNs < actionSpan.startNs || s.startNs > actionSpan.endNs)
-            continue;
-        orphanCount++;
+        if (s.parentSpanId && !byId.has(s.parentSpanId))
+            orphanCount++;
     }
     return { descendants, actionSpan, preciseRoot, orphanCount };
 }

package/dist/helpers/event-workflow-impact/subtree.spec.js

@@ -20,42 +20,30 @@ describe('extractActionSubtree', () => {
     it('returns null when no candidate exists', () => {
         expect((0, subtree_1.extractActionSubtree)([s({ spanId: 'a' })], IDENT)).toBeNull();
     });
-    describe('precise root (inner action span exists)', () => {
-        it('does not count the action executor SERVER as a service boundary', () => {
-            // Realistic Lambda shape: action span (kind=CLIENT, the invocation) has
-            // a SERVER child representing the receive-side of that invocation —
-            // this is the action's own executor lambda. The HTTP outbound from
-            // inside that lambda must be classified as direct (serverAncestorCount=0).
-            // Only SERVER spans BELOW outbound calls (downstream services) count.
+    describe('precise root (inner PRODUCER span exists)', () => {
+        it('walks descendants of the inner span and excludes consumer-side framework spans', () => {
+            // consumer (root) -> [framework DDB, framework S3, inner action]
+            // inner -> [http GET, http PUT]
+            // http GET -> nested DDB (downstream service's own DDB; should be kept)
             const spans = [
                 s({
                     spanId: 'consumer',
                     parentSpanId: '',
                     name: 'consumer',
-                    kind: 2,
                     attrs: { 'contrail.event_workflow.action.identifier': IDENT },
                 }),
-                s({ spanId: 'inner', parentSpanId: 'consumer', name: IDENT, kind: 3 }),
-                // Action's own executor SERVER (apps lambda receive side) — exempt.
-                s({ spanId: 'execSrv', parentSpanId: 'inner', name: 'apps-lambda', kind: 2 }),
-                // Action code's own outbound HTTP — direct.
-                s({ spanId: 'http1', parentSpanId: 'execSrv', name: 'GET', kind: 3 }),
-                // Downstream SERVER (e.g. contrail-items receiving the request).
-                s({ spanId: 'downSrv', parentSpanId: 'http1', name: 'GET /api/items', kind: 2 }),
-                // HTTP outbound from downstream — transitive.
-                s({ spanId: 'http2', parentSpanId: 'downSrv', name: 'GET', kind: 3 }),
+                s({ spanId: 'frameworkDdb', parentSpanId: 'consumer', name: 'DynamoDB.Query' }),
+                s({ spanId: 'frameworkS3', parentSpanId: 'consumer', name: 'S3.PutObject' }),
+                s({ spanId: 'inner', parentSpanId: 'consumer', name: IDENT, kind: 4 }),
+                s({ spanId: 'http1', parentSpanId: 'inner', name: 'GET' }),
+                s({ spanId: 'http2', parentSpanId: 'inner', name: 'PUT' }),
+                s({ spanId: 'nestedDdb', parentSpanId: 'http1', name: 'DynamoDB.Query' }),
             ];
             const result = (0, subtree_1.extractActionSubtree)(spans, IDENT);
             expect(result).not.toBeNull();
             expect(result.preciseRoot).toBe(true);
-            const find = (id) => result.descendants.find((d) => d.spanId === id);
-            // Executor SERVER is exempt: it gets count 0 itself, and its descendants
-            // don't see +1 from it.
-            expect(find('execSrv').serverAncestorCount).toBe(0);
-            expect(find('http1').serverAncestorCount).toBe(0);
-            // The downstream SERVER does count for its descendants.
-            expect(find('downSrv').serverAncestorCount).toBe(0);
-            expect(find('http2').serverAncestorCount).toBe(1);
+            const ids = result.descendants.map((d) => d.spanId).sort();
+            expect(ids).toEqual(['http1', 'http2', 'nestedDdb']);
         });
     });
     describe('fallback root (no inner span)', () => {
@@ -88,48 +76,16 @@ describe('extractActionSubtree', () => {
             expect(ids).toEqual(['http1', 'nestedDdb']);
         });
     });
-    describe('orphan counting', () => {
-        it('counts orphans inside the action span time range', () => {
-            const spans = [
-                s({
-                    spanId: 'consumer',
-                    parentSpanId: '',
-                    startNs: 1000n,
-                    endNs: 9000n,
-                    attrs: { 'contrail.event_workflow.action.identifier': IDENT },
-                }),
-                // Inside [1000, 9000] with missing parent → counts.
-                s({
-                    spanId: 'innerOrphan',
-                    parentSpanId: 'missing',
-                    startNs: 5000n,
-                    endNs: 6000n,
-                }),
-            ];
-            const result = (0, subtree_1.extractActionSubtree)(spans, IDENT);
-            expect(result.orphanCount).toBe(1);
-        });
-        it('ignores orphans whose time falls outside the action span', () => {
-            const spans = [
-                s({
-                    spanId: 'consumer',
-                    parentSpanId: '',
-                    startNs: 1000n,
-                    endNs: 9000n,
-                    attrs: { 'contrail.event_workflow.action.identifier': IDENT },
-                }),
-                // Sibling-of-action lineage span. Real parent is unobserved (window
-                // edge effect) but its time is outside the action's range — noise,
-                // not a real propagation gap.
-                s({
-                    spanId: 'unrelated',
-                    parentSpanId: 'missing',
-                    startNs: 50000n,
-                    endNs: 60000n,
-                }),
-            ];
-            const result = (0, subtree_1.extractActionSubtree)(spans, IDENT);
-            expect(result.orphanCount).toBe(0);
-        });
+    it('counts orphans (parent_id pointing outside the trace)', () => {
+        const spans = [
+            s({
+                spanId: 'consumer',
+                parentSpanId: '',
+                attrs: { 'contrail.event_workflow.action.identifier': IDENT },
+            }),
+            s({ spanId: 'unattached', parentSpanId: 'missing-parent' }),
+        ];
+        const result = (0, subtree_1.extractActionSubtree)(spans, IDENT);
+        expect(result.orphanCount).toBe(1);
     });
 });

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.0-alpha.11f30e6",
+  "version": "3.5.0-alpha.7efeaa8",
   "commands": {
     "app:create": {
       "id": "app:create",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "3.5.0-alpha.11f30e6",
+  "version": "3.5.0-alpha.7efeaa8",
   "description": "VibeIQ's Contrail Platform CLI.",
   "bin": {
     "contrail-cli": "./bin/run",