aiwcli 0.15.5 → 0.17.0

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/artifacts.test.ts

@@ -0,0 +1,234 @@
+import { expect } from "chai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  formatReviewMarkdown,
+  formatCombinedMarkdown,
+  buildInlineReviewSummary,
+  extractTopIssuesText,
+  buildHighIssuesDocument,
+  buildCombinedJson,
+  generateReviewIndex,
+} from "../artifacts.js";
+import {
+  createSampleReviewerResult,
+  createSampleCombinedResult,
+  createTempDir,
+  cleanupTempDir,
+} from "./helpers.js";
+
+describe("artifacts", () => {
+  describe("formatReviewMarkdown", () => {
+    it("includes overall verdict in output", () => {
+      const results = [createSampleReviewerResult({ name: "claude", verdict: "pass" })];
+      const md = formatReviewMarkdown(results, "pass");
+      expect(md).to.include("PASS");
+      expect(md).to.include("Claude");
+    });
+
+    it("handles empty results", () => {
+      const md = formatReviewMarkdown([], "pass");
+      expect(md).to.include("PASS");
+    });
+
+    it("includes custom title", () => {
+      const md = formatReviewMarkdown([], "pass", "Custom Review Title");
+      expect(md).to.include("Custom Review Title");
+    });
+
+    it("marks default summaries with warning", () => {
+      const result = createSampleReviewerResult({
+        data: {
+          verdict: "pass",
+          summary: "No summary provided.",
+          summary_source: "default",
+          issues: [],
+          missing_sections: [],
+          questions: [],
+        },
+      });
+      const md = formatReviewMarkdown([result], "pass");
+      expect(md).to.include("⚠️");
+    });
+  });
+
+  describe("formatCombinedMarkdown", () => {
+    it("includes plan hash and overall verdict", () => {
+      const combined = createSampleCombinedResult();
+      const md = formatCombinedMarkdown(combined);
+      expect(md).to.include("abc123def456");
+      expect(md).to.include("PASS");
+    });
+
+    it("includes orchestration section when present", () => {
+      const combined = createSampleCombinedResult();
+      const md = formatCombinedMarkdown(combined);
+      expect(md).to.include("Orchestration");
+      expect(md).to.include("medium");
+    });
+
+    it("includes agent reviewer sections", () => {
+      const combined = createSampleCombinedResult({
+        agents: {
+          "test-agent": createSampleReviewerResult({ name: "test-agent", verdict: "warn" }),
+        },
+      });
+      const md = formatCombinedMarkdown(combined);
+      expect(md).to.include("test-agent");
+      expect(md).to.include("warn");
+    });
+  });
+
+  describe("buildInlineReviewSummary", () => {
+    it("includes overall verdict", () => {
+      const combined = createSampleCombinedResult();
+      const summary = buildInlineReviewSummary(combined);
+      expect(summary).to.include("PASS");
+    });
+
+    it("lists high-severity issues", () => {
+      const combined = createSampleCombinedResult({
+        agents: {
+          test: createSampleReviewerResult({
+            name: "test",
+            data: {
+              verdict: "warn",
+              summary: "Issues found",
+              summary_source: "reviewer",
+              issues: [
+                { severity: "high", category: "security", issue: "SQL injection", suggested_fix: "Use parameterized queries" },
+              ],
+              missing_sections: [],
+              questions: [],
+            },
+          }),
+        },
+      });
+      const summary = buildInlineReviewSummary(combined);
+      expect(summary).to.include("SQL injection");
+      expect(summary).to.include("security");
+    });
+
+    it("truncates to maxChars", () => {
+      const combined = createSampleCombinedResult();
+      const summary = buildInlineReviewSummary(combined, 5, 20);
+      expect(summary.length).to.be.at.most(20);
+    });
+  });
+
+  describe("extractTopIssuesText", () => {
+    it("returns default message for no issues", () => {
+      const combined = createSampleCombinedResult();
+      const text = extractTopIssuesText(combined);
+      expect(text).to.equal("Review found critical issues");
+    });
+
+    it("extracts high-severity issues from reviewers", () => {
+      const combined = createSampleCombinedResult({
+        agents: {
+          r1: createSampleReviewerResult({
+            name: "r1",
+            data: {
+              verdict: "fail",
+              summary: "Problems",
+              summary_source: "reviewer",
+              issues: [{ severity: "high", category: "security", issue: "XSS vulnerability", suggested_fix: "sanitize" }],
+              missing_sections: [],
+              questions: [],
+            },
+          }),
+        },
+      });
+      const text = extractTopIssuesText(combined);
+      expect(text).to.include("XSS vulnerability");
+      expect(text).to.include("r1");
+    });
+  });
+
+  describe("buildHighIssuesDocument", () => {
+    it("reports no high-severity issues when none exist", () => {
+      const combined = createSampleCombinedResult();
+      const doc = buildHighIssuesDocument(combined);
+      expect(doc).to.include("No high-severity issues found");
+    });
+
+    it("lists high-severity issues by reviewer", () => {
+      const combined = createSampleCombinedResult({
+        agents: {
+          "security-agent": createSampleReviewerResult({
+            name: "security-agent",
+            verdict: "fail",
+            data: {
+              verdict: "fail",
+              summary: "Critical",
+              summary_source: "reviewer",
+              issues: [
+                { severity: "high", category: "auth", issue: "Missing auth check", suggested_fix: "Add middleware" },
+                { severity: "low", category: "style", issue: "Formatting", suggested_fix: "Run prettier" },
+              ],
+              missing_sections: [],
+              questions: [],
+            },
+          }),
+        },
+      });
+      const doc = buildHighIssuesDocument(combined);
+      expect(doc).to.include("Missing auth check");
+      expect(doc).to.not.include("Formatting"); // low severity excluded
+    });
+  });
+
+  describe("buildCombinedJson", () => {
+    it("includes metadata with plan hash", () => {
+      const combined = createSampleCombinedResult();
+      const json = buildCombinedJson(combined);
+      expect((json.metadata as any).plan_hash).to.equal("abc123def456");
+    });
+
+    it("includes overall verdict", () => {
+      const combined = createSampleCombinedResult();
+      const json = buildCombinedJson(combined);
+      expect((json.overall as any).verdict).to.equal("pass");
+    });
+
+    it("excludes low-severity issues from JSON", () => {
+      const combined = createSampleCombinedResult({
+        agents: {
+          test: createSampleReviewerResult({
+            name: "test",
+            data: {
+              verdict: "warn",
+              summary: "ok",
+              summary_source: "reviewer",
+              issues: [
+                { severity: "high", category: "sec", issue: "important", suggested_fix: "fix" },
+                { severity: "low", category: "style", issue: "trivial", suggested_fix: "ignore" },
+              ],
+              missing_sections: [],
+              questions: [],
+            },
+          }),
+        },
+      });
+      const json = buildCombinedJson(combined);
+      const reviewers = json.agents as Record<string, any>;
+      expect(reviewers.test.issues).to.have.length(1);
+      expect(reviewers.test.issues[0].issue).to.equal("important");
+    });
+  });
+
+  describe("generateReviewIndex", () => {
+    it("includes plan hash and verdict in frontmatter", () => {
+      const combined = createSampleCombinedResult();
+      const index = generateReviewIndex(combined);
+      expect(index).to.include("plan_hash: abc123def456");
+      expect(index).to.include("overall_verdict: pass");
+    });
+
+    it("includes iteration number when provided", () => {
+      const combined = createSampleCombinedResult();
+      const index = generateReviewIndex(combined, 2);
+      expect(index).to.include("iteration: 2");
+    });
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/cc-native-state.test.ts

@@ -0,0 +1,170 @@
+import { expect } from "chai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  getCcNativeState,
+  saveCcNativeState,
+  isPlanAlreadyReviewed,
+  wasPlanPreviouslyDenied,
+  markPlanReviewed,
+  wasQuestionsAsked,
+  markQuestionsAsked,
+  getStuckDetectionState,
+  updateStuckDetectionState,
+} from "../cc-native-state.js";
+import {
+  createTempDir,
+  cleanupTempDir,
+  setProjectRoot,
+  createSampleState,
+  createSampleIndex,
+  writeStateJson,
+  writeIndexJson,
+} from "./helpers.js";
+
+describe("cc-native-state", () => {
+  let tmpDir: string;
+  let restoreRoot: () => void;
+  const sessionId = "test-session-123";
+  const contextId = "test-context";
+
+  beforeEach(() => {
+    tmpDir = createTempDir("ccnstate-test-");
+    restoreRoot = setProjectRoot(tmpDir);
+
+    // Set up context with session binding
+    const state = createSampleState({
+      id: contextId,
+      session_ids: [sessionId],
+      last_session: { session_id: sessionId, saved_at: "2026-02-08T10:30:00.000", save_reason: "test" },
+    });
+    writeStateJson(tmpDir, contextId, state);
+    writeIndexJson(tmpDir, createSampleIndex(
+      { [contextId]: { summary: "Test", mode: "active", last_active: "2026-02-08T10:30:00.000" } },
+      { [sessionId]: contextId },
+    ));
+  });
+
+  afterEach(() => {
+    restoreRoot();
+    cleanupTempDir(tmpDir);
+  });
+
+  describe("getCcNativeState", () => {
+    it("returns null when no cc_native key", () => {
+      const result = getCcNativeState(sessionId, tmpDir);
+      expect(result).to.be.null;
+    });
+
+    it("returns cc_native object when present", () => {
+      // Manually add cc_native to state
+      const statePath = path.join(tmpDir, "_output", "contexts", contextId, "state.json");
+      const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+      state.cc_native = { plan_review: { plan_hash: "abc", reviewed_at: "now", decision: "allow" } };
+      fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+
+      const result = getCcNativeState(sessionId, tmpDir);
+      expect(result).to.not.be.null;
+      expect(result!.plan_review?.plan_hash).to.equal("abc");
+    });
+
+    it("returns null for unknown session", () => {
+      expect(getCcNativeState("nonexistent", tmpDir)).to.be.null;
+    });
+  });
+
+  describe("isPlanAlreadyReviewed", () => {
+    it("returns false when no cc_native state", () => {
+      expect(isPlanAlreadyReviewed(sessionId, "hash123", tmpDir)).to.be.false;
+    });
+
+    it("returns true when plan hash matches", () => {
+      const statePath = path.join(tmpDir, "_output", "contexts", contextId, "state.json");
+      const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+      state.cc_native = { plan_review: { plan_hash: "hash123", reviewed_at: "now", decision: "allow" } };
+      fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+
+      expect(isPlanAlreadyReviewed(sessionId, "hash123", tmpDir)).to.be.true;
+    });
+
+    it("returns false when plan hash does not match", () => {
+      const statePath = path.join(tmpDir, "_output", "contexts", contextId, "state.json");
+      const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+      state.cc_native = { plan_review: { plan_hash: "other", reviewed_at: "now", decision: "allow" } };
+      fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+
+      expect(isPlanAlreadyReviewed(sessionId, "hash123", tmpDir)).to.be.false;
+    });
+  });
+
+  describe("wasPlanPreviouslyDenied", () => {
+    it("returns false when no review state", () => {
+      expect(wasPlanPreviouslyDenied(sessionId, "hash123", tmpDir)).to.be.false;
+    });
+
+    it("returns true for deny decision", () => {
+      const statePath = path.join(tmpDir, "_output", "contexts", contextId, "state.json");
+      const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+      state.cc_native = { plan_review: { plan_hash: "hash123", reviewed_at: "now", decision: "deny" } };
+      fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+
+      expect(wasPlanPreviouslyDenied(sessionId, "hash123", tmpDir)).to.be.true;
+    });
+
+    it("returns true for hook_deny_iteration decision", () => {
+      const statePath = path.join(tmpDir, "_output", "contexts", contextId, "state.json");
+      const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+      state.cc_native = { plan_review: { plan_hash: "hash123", reviewed_at: "now", decision: "hook_deny_iteration" } };
+      fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+
+      expect(wasPlanPreviouslyDenied(sessionId, "hash123", tmpDir)).to.be.true;
+    });
+
+    it("returns false for allow decision", () => {
+      const statePath = path.join(tmpDir, "_output", "contexts", contextId, "state.json");
+      const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+      state.cc_native = { plan_review: { plan_hash: "abc123", reviewed_at: "now", decision: "allow" } };
+      fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+
+      expect(wasPlanPreviouslyDenied(sessionId, "hash123", tmpDir)).to.be.false;
+    });
+  });
+
+  describe("wasQuestionsAsked", () => {
+    it("returns false when no questions state", () => {
+      expect(wasQuestionsAsked(sessionId, tmpDir)).to.be.false;
+    });
+  });
+
+  describe("markQuestionsAsked", () => {
+    it("marks questions as asked", () => {
+      const result = markQuestionsAsked(sessionId, tmpDir);
+      expect(result).to.be.true;
+      expect(wasQuestionsAsked(sessionId, tmpDir)).to.be.true;
+    });
+  });
+
+  describe("getStuckDetectionState", () => {
+    it("returns null when no stuck detection state", () => {
+      expect(getStuckDetectionState(sessionId, tmpDir)).to.be.null;
+    });
+  });
+
+  describe("updateStuckDetectionState", () => {
+    it("saves and retrieves stuck detection state", () => {
+      const stuckState = {
+        error_hashes: ["hash1"],
+        file_edits: { "file.ts": 3 },
+        test_failures: 2,
+        tool_calls_since_suggestion: 5,
+        suggestion_count: 1,
+      };
+      const ok = updateStuckDetectionState(sessionId, tmpDir, stuckState as any);
+      expect(ok).to.be.true;
+
+      const retrieved = getStuckDetectionState(sessionId, tmpDir);
+      expect(retrieved).to.not.be.null;
+      expect(retrieved!.error_hashes).to.deep.equal(["hash1"]);
+    });
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/cli-output-parser.test.ts

@@ -0,0 +1,73 @@
+import { expect } from "chai";
+import { parseCliOutput } from "../cli-output-parser.js";
+
+describe("cli-output-parser", () => {
+  describe("parseCliOutput", () => {
+    it("extracts structured_output from root dict", () => {
+      const input = JSON.stringify({
+        structured_output: { verdict: "pass", summary: "ok" },
+      });
+      const result = parseCliOutput(input);
+      expect(result).to.deep.equal({ verdict: "pass", summary: "ok" });
+    });
+
+    it("extracts StructuredOutput from assistant message", () => {
+      const input = JSON.stringify({
+        type: "assistant",
+        message: {
+          content: [
+            { name: "StructuredOutput", input: { verdict: "warn", summary: "issues found" } },
+          ],
+        },
+      });
+      const result = parseCliOutput(input);
+      expect(result).to.deep.equal({ verdict: "warn", summary: "issues found" });
+    });
+
+    it("extracts StructuredOutput from event list", () => {
+      const input = JSON.stringify([
+        { type: "system" },
+        {
+          type: "assistant",
+          message: {
+            content: [
+              { name: "StructuredOutput", input: { verdict: "fail" } },
+            ],
+          },
+        },
+      ]);
+      const result = parseCliOutput(input);
+      expect(result).to.deep.equal({ verdict: "fail" });
+    });
+
+    it("falls back to heuristic for non-JSON input", () => {
+      const result = parseCliOutput('Some text {"verdict": "pass"} more text');
+      expect(result).to.deep.equal({ verdict: "pass" });
+    });
+
+    it("returns null for empty string", () => {
+      expect(parseCliOutput("")).to.be.null;
+    });
+
+    it("returns null for plain text without JSON", () => {
+      expect(parseCliOutput("just plain text")).to.be.null;
+    });
+
+    it("handles assistant message without StructuredOutput tool", () => {
+      const input = JSON.stringify({
+        type: "assistant",
+        message: {
+          content: [{ name: "SomeOtherTool", input: {} }],
+        },
+      });
+      // Falls through to heuristic, which will find the JSON object
+      const result = parseCliOutput(input);
+      expect(result).to.not.be.null;
+    });
+
+    it("handles empty event list", () => {
+      const result = parseCliOutput("[]");
+      expect(result).to.be.null;
+    });
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/config.test.ts

@@ -0,0 +1,64 @@
+import { expect } from "chai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadConfig, getDisplaySettings } from "../config.js";
+import { DEFAULT_DISPLAY } from "../types.js";
+import { createTempDir, cleanupTempDir } from "./helpers.js";
+
+describe("config", () => {
+  let tmpDir: string;
+
+  beforeEach(() => { tmpDir = createTempDir("config-test-"); });
+  afterEach(() => cleanupTempDir(tmpDir));
+
+  describe("loadConfig", () => {
+    it("returns empty object when config file missing", () => {
+      const result = loadConfig(tmpDir);
+      expect(result).to.deep.equal({});
+    });
+
+    it("loads valid config file", () => {
+      const configDir = path.join(tmpDir, "_cc-native");
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(configDir, "cc-native.config.json"),
+        JSON.stringify({ orchestrator: { enabled: true, model: "haiku" } }),
+      );
+      const result = loadConfig(tmpDir);
+      expect(result).to.have.property("orchestrator");
+    });
+
+    it("returns empty object for malformed JSON", () => {
+      const configDir = path.join(tmpDir, "_cc-native");
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(configDir, "cc-native.config.json"),
+        "not json{{{",
+      );
+      const result = loadConfig(tmpDir);
+      expect(result).to.deep.equal({});
+    });
+  });
+
+  describe("getDisplaySettings", () => {
+    it("returns defaults when no config", () => {
+      const result = getDisplaySettings({}, "agents");
+      expect(result).to.deep.equal(DEFAULT_DISPLAY);
+    });
+
+    it("merges root display overrides", () => {
+      const result = getDisplaySettings({ display: { maxIssues: 5 } }, "agents");
+      expect(result.maxIssues).to.equal(5);
+      expect(result.maxQuestions).to.equal(DEFAULT_DISPLAY.maxQuestions);
+    });
+
+    it("section-specific overrides take priority over root", () => {
+      const config = {
+        display: { maxIssues: 10 },
+        agents: { display: { maxIssues: 3 } },
+      };
+      const result = getDisplaySettings(config as any, "agents");
+      expect(result.maxIssues).to.equal(3);
+    });
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/constants.test.ts

@@ -0,0 +1,40 @@
+import { expect } from "chai";
+import * as path from "node:path";
+import * as os from "node:os";
+import { validatePlanPath, PLANS_DIR, MAX_PLAN_PATH_LENGTH } from "../constants.js";
+
+describe("constants", () => {
+  describe("validatePlanPath", () => {
+    it("accepts valid plan path within PLANS_DIR", () => {
+      const validPath = path.join(PLANS_DIR, "my-plan.md");
+      const result = validatePlanPath(validPath);
+      expect(result).to.equal(path.resolve(validPath));
+    });
+
+    it("throws on empty path", () => {
+      expect(() => validatePlanPath("")).to.throw(/Invalid plan path length/);
+    });
+
+    it("throws on path exceeding max length", () => {
+      const longPath = path.join(PLANS_DIR, "a".repeat(MAX_PLAN_PATH_LENGTH));
+      expect(() => validatePlanPath(longPath)).to.throw(/Invalid plan path length/);
+    });
+
+    it("throws on null byte injection", () => {
+      expect(() => validatePlanPath(PLANS_DIR + "/test\x00.md")).to.throw(/Null bytes/);
+    });
+
+    it("throws on path outside PLANS_DIR", () => {
+      const outsidePath = path.join(os.tmpdir(), "evil-plan.md");
+      expect(() => validatePlanPath(outsidePath)).to.throw(/Path outside allowed directory/);
+    });
+
+    it("resolves to absolute path", () => {
+      // This test depends on CWD being inside PLANS_DIR, which typically won't be
+      // So we test with an absolute path
+      const absPath = path.join(PLANS_DIR, "test-plan.md");
+      const result = validatePlanPath(absPath);
+      expect(path.isAbsolute(result)).to.be.true;
+    });
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/debug.test.ts

@@ -0,0 +1,42 @@
+import { expect } from "chai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getDebugDir, cleanupDebugFolder } from "../debug.js";
+import { createTempDir, cleanupTempDir } from "./helpers.js";
+
+describe("debug", () => {
+  let tmpDir: string;
+
+  beforeEach(() => { tmpDir = createTempDir("debug-test-"); });
+  afterEach(() => cleanupTempDir(tmpDir));
+
+  describe("getDebugDir", () => {
+    it("creates debug directory under context path", () => {
+      const result = getDebugDir(tmpDir);
+      expect(result).to.equal(path.join(tmpDir, "debug"));
+      expect(fs.existsSync(result)).to.be.true;
+    });
+
+    it("returns same path on subsequent calls", () => {
+      const first = getDebugDir(tmpDir);
+      const second = getDebugDir(tmpDir);
+      expect(first).to.equal(second);
+    });
+  });
+
+  describe("cleanupDebugFolder", () => {
+    it("removes existing debug directory", () => {
+      const debugDir = path.join(tmpDir, "debug");
+      fs.mkdirSync(debugDir, { recursive: true });
+      fs.writeFileSync(path.join(debugDir, "test.log"), "data");
+
+      cleanupDebugFolder(tmpDir);
+      expect(fs.existsSync(debugDir)).to.be.false;
+    });
+
+    it("does nothing when debug directory does not exist", () => {
+      // Should not throw
+      cleanupDebugFolder(tmpDir);
+    });
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/exports.test.ts

@@ -0,0 +1,58 @@
+import { expect } from "chai";
+
+describe("exports", () => {
+  it("all public functions are importable from index", async () => {
+    const mod = await import("../index.js");
+
+    // Verdict
+    expect(mod.worstVerdict).to.be.a("function");
+    expect(mod.computeReviewDecision).to.be.a("function");
+
+    // JSON parsing
+    expect(mod.parseJsonMaybe).to.be.a("function");
+    expect(mod.coerceToReview).to.be.a("function");
+
+    // CLI parsing
+    expect(mod.parseCliOutput).to.be.a("function");
+
+    // Config
+    expect(mod.loadConfig).to.be.a("function");
+    expect(mod.getDisplaySettings).to.be.a("function");
+
+    // Constants
+    expect(mod.validatePlanPath).to.be.a("function");
+    expect(mod.PLANS_DIR).to.be.a("string");
+
+    // State
+    expect(mod.getStateFilePath).to.be.a("function");
+    expect(mod.loadState).to.be.a("function");
+    expect(mod.getIterationState).to.be.a("function");
+    expect(mod.shouldContinueIterating).to.be.a("function");
+
+    // CC-native state
+    expect(mod.getCcNativeState).to.be.a("function");
+    expect(mod.isPlanAlreadyReviewed).to.be.a("function");
+    expect(mod.markPlanReviewed).to.be.a("function");
+
+    // Orchestrator
+    expect(mod.buildOrchestratorSchema).to.be.a("function");
+    expect(mod.runOrchestrator).to.be.a("function");
+
+    // Aggregate agents
+    expect(mod.aggregateAgents).to.be.a("function");
+    expect(mod.extractFrontmatter).to.be.a("function");
+
+    // Artifacts
+    expect(mod.formatReviewMarkdown).to.be.a("function");
+    expect(mod.buildCombinedJson).to.be.a("function");
+    expect(mod.buildInlineReviewSummary).to.be.a("function");
+
+    // Reviewers
+    expect(mod.AgentReviewer).to.be.a("function");
+
+    // Schemas
+    expect(mod.REVIEW_SCHEMA).to.be.an("object");
+    expect(mod.ORCHESTRATOR_SCHEMA).to.be.an("object");
+    expect(mod.DEFAULT_DISPLAY).to.be.an("object");
+  });
+});