peaks-loop 4.0.0-beta.8 → 4.0.0-beta.9

package/dist/services/mut/types.d.ts

@@ -0,0 +1,336 @@
+/**
+ * Per spec §4.2 验收审计 + §7 阶段二 — MutReportJson v1.0.
+ *
+ * Hard constraints:
+ *   H8 (audit trail hashable): sha256 + inputSig (chain to TACT.sig)
+ *   H6 (CLI裁决, not LLM): passed boolean is computed by CLI, not LLM
+ */
+import { z } from 'zod';
+export type MutVersion = '1.0';
+export type MutTool = 'stryker' | 'mutmut' | 'go-mutesting';
+export type WeakPattern = 'toBeDefined' | 'toBeTruthy' | 'toEqual-self' | 'expect-anything' | 'toBe-self';
+export interface SurvivedMutant {
+    readonly line: number;
+    readonly mutation: string;
+    readonly survivedBecause: string;
+}
+export interface FileMutationReport {
+    readonly file: string;
+    readonly killRate: number;
+    readonly survived: ReadonlyArray<SurvivedMutant>;
+}
+export interface MutationReport {
+    readonly tool: MutTool;
+    readonly mutantsTotal: number;
+    readonly mutantsKilled: number;
+    readonly mutantsSurvived: number;
+    readonly mutantsTimeout: number;
+    readonly killRate: number;
+    readonly byFile: ReadonlyArray<FileMutationReport>;
+}
+export interface WeakExample {
+    readonly file: string;
+    readonly line: number;
+    readonly code: string;
+}
+export interface WeakPatternCount {
+    readonly pattern: WeakPattern;
+    readonly count: number;
+    readonly examples: ReadonlyArray<WeakExample>;
+}
+export interface AssertionsReport {
+    readonly totalAssertions: number;
+    readonly weakAssertions: number;
+    readonly weakRate: number;
+    readonly weakPatterns: ReadonlyArray<WeakPatternCount>;
+}
+export interface ThresholdsConfig {
+    readonly mutationKillRateMin: number;
+    readonly weakAssertionRateMax: number;
+    readonly passed: boolean;
+}
+export type FollowupSeverity = 'soft' | 'hard';
+export type FollowupIssue = 'low_kill_rate' | 'high_weak_assertions';
+export interface Followup {
+    readonly file: string;
+    readonly issue: FollowupIssue;
+    readonly severity: FollowupSeverity;
+    readonly suggestion: string;
+}
+export interface MutReportJson {
+    readonly version: MutVersion;
+    readonly sha256: string;
+    readonly generatedAt: string;
+    readonly inputSig: string;
+    readonly mutation: MutationReport;
+    readonly assertions: AssertionsReport;
+    readonly thresholds: ThresholdsConfig;
+    readonly followups: ReadonlyArray<Followup>;
+}
+export declare const WeakPatternSchema: z.ZodEnum<["toBeDefined", "toBeTruthy", "toEqual-self", "expect-anything", "toBe-self"]>;
+export declare const MutReportSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1.0">;
+    sha256: z.ZodString;
+    generatedAt: z.ZodString;
+    inputSig: z.ZodString;
+    mutation: z.ZodObject<{
+        tool: z.ZodEnum<["stryker", "mutmut", "go-mutesting"]>;
+        mutantsTotal: z.ZodNumber;
+        mutantsKilled: z.ZodNumber;
+        mutantsSurvived: z.ZodNumber;
+        mutantsTimeout: z.ZodNumber;
+        killRate: z.ZodNumber;
+        byFile: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            killRate: z.ZodNumber;
+            survived: z.ZodArray<z.ZodObject<{
+                line: z.ZodNumber;
+                mutation: z.ZodString;
+                survivedBecause: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }, {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }, {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        tool: "stryker" | "mutmut" | "go-mutesting";
+        killRate: number;
+        mutantsTotal: number;
+        mutantsKilled: number;
+        mutantsSurvived: number;
+        mutantsTimeout: number;
+        byFile: {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }[];
+    }, {
+        tool: "stryker" | "mutmut" | "go-mutesting";
+        killRate: number;
+        mutantsTotal: number;
+        mutantsKilled: number;
+        mutantsSurvived: number;
+        mutantsTimeout: number;
+        byFile: {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }[];
+    }>;
+    assertions: z.ZodObject<{
+        totalAssertions: z.ZodNumber;
+        weakAssertions: z.ZodNumber;
+        weakRate: z.ZodNumber;
+        weakPatterns: z.ZodArray<z.ZodObject<{
+            pattern: z.ZodEnum<["toBeDefined", "toBeTruthy", "toEqual-self", "expect-anything", "toBe-self"]>;
+            count: z.ZodNumber;
+            examples: z.ZodArray<z.ZodObject<{
+                file: z.ZodString;
+                line: z.ZodNumber;
+                code: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                code: string;
+                file: string;
+                line: number;
+            }, {
+                code: string;
+                file: string;
+                line: number;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }, {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        weakRate: number;
+        totalAssertions: number;
+        weakAssertions: number;
+        weakPatterns: {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }[];
+    }, {
+        weakRate: number;
+        totalAssertions: number;
+        weakAssertions: number;
+        weakPatterns: {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }[];
+    }>;
+    thresholds: z.ZodObject<{
+        mutationKillRateMin: z.ZodNumber;
+        weakAssertionRateMax: z.ZodNumber;
+        passed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        passed: boolean;
+        mutationKillRateMin: number;
+        weakAssertionRateMax: number;
+    }, {
+        passed: boolean;
+        mutationKillRateMin: number;
+        weakAssertionRateMax: number;
+    }>;
+    followups: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        issue: z.ZodEnum<["low_kill_rate", "high_weak_assertions"]>;
+        severity: z.ZodEnum<["soft", "hard"]>;
+        suggestion: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        severity: "soft" | "hard";
+        issue: "low_kill_rate" | "high_weak_assertions";
+        suggestion: string;
+    }, {
+        file: string;
+        severity: "soft" | "hard";
+        issue: "low_kill_rate" | "high_weak_assertions";
+        suggestion: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: "1.0";
+    sha256: string;
+    generatedAt: string;
+    inputSig: string;
+    mutation: {
+        tool: "stryker" | "mutmut" | "go-mutesting";
+        killRate: number;
+        mutantsTotal: number;
+        mutantsKilled: number;
+        mutantsSurvived: number;
+        mutantsTimeout: number;
+        byFile: {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }[];
+    };
+    assertions: {
+        weakRate: number;
+        totalAssertions: number;
+        weakAssertions: number;
+        weakPatterns: {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }[];
+    };
+    thresholds: {
+        passed: boolean;
+        mutationKillRateMin: number;
+        weakAssertionRateMax: number;
+    };
+    followups: {
+        file: string;
+        severity: "soft" | "hard";
+        issue: "low_kill_rate" | "high_weak_assertions";
+        suggestion: string;
+    }[];
+}, {
+    version: "1.0";
+    sha256: string;
+    generatedAt: string;
+    inputSig: string;
+    mutation: {
+        tool: "stryker" | "mutmut" | "go-mutesting";
+        killRate: number;
+        mutantsTotal: number;
+        mutantsKilled: number;
+        mutantsSurvived: number;
+        mutantsTimeout: number;
+        byFile: {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }[];
+    };
+    assertions: {
+        weakRate: number;
+        totalAssertions: number;
+        weakAssertions: number;
+        weakPatterns: {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }[];
+    };
+    thresholds: {
+        passed: boolean;
+        mutationKillRateMin: number;
+        weakAssertionRateMax: number;
+    };
+    followups: {
+        file: string;
+        severity: "soft" | "hard";
+        issue: "low_kill_rate" | "high_weak_assertions";
+        suggestion: string;
+    }[];
+}>;

package/dist/services/mut/types.js

@@ -0,0 +1,59 @@
+/**
+ * Per spec §4.2 验收审计 + §7 阶段二 — MutReportJson v1.0.
+ *
+ * Hard constraints:
+ *   H8 (audit trail hashable): sha256 + inputSig (chain to TACT.sig)
+ *   H6 (CLI裁决, not LLM): passed boolean is computed by CLI, not LLM
+ */
+import { z } from 'zod';
+export const WeakPatternSchema = z.enum([
+    'toBeDefined', 'toBeTruthy', 'toEqual-self', 'expect-anything', 'toBe-self',
+]);
+export const MutReportSchema = z.object({
+    version: z.literal('1.0'),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    generatedAt: z.string().datetime(),
+    inputSig: z.string().regex(/^[a-f0-9]{64}$/),
+    mutation: z.object({
+        tool: z.enum(['stryker', 'mutmut', 'go-mutesting']),
+        mutantsTotal: z.number().int().nonnegative(),
+        mutantsKilled: z.number().int().nonnegative(),
+        mutantsSurvived: z.number().int().nonnegative(),
+        mutantsTimeout: z.number().int().nonnegative(),
+        killRate: z.number().min(0).max(1),
+        byFile: z.array(z.object({
+            file: z.string(),
+            killRate: z.number().min(0).max(1),
+            survived: z.array(z.object({
+                line: z.number().int(),
+                mutation: z.string(),
+                survivedBecause: z.string(),
+            })),
+        })),
+    }),
+    assertions: z.object({
+        totalAssertions: z.number().int().nonnegative(),
+        weakAssertions: z.number().int().nonnegative(),
+        weakRate: z.number().min(0).max(1),
+        weakPatterns: z.array(z.object({
+            pattern: WeakPatternSchema,
+            count: z.number().int().nonnegative(),
+            examples: z.array(z.object({
+                file: z.string(),
+                line: z.number().int(),
+                code: z.string(),
+            })),
+        })),
+    }),
+    thresholds: z.object({
+        mutationKillRateMin: z.number().min(0).max(1),
+        weakAssertionRateMax: z.number().min(0).max(1),
+        passed: z.boolean(),
+    }),
+    followups: z.array(z.object({
+        file: z.string(),
+        issue: z.enum(['low_kill_rate', 'high_weak_assertions']),
+        severity: z.enum(['soft', 'hard']),
+        suggestion: z.string(),
+    })),
+});

package/dist/services/observability/aggregation.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Read-only aggregations over observability events.
+ *
+ * Slice B of v2.11.1. Pure functions over `readonly ObservabilityEvent[]`
+ * — the CLI layer reads events via `readObservabilityEvents` (or
+ * `listSessionDirsWithMetrics` for cross-session rollups) and passes
+ * them in. Tests pass synthetic events directly.
+ *
+ * Aggregations:
+ *   - `aggregateStatus(events)`        → AC-1
+ *   - `aggregateSlices(events)`        → AC-2
+ *   - `aggregateFanout(events)`        → AC-3
+ *   - `aggregateRepairCycles(events)`  → AC-4
+ *
+ * The dispatch / mode-gate / context / post-compact categories land
+ * in Slice C (more hooks); for Slice B only `slice-transition` events
+ * are emitted from the `peaks request transition` hook. Slice B
+ * builds the read-side surface so Slice C is purely additive.
+ */
+import { type ObservabilityEvent, type ObservabilitySubagentRole } from './observability-service.js';
+export type StatusAggregate = {
+    totalEvents: number;
+    totalSlices: number;
+    successCount: number;
+    failCount: number;
+    repairCyclePeak: number;
+    fanoutCostTotal: number;
+};
+export type SliceRollup = {
+    sliceRid: string;
+    transitions: number;
+    firstTs: string | null;
+    lastTs: string | null;
+    durationMs: number | null;
+    finalState: string | null;
+    fanoutCount: number;
+    repairCycleCount: number;
+    success: boolean;
+};
+export type FanoutBreakdown = {
+    total: number;
+    perRole: Record<ObservabilitySubagentRole, number>;
+};
+export type RepairCycleReport = {
+    totalCycles: number;
+    cap: number;
+    capHit: boolean;
+    capHitCount: number;
+    perSlice: Array<{
+        sliceRid: string;
+        cycleCount: number;
+    }>;
+};
+/** RD/QA repair-loop cap (matches the peaks-code repair-loop contract). */
+export declare const REPAIR_CYCLE_CAP = 3;
+export declare function aggregateStatus(events: readonly ObservabilityEvent[]): StatusAggregate;
+export declare function aggregateSlices(events: readonly ObservabilityEvent[]): SliceRollup[];
+export declare function aggregateFanout(events: readonly ObservabilityEvent[]): FanoutBreakdown;
+export declare function aggregateRepairCycles(events: readonly ObservabilityEvent[]): RepairCycleReport;
+export type Period = 'day' | 'week' | 'month';
+export declare function periodStartIso(period: Period, now?: () => Date): string;
+export declare function filterByPeriod(events: readonly ObservabilityEvent[], period: Period, now?: () => Date): ObservabilityEvent[];
+export declare function readAllSessionEvents(projectRoot: string): ObservabilityEvent[];
+export declare function readSessionEvents(projectRoot: string, sessionId: string): ObservabilityEvent[];

package/dist/services/observability/aggregation.js

@@ -0,0 +1,217 @@
+/**
+ * Read-only aggregations over observability events.
+ *
+ * Slice B of v2.11.1. Pure functions over `readonly ObservabilityEvent[]`
+ * — the CLI layer reads events via `readObservabilityEvents` (or
+ * `listSessionDirsWithMetrics` for cross-session rollups) and passes
+ * them in. Tests pass synthetic events directly.
+ *
+ * Aggregations:
+ *   - `aggregateStatus(events)`        → AC-1
+ *   - `aggregateSlices(events)`        → AC-2
+ *   - `aggregateFanout(events)`        → AC-3
+ *   - `aggregateRepairCycles(events)`  → AC-4
+ *
+ * The dispatch / mode-gate / context / post-compact categories land
+ * in Slice C (more hooks); for Slice B only `slice-transition` events
+ * are emitted from the `peaks request transition` hook. Slice B
+ * builds the read-side surface so Slice C is purely additive.
+ */
+import { readObservabilityEvents } from './observability-service.js';
+import { listSessionDirsWithMetrics } from './jsonl-store.js';
+// Slice lifecycle terminal states. Anything not listed is in-flight
+// (draft / spec-locked / implemented / qa-handoff / running).
+const TERMINAL_HAPPY_STATES = new Set([
+    'handed-off',
+    'verdict-issued',
+    'impact-recorded',
+    'boundary-recorded'
+]);
+const TERMINAL_FAIL_STATES = new Set(['blocked']);
+/** RD/QA repair-loop cap (matches the peaks-code repair-loop contract). */
+export const REPAIR_CYCLE_CAP = 3;
+// v2.12.0 fan-out collapse: see OBSERVABILITY_SUBAGENT_ROLES for the
+// rationale on why `security-reviewer` was dropped and `peaks-security-audit`
+// + `peaks-perf-audit` were added.
+const ZERO_FANOUT = {
+    'rd': 0,
+    'qa': 0,
+    'code-reviewer': 0,
+    'karpathy-reviewer': 0,
+    'peaks-security-audit': 0,
+    'peaks-perf-audit': 0
+};
+// ----- internal helpers -----
+function isSliceTransition(event) {
+    return event.category === 'slice-transition' && typeof event.sliceRid === 'string';
+}
+function artifactRole(event) {
+    const detail = event.detail;
+    return typeof detail.artifactRole === 'string' ? detail.artifactRole : '';
+}
+function transitionTo(event) {
+    const detail = event.detail;
+    return typeof detail.to === 'string' ? detail.to : null;
+}
+function durationMsBetween(firstTs, lastTs) {
+    const a = new Date(firstTs).getTime();
+    const b = new Date(lastTs).getTime();
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        return 0;
+    }
+    return Math.max(0, b - a);
+}
+// ----- per-slice rollup (shared by status + slices queries) -----
+function rollupSlices(events) {
+    const bySlice = new Map();
+    for (const event of events) {
+        if (!isSliceTransition(event))
+            continue;
+        const rid = event.sliceRid;
+        let rollup = bySlice.get(rid);
+        if (rollup === undefined) {
+            rollup = {
+                sliceRid: rid,
+                transitions: 0,
+                firstTs: null,
+                lastTs: null,
+                durationMs: null,
+                finalState: null,
+                fanoutCount: 0,
+                repairCycleCount: 0,
+                success: false
+            };
+            bySlice.set(rid, rollup);
+        }
+        rollup.transitions += 1;
+        if (rollup.firstTs === null || event.ts < rollup.firstTs)
+            rollup.firstTs = event.ts;
+        if (rollup.lastTs === null || event.ts > rollup.lastTs)
+            rollup.lastTs = event.ts;
+        const to = transitionTo(event);
+        if (to !== null)
+            rollup.finalState = to;
+    }
+    for (const rollup of bySlice.values()) {
+        if (rollup.finalState !== null && TERMINAL_HAPPY_STATES.has(rollup.finalState)) {
+            rollup.success = true;
+        }
+        if (rollup.firstTs !== null && rollup.lastTs !== null) {
+            rollup.durationMs = durationMsBetween(rollup.firstTs, rollup.lastTs);
+        }
+    }
+    return bySlice;
+}
+function computeRepairCyclesBySlice(events) {
+    // Repair cycle = each rd → qa transition within one slice (proxy for the
+    // RD→QA→RD loop). For each slice we count qa transitions that follow an
+    // rd transition. Multiple qa transitions on the same slice are capped by
+    // REPAIR_CYCLE_CAP at the report level — the per-slice count here is the
+    // raw observation count.
+    const cyclesBySlice = new Map();
+    for (const event of events) {
+        if (!isSliceTransition(event))
+            continue;
+        const rid = event.sliceRid;
+        const role = artifactRole(event);
+        if (role === 'qa') {
+            cyclesBySlice.set(rid, (cyclesBySlice.get(rid) ?? 0) + 1);
+        }
+    }
+    return cyclesBySlice;
+}
+// ----- public aggregations -----
+export function aggregateStatus(events) {
+    const bySlice = rollupSlices(events);
+    const cyclesBySlice = computeRepairCyclesBySlice(events);
+    let repairCyclePeak = 0;
+    for (const rollup of bySlice.values()) {
+        const cycles = cyclesBySlice.get(rollup.sliceRid) ?? 0;
+        rollup.repairCycleCount = cycles;
+        if (cycles > repairCyclePeak)
+            repairCyclePeak = cycles;
+    }
+    const successCount = Array.from(bySlice.values()).filter((r) => r.success).length;
+    const failCount = Array.from(bySlice.values()).filter((r) => r.finalState !== null && TERMINAL_FAIL_STATES.has(r.finalState)).length;
+    const fanoutCostTotal = events.filter((e) => e.category === 'dispatch').length;
+    return {
+        totalEvents: events.length,
+        totalSlices: bySlice.size,
+        successCount,
+        failCount,
+        repairCyclePeak,
+        fanoutCostTotal
+    };
+}
+export function aggregateSlices(events) {
+    const bySlice = rollupSlices(events);
+    const cyclesBySlice = computeRepairCyclesBySlice(events);
+    for (const rollup of bySlice.values()) {
+        rollup.repairCycleCount = cyclesBySlice.get(rollup.sliceRid) ?? 0;
+    }
+    return Array.from(bySlice.values()).sort((a, b) => a.sliceRid.localeCompare(b.sliceRid));
+}
+export function aggregateFanout(events) {
+    const perRole = { ...ZERO_FANOUT };
+    let total = 0;
+    for (const event of events) {
+        if (event.category !== 'dispatch')
+            continue;
+        if (event.role !== undefined && event.role in perRole) {
+            perRole[event.role] += 1;
+            total += 1;
+        }
+    }
+    return { total, perRole };
+}
+export function aggregateRepairCycles(events) {
+    const cyclesBySlice = computeRepairCyclesBySlice(events);
+    const perSlice = Array.from(cyclesBySlice.entries())
+        .map(([sliceRid, cycleCount]) => ({ sliceRid, cycleCount }))
+        .sort((a, b) => a.sliceRid.localeCompare(b.sliceRid));
+    const totalCycles = perSlice.reduce((sum, row) => sum + row.cycleCount, 0);
+    const capHitCount = perSlice.filter((row) => row.cycleCount >= REPAIR_CYCLE_CAP).length;
+    return {
+        totalCycles,
+        cap: REPAIR_CYCLE_CAP,
+        capHit: capHitCount > 0,
+        capHitCount,
+        perSlice
+    };
+}
+export function periodStartIso(period, now = () => new Date()) {
+    const d = now();
+    if (period === 'day') {
+        d.setUTCHours(0, 0, 0, 0);
+        return d.toISOString();
+    }
+    if (period === 'week') {
+        d.setUTCHours(0, 0, 0, 0);
+        const day = d.getUTCDay();
+        const diff = (day + 6) % 7; // Monday = 0
+        d.setUTCDate(d.getUTCDate() - diff);
+        return d.toISOString();
+    }
+    d.setUTCDate(1);
+    d.setUTCHours(0, 0, 0, 0);
+    return d.toISOString();
+}
+export function filterByPeriod(events, period, now) {
+    const start = periodStartIso(period, now);
+    return events.filter((e) => e.ts >= start);
+}
+// ----- event-source helpers (CLI calls these; tests use pure functions) -----
+export function readAllSessionEvents(projectRoot) {
+    const sessions = listSessionDirsWithMetrics(projectRoot);
+    const all = [];
+    for (const { sessionId } of sessions) {
+        for (const event of readObservabilityEvents(projectRoot, sessionId)) {
+            all.push(event);
+        }
+    }
+    all.sort((a, b) => a.ts.localeCompare(b.ts));
+    return all;
+}
+export function readSessionEvents(projectRoot, sessionId) {
+    return readObservabilityEvents(projectRoot, sessionId);
+}