@bryan-thompson/inspector-assessment-cli 1.34.1 → 1.35.1

package/build/__tests__/stage3-fix-validation.test.js

@@ -0,0 +1,163 @@
+/**
+ * Stage 3 Fix Validation Tests
+ *
+ * Tests for Issue #137 Stage 3 fixes (code review and corrections).
+ * Validates that FIX-001 (stageBVerbose schema) is correctly implemented.
+ *
+ * @see https://github.com/triepod-ai/inspector-assessment/issues/137
+ */
+import { describe, it, expect } from "@jest/globals";
+import { AssessmentOptionsSchema, safeParseAssessmentOptions, validateAssessmentOptions, } from "../lib/cli-parserSchemas.js";
+describe("Stage 3 Fix Validation Tests", () => {
+    describe("[TEST-001] cli-parserSchemas.ts - stageBVerbose field (FIX-001)", () => {
+        describe("stageBVerbose field validation", () => {
+            it("should accept stageBVerbose with true value (happy path)", () => {
+                const options = {
+                    serverName: "test-server",
+                    stageBVerbose: true,
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.stageBVerbose).toBe(true);
+                }
+            });
+            it("should accept stageBVerbose with false value (edge case)", () => {
+                const options = {
+                    serverName: "test-server",
+                    stageBVerbose: false,
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.stageBVerbose).toBe(false);
+                }
+            });
+            it("should accept undefined stageBVerbose - optional field (edge case)", () => {
+                const options = {
+                    serverName: "test-server",
+                    // stageBVerbose omitted
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.stageBVerbose).toBeUndefined();
+                }
+            });
+            it("should validate with validateAssessmentOptions() accepting stageBVerbose (error case prevention)", () => {
+                const options = {
+                    serverName: "test-server",
+                    stageBVerbose: true,
+                };
+                const errors = validateAssessmentOptions(options);
+                expect(errors).toHaveLength(0);
+            });
+            it("should reject non-boolean stageBVerbose values (error case)", () => {
+                const testCases = [
+                    { stageBVerbose: "true" }, // string instead of boolean
+                    { stageBVerbose: 1 }, // number instead of boolean
+                    { stageBVerbose: null },
+                    { stageBVerbose: {} },
+                    { stageBVerbose: [] },
+                ];
+                testCases.forEach((testCase) => {
+                    const options = {
+                        serverName: "test-server",
+                        ...testCase,
+                    };
+                    const result = safeParseAssessmentOptions(options);
+                    expect(result.success).toBe(false);
+                });
+            });
+        });
+        describe("stageBVerbose integration with other fields", () => {
+            it("should accept stageBVerbose with outputFormat=tiered", () => {
+                const options = {
+                    serverName: "test-server",
+                    outputFormat: "tiered",
+                    stageBVerbose: true,
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.outputFormat).toBe("tiered");
+                    expect(result.data.stageBVerbose).toBe(true);
+                }
+            });
+            it("should accept stageBVerbose with other CLI options", () => {
+                const options = {
+                    serverName: "test-server",
+                    verbose: true,
+                    jsonOnly: false,
+                    fullAssessment: true,
+                    stageBVerbose: true,
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.verbose).toBe(true);
+                    expect(result.data.jsonOnly).toBe(false);
+                    expect(result.data.fullAssessment).toBe(true);
+                    expect(result.data.stageBVerbose).toBe(true);
+                }
+            });
+            it("should work with validateAssessmentOptions for complex options", () => {
+                const options = {
+                    serverName: "test-server",
+                    outputFormat: "tiered",
+                    autoTier: true,
+                    stageBVerbose: true,
+                    verbose: true,
+                };
+                const errors = validateAssessmentOptions(options);
+                expect(errors).toHaveLength(0);
+            });
+        });
+        describe("regression prevention for ISSUE-001", () => {
+            it("should maintain stageBVerbose in schema after validation", () => {
+                // Verify the field exists in the schema shape
+                const options = {
+                    serverName: "test-server",
+                    stageBVerbose: true,
+                };
+                const result = AssessmentOptionsSchema.safeParse(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data).toHaveProperty("stageBVerbose");
+                    expect(result.data.stageBVerbose).toBe(true);
+                }
+            });
+            it("should not strip stageBVerbose field during validation", () => {
+                const options = {
+                    serverName: "test-server",
+                    stageBVerbose: true,
+                    outputFormat: "tiered",
+                };
+                const parsed = AssessmentOptionsSchema.parse(options);
+                // Field should be present after parsing
+                expect(parsed.stageBVerbose).toBe(true);
+                expect(parsed.outputFormat).toBe("tiered");
+            });
+            it("should backward compatibility - existing fields unaffected", () => {
+                const options = {
+                    serverName: "test-server",
+                    verbose: true,
+                    jsonOnly: false,
+                    format: "json",
+                    fullAssessment: true,
+                    // New field
+                    stageBVerbose: true,
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.verbose).toBe(true);
+                    expect(result.data.jsonOnly).toBe(false);
+                    expect(result.data.format).toBe("json");
+                    expect(result.data.fullAssessment).toBe(true);
+                    expect(result.data.stageBVerbose).toBe(true);
+                }
+            });
+        });
+    });
+});

package/build/__tests__/stage3-fixes.test.js

@@ -0,0 +1,516 @@
+/**
+ * Stage 3 Fixes Regression Tests
+ *
+ * Tests for Issue #134 code review fixes to ensure they don't regress.
+ * These tests validate schema validation and JSONL event emission.
+ *
+ * @see https://github.com/triepod-ai/inspector-assessment/issues/134
+ */
+import { describe, it, expect, jest, beforeEach, afterEach, } from "@jest/globals";
+import { OutputFormatSchema, safeParseAssessmentOptions, } from "../lib/cli-parserSchemas.js";
+import { emitTieredOutput, SCHEMA_VERSION, } from "../lib/jsonl-events.js";
+import { INSPECTOR_VERSION } from "../../../client/lib/lib/moduleScoring.js";
+describe("Stage 3 Fixes Regression Tests", () => {
+    describe("[TEST-REQ-001] cli-parserSchemas.ts - AssessmentOptionsSchema", () => {
+        describe("outputFormat field validation", () => {
+            it("should accept outputFormat with 'full' value", () => {
+                const options = {
+                    serverName: "test-server",
+                    outputFormat: "full",
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.outputFormat).toBe("full");
+                }
+            });
+            it("should accept outputFormat with 'tiered' value", () => {
+                const options = {
+                    serverName: "test-server",
+                    outputFormat: "tiered",
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.outputFormat).toBe("tiered");
+                }
+            });
+            it("should accept outputFormat with 'summary-only' value", () => {
+                const options = {
+                    serverName: "test-server",
+                    outputFormat: "summary-only",
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.outputFormat).toBe("summary-only");
+                }
+            });
+            it("should accept undefined outputFormat (optional field)", () => {
+                const options = {
+                    serverName: "test-server",
+                    // outputFormat omitted
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.outputFormat).toBeUndefined();
+                }
+            });
+            it("should reject invalid outputFormat value", () => {
+                const options = {
+                    serverName: "test-server",
+                    outputFormat: "invalid",
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(false);
+                if (!result.success) {
+                    // Zod error messages include the full path and expected values
+                    const errors = result.error.errors;
+                    const hasOutputFormatError = errors.some((e) => e.path.includes("outputFormat") ||
+                        e.message.includes("full") ||
+                        e.message.includes("tiered") ||
+                        e.message.includes("summary-only"));
+                    expect(hasOutputFormatError).toBe(true);
+                }
+            });
+            it("should reject non-string outputFormat values", () => {
+                const testCases = [
+                    { outputFormat: 123 },
+                    { outputFormat: true },
+                    { outputFormat: null },
+                    { outputFormat: {} },
+                    { outputFormat: [] },
+                ];
+                testCases.forEach((testCase) => {
+                    const options = {
+                        serverName: "test-server",
+                        ...testCase,
+                    };
+                    const result = safeParseAssessmentOptions(options);
+                    expect(result.success).toBe(false);
+                });
+            });
+        });
+        describe("autoTier field validation", () => {
+            it("should accept autoTier with true value", () => {
+                const options = {
+                    serverName: "test-server",
+                    autoTier: true,
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.autoTier).toBe(true);
+                }
+            });
+            it("should accept autoTier with false value", () => {
+                const options = {
+                    serverName: "test-server",
+                    autoTier: false,
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.autoTier).toBe(false);
+                }
+            });
+            it("should accept undefined autoTier (optional field)", () => {
+                const options = {
+                    serverName: "test-server",
+                    // autoTier omitted
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.autoTier).toBeUndefined();
+                }
+            });
+            it("should reject non-boolean autoTier values", () => {
+                const testCases = [
+                    { autoTier: "true" }, // string instead of boolean
+                    { autoTier: 1 }, // number instead of boolean
+                    { autoTier: null },
+                    { autoTier: {} },
+                    { autoTier: [] },
+                ];
+                testCases.forEach((testCase) => {
+                    const options = {
+                        serverName: "test-server",
+                        ...testCase,
+                    };
+                    const result = safeParseAssessmentOptions(options);
+                    expect(result.success).toBe(false);
+                });
+            });
+        });
+        describe("combined outputFormat and autoTier validation", () => {
+            it("should accept both outputFormat and autoTier together", () => {
+                const options = {
+                    serverName: "test-server",
+                    outputFormat: "tiered",
+                    autoTier: true,
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.outputFormat).toBe("tiered");
+                    expect(result.data.autoTier).toBe(true);
+                }
+            });
+            it("should accept outputFormat without autoTier", () => {
+                const options = {
+                    serverName: "test-server",
+                    outputFormat: "summary-only",
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.outputFormat).toBe("summary-only");
+                    expect(result.data.autoTier).toBeUndefined();
+                }
+            });
+            it("should accept autoTier without outputFormat", () => {
+                const options = {
+                    serverName: "test-server",
+                    autoTier: true,
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.autoTier).toBe(true);
+                    expect(result.data.outputFormat).toBeUndefined();
+                }
+            });
+        });
+        describe("regression prevention", () => {
+            it("should fail if outputFormat schema loses required enum values", () => {
+                // Verify all three enum values are present
+                const validValues = OutputFormatSchema.options;
+                expect(validValues).toContain("full");
+                expect(validValues).toContain("tiered");
+                expect(validValues).toContain("summary-only");
+                expect(validValues.length).toBe(3);
+            });
+            it("should maintain backward compatibility with existing fields", () => {
+                // Test that adding new fields didn't break existing validation
+                const options = {
+                    serverName: "test-server",
+                    verbose: true,
+                    jsonOnly: true,
+                    format: "json",
+                    // Include new fields
+                    outputFormat: "tiered",
+                    autoTier: true,
+                };
+                const result = safeParseAssessmentOptions(options);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.data.verbose).toBe(true);
+                    expect(result.data.jsonOnly).toBe(true);
+                    expect(result.data.format).toBe("json");
+                    expect(result.data.outputFormat).toBe("tiered");
+                    expect(result.data.autoTier).toBe(true);
+                }
+            });
+        });
+    });
+    describe("[TEST-REQ-002] jsonl-events.ts - TieredOutputEvent and emitTieredOutput", () => {
+        // Capture console.error output for testing
+        let consoleSpy;
+        let errorOutput = [];
+        beforeEach(() => {
+            errorOutput = [];
+            // Spy on console.error to capture JSONL output
+            consoleSpy = jest
+                .spyOn(console, "error")
+                .mockImplementation((msg) => {
+                errorOutput.push(msg);
+            });
+        });
+        afterEach(() => {
+            // Restore original console.error
+            if (consoleSpy) {
+                consoleSpy.mockRestore();
+            }
+        });
+        describe("emitTieredOutput function", () => {
+            it("should emit valid JSONL with correct event type", () => {
+                const tiers = {
+                    executiveSummary: {
+                        path: "/tmp/output/executive-summary.json",
+                        estimatedTokens: 500,
+                    },
+                    toolSummaries: {
+                        path: "/tmp/output/tool-summaries.json",
+                        estimatedTokens: 1500,
+                        toolCount: 10,
+                    },
+                };
+                emitTieredOutput("/tmp/output", "summary-only", tiers);
+                expect(errorOutput.length).toBe(1);
+                const parsed = JSON.parse(errorOutput[0]);
+                expect(parsed.event).toBe("tiered_output_generated");
+                expect(parsed.outputDir).toBe("/tmp/output");
+                expect(parsed.outputFormat).toBe("summary-only");
+                expect(parsed.tiers).toEqual(tiers);
+            });
+            it("should include version and schemaVersion fields", () => {
+                const tiers = {
+                    executiveSummary: {
+                        path: "/tmp/output/executive-summary.json",
+                        estimatedTokens: 500,
+                    },
+                    toolSummaries: {
+                        path: "/tmp/output/tool-summaries.json",
+                        estimatedTokens: 1500,
+                        toolCount: 10,
+                    },
+                };
+                emitTieredOutput("/tmp/output", "tiered", tiers);
+                expect(errorOutput.length).toBe(1);
+                const parsed = JSON.parse(errorOutput[0]);
+                expect(parsed.version).toBe(INSPECTOR_VERSION);
+                expect(parsed.schemaVersion).toBe(SCHEMA_VERSION);
+            });
+            it("should include all required tier properties", () => {
+                const tiers = {
+                    executiveSummary: {
+                        path: "/tmp/output/executive-summary.json",
+                        estimatedTokens: 500,
+                    },
+                    toolSummaries: {
+                        path: "/tmp/output/tool-summaries.json",
+                        estimatedTokens: 1500,
+                        toolCount: 10,
+                    },
+                    toolDetails: {
+                        directory: "/tmp/output/tools",
+                        fileCount: 10,
+                        totalEstimatedTokens: 5000,
+                    },
+                };
+                emitTieredOutput("/tmp/output", "tiered", tiers);
+                expect(errorOutput.length).toBe(1);
+                const parsed = JSON.parse(errorOutput[0]);
+                expect(parsed.tiers.executiveSummary).toEqual({
+                    path: "/tmp/output/executive-summary.json",
+                    estimatedTokens: 500,
+                });
+                expect(parsed.tiers.toolSummaries).toEqual({
+                    path: "/tmp/output/tool-summaries.json",
+                    estimatedTokens: 1500,
+                    toolCount: 10,
+                });
+                expect(parsed.tiers.toolDetails).toEqual({
+                    directory: "/tmp/output/tools",
+                    fileCount: 10,
+                    totalEstimatedTokens: 5000,
+                });
+            });
+            it("should handle missing optional toolDetails tier", () => {
+                const tiers = {
+                    executiveSummary: {
+                        path: "/tmp/output/executive-summary.json",
+                        estimatedTokens: 500,
+                    },
+                    toolSummaries: {
+                        path: "/tmp/output/tool-summaries.json",
+                        estimatedTokens: 1500,
+                        toolCount: 10,
+                    },
+                    // toolDetails omitted (optional)
+                };
+                emitTieredOutput("/tmp/output", "summary-only", tiers);
+                expect(errorOutput.length).toBe(1);
+                const parsed = JSON.parse(errorOutput[0]);
+                expect(parsed.tiers.executiveSummary).toBeDefined();
+                expect(parsed.tiers.toolSummaries).toBeDefined();
+                expect(parsed.tiers.toolDetails).toBeUndefined();
+            });
+            it("should emit valid JSON that can be parsed", () => {
+                const tiers = {
+                    executiveSummary: {
+                        path: "/tmp/output/executive-summary.json",
+                        estimatedTokens: 500,
+                    },
+                    toolSummaries: {
+                        path: "/tmp/output/tool-summaries.json",
+                        estimatedTokens: 1500,
+                        toolCount: 10,
+                    },
+                };
+                emitTieredOutput("/tmp/output", "tiered", tiers);
+                expect(errorOutput.length).toBe(1);
+                // Should not throw when parsing
+                expect(() => JSON.parse(errorOutput[0])).not.toThrow();
+            });
+        });
+        describe("TieredOutputEvent type structure", () => {
+            it("should enforce correct event type", () => {
+                const event = {
+                    event: "tiered_output_generated",
+                    outputDir: "/tmp/output",
+                    outputFormat: "tiered",
+                    tiers: {
+                        executiveSummary: {
+                            path: "/tmp/output/executive-summary.json",
+                            estimatedTokens: 500,
+                        },
+                        toolSummaries: {
+                            path: "/tmp/output/tool-summaries.json",
+                            estimatedTokens: 1500,
+                            toolCount: 10,
+                        },
+                    },
+                };
+                expect(event.event).toBe("tiered_output_generated");
+            });
+            it("should support both 'tiered' and 'summary-only' output formats", () => {
+                const tieredEvent = {
+                    event: "tiered_output_generated",
+                    outputDir: "/tmp/output",
+                    outputFormat: "tiered",
+                    tiers: {
+                        executiveSummary: { path: "/tmp/exec.json", estimatedTokens: 500 },
+                        toolSummaries: {
+                            path: "/tmp/tools.json",
+                            estimatedTokens: 1500,
+                            toolCount: 10,
+                        },
+                    },
+                };
+                const summaryOnlyEvent = {
+                    event: "tiered_output_generated",
+                    outputDir: "/tmp/output",
+                    outputFormat: "summary-only",
+                    tiers: {
+                        executiveSummary: { path: "/tmp/exec.json", estimatedTokens: 500 },
+                        toolSummaries: {
+                            path: "/tmp/tools.json",
+                            estimatedTokens: 1500,
+                            toolCount: 10,
+                        },
+                    },
+                };
+                expect(tieredEvent.outputFormat).toBe("tiered");
+                expect(summaryOnlyEvent.outputFormat).toBe("summary-only");
+            });
+            it("should have correct structure for all tier properties", () => {
+                const event = {
+                    event: "tiered_output_generated",
+                    outputDir: "/tmp/output",
+                    outputFormat: "tiered",
+                    tiers: {
+                        executiveSummary: {
+                            path: "/tmp/output/executive-summary.json",
+                            estimatedTokens: 500,
+                        },
+                        toolSummaries: {
+                            path: "/tmp/output/tool-summaries.json",
+                            estimatedTokens: 1500,
+                            toolCount: 10,
+                        },
+                        toolDetails: {
+                            directory: "/tmp/output/tools",
+                            fileCount: 10,
+                            totalEstimatedTokens: 5000,
+                        },
+                    },
+                };
+                // Verify executive summary structure
+                expect(event.tiers.executiveSummary).toHaveProperty("path");
+                expect(event.tiers.executiveSummary).toHaveProperty("estimatedTokens");
+                expect(typeof event.tiers.executiveSummary.path).toBe("string");
+                expect(typeof event.tiers.executiveSummary.estimatedTokens).toBe("number");
+                // Verify tool summaries structure
+                expect(event.tiers.toolSummaries).toHaveProperty("path");
+                expect(event.tiers.toolSummaries).toHaveProperty("estimatedTokens");
+                expect(event.tiers.toolSummaries).toHaveProperty("toolCount");
+                expect(typeof event.tiers.toolSummaries.path).toBe("string");
+                expect(typeof event.tiers.toolSummaries.estimatedTokens).toBe("number");
+                expect(typeof event.tiers.toolSummaries.toolCount).toBe("number");
+                // Verify tool details structure (optional)
+                expect(event.tiers.toolDetails).toHaveProperty("directory");
+                expect(event.tiers.toolDetails).toHaveProperty("fileCount");
+                expect(event.tiers.toolDetails).toHaveProperty("totalEstimatedTokens");
+                expect(typeof event.tiers.toolDetails?.directory).toBe("string");
+                expect(typeof event.tiers.toolDetails?.fileCount).toBe("number");
+                expect(typeof event.tiers.toolDetails?.totalEstimatedTokens).toBe("number");
+            });
+        });
+        describe("JSONL format compliance", () => {
+            it("should emit single-line JSON (no newlines within object)", () => {
+                const tiers = {
+                    executiveSummary: {
+                        path: "/tmp/output/executive-summary.json",
+                        estimatedTokens: 500,
+                    },
+                    toolSummaries: {
+                        path: "/tmp/output/tool-summaries.json",
+                        estimatedTokens: 1500,
+                        toolCount: 10,
+                    },
+                };
+                emitTieredOutput("/tmp/output", "tiered", tiers);
+                expect(errorOutput.length).toBe(1);
+                const output = errorOutput[0];
+                // Should be single line (may have trailing newline from console.error)
+                const lines = output.trim().split("\n");
+                expect(lines.length).toBe(1);
+            });
+            it("should emit parseable JSON Lines format", () => {
+                const tiers1 = {
+                    executiveSummary: { path: "/tmp/1/exec.json", estimatedTokens: 500 },
+                    toolSummaries: {
+                        path: "/tmp/1/tools.json",
+                        estimatedTokens: 1500,
+                        toolCount: 10,
+                    },
+                };
+                const tiers2 = {
+                    executiveSummary: { path: "/tmp/2/exec.json", estimatedTokens: 600 },
+                    toolSummaries: {
+                        path: "/tmp/2/tools.json",
+                        estimatedTokens: 1600,
+                        toolCount: 12,
+                    },
+                };
+                emitTieredOutput("/tmp/output1", "tiered", tiers1);
+                emitTieredOutput("/tmp/output2", "summary-only", tiers2);
+                expect(errorOutput.length).toBe(2);
+                // Each line should be valid JSON
+                const parsed1 = JSON.parse(errorOutput[0]);
+                const parsed2 = JSON.parse(errorOutput[1]);
+                expect(parsed1.outputDir).toBe("/tmp/output1");
+                expect(parsed2.outputDir).toBe("/tmp/output2");
+            });
+        });
+    });
+    describe("Code duplication documentation", () => {
+        it("should have matching TieredOutputEvent interface across files", () => {
+            // This test documents the intentional duplication between
+            // cli/src/lib/jsonl-events.ts and scripts/lib/jsonl-events.ts
+            // as documented in FIX-002 and FIX-003
+            // The interface structure is tested above. This test serves as
+            // documentation that the duplication is intentional and tracked.
+            const expectedEventType = "tiered_output_generated";
+            const expectedOutputFormats = ["tiered", "summary-only"];
+            expect(expectedEventType).toBe("tiered_output_generated");
+            expect(expectedOutputFormats).toEqual(["tiered", "summary-only"]);
+        });
+        it("should maintain consistency reminder for developers", () => {
+            // This test serves as a reminder that TieredOutputEvent and
+            // emitTieredOutput are duplicated across two files and must
+            // be kept in sync when changes are made.
+            const files = [
+                "cli/src/lib/jsonl-events.ts",
+                "scripts/lib/jsonl-events.ts",
+            ];
+            // Documentation reminder
+            expect(files.length).toBe(2);
+            expect(files[0]).toContain("cli/src/lib/jsonl-events.ts");
+            expect(files[1]).toContain("scripts/lib/jsonl-events.ts");
+        });
+    });
+});

package/build/assess-full.js

@@ -13,8 +13,9 @@ import { ScopedListenerConfig } from "./lib/event-config.js";
 // Import from extracted modules
 import { parseArgs } from "./lib/cli-parser.js";
 import { runFullAssessment } from "./lib/assessment-runner.js";
-import { saveResults, displaySummary } from "./lib/result-output.js";
+import { saveResults, saveTieredResults, saveSummaryOnly, displaySummary, } from "./lib/result-output.js";
 import { handleComparison, displayComparisonSummary, } from "./lib/comparison-handler.js";
+import { shouldAutoTier, formatTokenEstimate, } from "../../client/lib/lib/assessment/summarizer/index.js";
 // ============================================================================
 // Main Entry Point
 // ============================================================================
@@ -60,13 +61,54 @@ async function main() {
         if (!options.jsonOnly) {
             displaySummary(results);
         }
-        // Save results to file
-        const outputPath = saveResults(options.serverName, results, options);
-        if (options.jsonOnly) {
-            console.log(outputPath);
+        // Determine output format (Issue #136: Tiered output strategy)
+        let effectiveFormat = options.outputFormat || "full";
+        // Auto-tier if requested and results exceed threshold
+        if (effectiveFormat === "full" &&
+            options.autoTier &&
+            shouldAutoTier(results)) {
+            effectiveFormat = "tiered";
+            if (!options.jsonOnly) {
+                const estimate = formatTokenEstimate(Math.ceil(JSON.stringify(results).length / 4));
+                console.log(`\n📊 Auto-tiering enabled: ${estimate.tokens} tokens (${estimate.recommendation})`);
+            }
+        }
+        // Save results in appropriate format
+        let outputPath;
+        if (effectiveFormat === "tiered") {
+            const tieredOutput = saveTieredResults(options.serverName, results, options);
+            outputPath = tieredOutput.outputDir;
+            if (options.jsonOnly) {
+                console.log(outputPath);
+            }
+            else {
+                console.log(`\n📁 Tiered output saved to: ${outputPath}/`);
+                console.log(`   📋 Executive Summary: executive-summary.json`);
+                console.log(`   📋 Tool Summaries: tool-summaries.json`);
+                console.log(`   📋 Tool Details: tools/ (${tieredOutput.toolDetailRefs.length} files)`);
+                console.log(`   📊 Total tokens: ~${tieredOutput.executiveSummary.estimatedTokens + tieredOutput.toolSummaries.estimatedTokens} (summaries only)\n`);
+            }
+        }
+        else if (effectiveFormat === "summary-only") {
+            outputPath = saveSummaryOnly(options.serverName, results, options);
+            if (options.jsonOnly) {
+                console.log(outputPath);
+            }
+            else {
+                console.log(`\n📁 Summary output saved to: ${outputPath}/`);
+                console.log(`   📋 Executive Summary: executive-summary.json`);
+                console.log(`   📋 Tool Summaries: tool-summaries.json\n`);
+            }
         }
         else {
-            console.log(`📄 Results saved to: ${outputPath}\n`);
+            // Default: full output
+            outputPath = saveResults(options.serverName, results, options);
+            if (options.jsonOnly) {
+                console.log(outputPath);
+            }
+            else {
+                console.log(`📄 Results saved to: ${outputPath}\n`);
+            }
         }
         // Exit with appropriate code
         const exitCode = results.overallStatus === "FAIL" ? 1 : 0;

package/build/lib/assessment-runner/assessment-executor.js

@@ -77,7 +77,7 @@ export async function runFullAssessment(options) {
             description: r.description,
             mimeType: r.mimeType,
         }));
-        // Get resource templates from resources/templates/list (Issue #132)
+        // Get resource templates from resources/templates/list (Issue #131)
         // This is a SEPARATE MCP endpoint - templates are NOT included in resources/list
         try {
             const templatesResponse = await client.listResourceTemplates();

package/build/lib/cli-parser.js

@@ -11,7 +11,7 @@
 import { ASSESSMENT_CATEGORY_METADATA, } from "../../../client/lib/lib/assessmentTypes.js";
 import { ASSESSMENT_PROFILES, getProfileHelpText, TIER_1_CORE_SECURITY, TIER_2_COMPLIANCE, TIER_3_CAPABILITY, TIER_4_EXTENDED, } from "../profiles.js";
 import packageJson from "../../package.json" with { type: "json" };
-import { safeParseModuleNames, LogLevelSchema, ReportFormatSchema, AssessmentProfileNameSchema, } from "./cli-parserSchemas.js";
+import { safeParseModuleNames, LogLevelSchema, ReportFormatSchema, OutputFormatSchema, AssessmentProfileNameSchema, } from "./cli-parserSchemas.js";
 // ============================================================================
 // Constants
 // ============================================================================
@@ -197,6 +197,35 @@ export function parseArgs(argv) {
                 // Enable official MCP conformance tests (requires HTTP/SSE transport with serverUrl)
                 options.conformanceEnabled = true;
                 break;
+            case "--output-format": {
+                // Issue #136: Tiered output strategy for large assessments
+                const outputFormatValue = args[++i];
+                if (!outputFormatValue) {
+                    console.error("Error: --output-format requires a format");
+                    console.error("Valid formats: full, tiered, summary-only");
+                    setTimeout(() => process.exit(1), 10);
+                    options.helpRequested = true;
+                    return options;
+                }
+                const parseResult = OutputFormatSchema.safeParse(outputFormatValue);
+                if (!parseResult.success) {
+                    console.error(`Error: Invalid output format: ${outputFormatValue}`);
+                    console.error("Valid formats: full, tiered, summary-only");
+                    setTimeout(() => process.exit(1), 10);
+                    options.helpRequested = true;
+                    return options;
+                }
+                options.outputFormat = parseResult.data;
+                break;
+            }
+            case "--auto-tier":
+                // Issue #136: Auto-enable tiered output when results exceed token threshold
+                options.autoTier = true;
+                break;
+            case "--stage-b-verbose":
+                // Issue #137: Stage B enrichment for Claude semantic analysis
+                options.stageBVerbose = true;
+                break;
             case "--profile": {
                 const profileValue = args[++i];
                 if (!profileValue) {
@@ -362,6 +391,14 @@ Options:
   --temporal-invocations <n>  Number of invocations per tool for rug pull detection (default: 25)
   --skip-temporal        Skip temporal/rug pull testing (faster assessment)
   --conformance          Enable official MCP conformance tests (experimental, requires HTTP/SSE transport)
+  --output-format <fmt>  Output format: full (default), tiered, summary-only
+                         full: Complete JSON output (existing behavior)
+                         tiered: Directory with executive-summary.json, tool-summaries.json, tools/
+                         summary-only: Executive summary + tool summaries (no per-tool details)
+  --auto-tier            Auto-enable tiered output when results exceed 100K tokens
+  --stage-b-verbose      Enable Stage B enrichment for Claude semantic analysis
+                         Adds evidence samples, payload correlations, and confidence
+                         breakdowns to tiered output (Tier 2 + Tier 3)
   --skip-modules <list>  Skip specific modules (comma-separated)
   --only-modules <list>  Run only specific modules (comma-separated)
   --json                 Output only JSON path (no console summary)

package/build/lib/cli-parserSchemas.js

@@ -8,9 +8,9 @@
  */
 import { z } from "zod";
 // Import shared schemas from single source of truth
-import { LogLevelSchema, ReportFormatSchema, TransportTypeSchema, ZOD_SCHEMA_VERSION, } from "../../../client/lib/lib/assessment/sharedSchemas.js";
+import { LogLevelSchema, ReportFormatSchema, OutputFormatSchema, TransportTypeSchema, ZOD_SCHEMA_VERSION, } from "../../../client/lib/lib/assessment/sharedSchemas.js";
 // Re-export shared schemas for backwards compatibility
-export { LogLevelSchema, ReportFormatSchema, TransportTypeSchema };
+export { LogLevelSchema, ReportFormatSchema, OutputFormatSchema, TransportTypeSchema, };
 // Export schema version for consumers
 export { ZOD_SCHEMA_VERSION };
 /**
@@ -121,6 +121,9 @@ export const AssessmentOptionsSchema = z
     profile: AssessmentProfileNameSchema.optional(),
     logLevel: LogLevelSchema.optional(),
     listModules: z.boolean().optional(),
+    outputFormat: OutputFormatSchema.optional(),
+    autoTier: z.boolean().optional(),
+    stageBVerbose: z.boolean().optional(),
 })
     .refine((data) => !(data.profile && (data.skipModules?.length || data.onlyModules?.length)), {
     message: "--profile cannot be used with --skip-modules or --only-modules",

package/build/lib/jsonl-events.js

@@ -255,3 +255,18 @@ export function emitPhaseComplete(phase, duration) {
         duration,
     });
 }
+/**
+ * Emit tiered_output_generated event when tiered output files are created.
+ * Includes paths and token estimates for each tier.
+ *
+ * NOTE: This function is duplicated in scripts/lib/jsonl-events.ts.
+ * Keep both implementations in sync. See TieredOutputEvent comment above.
+ */
+export function emitTieredOutput(outputDir, outputFormat, tiers) {
+    emitJSONL({
+        event: "tiered_output_generated",
+        outputDir,
+        outputFormat,
+        tiers,
+    });
+}

package/build/lib/result-output.js

@@ -7,9 +7,12 @@
  * @module cli/lib/result-output
  */
 import * as fs from "fs";
+import * as path from "path";
 import { ASSESSMENT_CATEGORY_METADATA, } from "../../../client/lib/lib/assessmentTypes.js";
 import { createFormatter } from "../../../client/lib/lib/reportFormatters/index.js";
 import { generatePolicyComplianceReport } from "../../../client/lib/services/assessment/PolicyComplianceGenerator.js";
+import { AssessmentSummarizer, estimateTokens, } from "../../../client/lib/lib/assessment/summarizer/index.js";
+import { emitTieredOutput } from "./jsonl-events.js";
 // ============================================================================
 // Result Output
 // ============================================================================
@@ -53,6 +56,156 @@ export function saveResults(serverName, results, options) {
     }
     return finalPath;
 }
+/**
+ * Save results in tiered format for LLM consumption.
+ * Creates a directory with executive summary, tool summaries, and per-tool details.
+ *
+ * Issue #136: Tiered output strategy for large assessments
+ *
+ * @param serverName - Server name for output directory
+ * @param results - Full assessment results
+ * @param options - Assessment options
+ * @returns Path to output directory
+ */
+export function saveTieredResults(serverName, results, options) {
+    // Issue #137: Pass stageBVerbose option to summarizer for Stage B enrichment
+    const summarizer = new AssessmentSummarizer({
+        stageBVerbose: options.stageBVerbose,
+    });
+    // Determine output directory
+    const defaultDir = `/tmp/inspector-full-assessment-${serverName}`;
+    const outputDir = options.outputPath || defaultDir;
+    // Create directory structure
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.mkdirSync(path.join(outputDir, "tools"), { recursive: true });
+    // Tier 1: Executive Summary
+    const executiveSummary = summarizer.generateExecutiveSummary(results);
+    const executivePath = path.join(outputDir, "executive-summary.json");
+    fs.writeFileSync(executivePath, JSON.stringify(executiveSummary, null, 2));
+    // Tier 2: Tool Summaries
+    const toolSummaries = summarizer.generateToolSummaries(results);
+    const toolSummariesPath = path.join(outputDir, "tool-summaries.json");
+    fs.writeFileSync(toolSummariesPath, JSON.stringify(toolSummaries, null, 2));
+    // Tier 3: Per-Tool Details
+    const toolDetailRefs = [];
+    const toolNames = summarizer.getAllToolNames(results);
+    for (const toolName of toolNames) {
+        const detail = summarizer.extractToolDetail(toolName, results);
+        const safeFileName = toolName.replace(/[^a-zA-Z0-9_-]/g, "_");
+        const relativePath = `tools/${safeFileName}.json`;
+        const absolutePath = path.join(outputDir, relativePath);
+        fs.writeFileSync(absolutePath, JSON.stringify(detail, null, 2));
+        const stats = fs.statSync(absolutePath);
+        toolDetailRefs.push({
+            toolName,
+            relativePath,
+            absolutePath,
+            fileSizeBytes: stats.size,
+            estimatedTokens: estimateTokens(detail),
+        });
+    }
+    // Create index file with all paths
+    const tieredOutput = {
+        executiveSummary,
+        toolSummaries,
+        toolDetailRefs,
+        outputDir,
+        paths: {
+            executiveSummary: executivePath,
+            toolSummaries: toolSummariesPath,
+            toolDetailsDir: path.join(outputDir, "tools"),
+        },
+    };
+    // Save index file
+    const indexPath = path.join(outputDir, "index.json");
+    fs.writeFileSync(indexPath, JSON.stringify({
+        timestamp: new Date().toISOString(),
+        serverName,
+        outputFormat: "tiered",
+        paths: tieredOutput.paths,
+        toolCount: toolDetailRefs.length,
+        totalEstimatedTokens: {
+            executiveSummary: executiveSummary.estimatedTokens,
+            toolSummaries: toolSummaries.estimatedTokens,
+            toolDetails: toolDetailRefs.reduce((sum, r) => sum + r.estimatedTokens, 0),
+        },
+    }, null, 2));
+    // Emit JSONL event for tiered output (Issue #136)
+    emitTieredOutput(outputDir, "tiered", {
+        executiveSummary: {
+            path: executivePath,
+            estimatedTokens: executiveSummary.estimatedTokens,
+        },
+        toolSummaries: {
+            path: toolSummariesPath,
+            estimatedTokens: toolSummaries.estimatedTokens,
+            toolCount: toolSummaries.tools.length,
+        },
+        toolDetails: {
+            directory: path.join(outputDir, "tools"),
+            fileCount: toolDetailRefs.length,
+            totalEstimatedTokens: toolDetailRefs.reduce((sum, r) => sum + r.estimatedTokens, 0),
+        },
+    });
+    return tieredOutput;
+}
+/**
+ * Save results in summary-only format (Tier 1 + Tier 2, no per-tool details).
+ *
+ * Issue #136: Tiered output strategy for large assessments
+ *
+ * @param serverName - Server name for output
+ * @param results - Full assessment results
+ * @param options - Assessment options
+ * @returns Path to output directory
+ */
+export function saveSummaryOnly(serverName, results, options) {
+    // Issue #137: Pass stageBVerbose option to summarizer for Stage B enrichment
+    const summarizer = new AssessmentSummarizer({
+        stageBVerbose: options.stageBVerbose,
+    });
+    // Determine output directory
+    const defaultDir = `/tmp/inspector-full-assessment-${serverName}`;
+    const outputDir = options.outputPath || defaultDir;
+    // Create directory
+    fs.mkdirSync(outputDir, { recursive: true });
+    // Tier 1: Executive Summary
+    const executiveSummary = summarizer.generateExecutiveSummary(results);
+    const executivePath = path.join(outputDir, "executive-summary.json");
+    fs.writeFileSync(executivePath, JSON.stringify(executiveSummary, null, 2));
+    // Tier 2: Tool Summaries
+    const toolSummaries = summarizer.generateToolSummaries(results);
+    const toolSummariesPath = path.join(outputDir, "tool-summaries.json");
+    fs.writeFileSync(toolSummariesPath, JSON.stringify(toolSummaries, null, 2));
+    // Create index file
+    const indexPath = path.join(outputDir, "index.json");
+    fs.writeFileSync(indexPath, JSON.stringify({
+        timestamp: new Date().toISOString(),
+        serverName,
+        outputFormat: "summary-only",
+        paths: {
+            executiveSummary: executivePath,
+            toolSummaries: toolSummariesPath,
+        },
+        totalEstimatedTokens: {
+            executiveSummary: executiveSummary.estimatedTokens,
+            toolSummaries: toolSummaries.estimatedTokens,
+        },
+    }, null, 2));
+    // Emit JSONL event for summary-only output (Issue #136)
+    emitTieredOutput(outputDir, "summary-only", {
+        executiveSummary: {
+            path: executivePath,
+            estimatedTokens: executiveSummary.estimatedTokens,
+        },
+        toolSummaries: {
+            path: toolSummariesPath,
+            estimatedTokens: toolSummaries.estimatedTokens,
+            toolCount: toolSummaries.tools.length,
+        },
+    });
+    return outputDir;
+}
 // ============================================================================
 // Summary Display
 // ============================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bryan-thompson/inspector-assessment-cli",
-  "version": "1.34.1",
+  "version": "1.35.1",
   "description": "CLI for the Enhanced MCP Inspector with assessment capabilities",
   "license": "MIT",
   "author": "Bryan Thompson <bryan@triepod.ai>",