test: close enterprise hardening coverage gaps

Author: Aitomates

universal-refiner/src/core/server.ts

@@ -37,6 +37,7 @@ import { parseStructuredResponse } from "./structured-response.js";
 import { RepositoryIdentity } from "../history/repository-identity.js";
 import { ApprovedTemplateSelector } from "../refiners/template-selector.js";
 import { createABEvaluationRecord, evaluatePrompt } from "../evaluation/prompt-evaluator.js";
+import { randomUUID } from "node:crypto";
 
 export class PromptRefinerServer {
   private server: Server;
@@ -458,7 +459,7 @@ Output ONLY the JSON array. If no gaps, return [].`,
             AgenticBlackboard.postIntent(agentName, "lint", prompt, this.rootPath);
             CommandCenterDashboard.log(`Scouting project for prompt: "${prompt.substring(0, 30)}..."`);
 
-            const promptId = `prm_${Date.now()}`;
+            const promptId = `prm_${randomUUID()}`;
             this.eventStore.recordPrompt({
               id: promptId,
               client: "MCP",
@@ -492,7 +493,7 @@ Output ONLY the JSON array. If no gaps, return [].`,
             AgenticBlackboard.postIntent(agentName, "finalize", original_prompt, this.rootPath);
 
             const ctx = await this.scoutProject(original_prompt);
-            const promptId = `ref_${Date.now()}`;
+            const promptId = `ref_${randomUUID()}`;
             const approvedTemplates = await this.templateSelector.select({
               repoId: this.repository.id,
               prompt: original_prompt,
@@ -664,7 +665,7 @@ Output ONLY the JSON array. If no gaps, return [].`,
             const now = new Date().toISOString();
 
             if (!execution) {
-              const execId = `exec_${Date.now()}`;
+              const execId = `exec_${randomUUID()}`;
               this.eventStore.recordExecution({
                 id: execId,
                 prompt_id: prompt_id,
@@ -711,7 +712,7 @@ Output ONLY the JSON array. If no gaps, return [].`,
               outcome_b: outcomeSchema.optional(),
             }).parse(request.params.arguments);
             const experiment = createABEvaluationRecord({
-              experimentId: `exp_${Date.now()}`,
+              experimentId: `exp_${randomUUID()}`,
               baselinePrompt: baseline_prompt,
               variantA: { id: "A", prompt: variant_a, observedOutcome: outcome_a },
               variantB: { id: "B", prompt: variant_b, observedOutcome: outcome_b },

universal-refiner/tests/acceptance/mcp-tools.acceptance.test.ts

@@ -84,6 +84,23 @@ describe("MCP all-tool acceptance", () => {
     });
   });
 
+  it("generates collision-resistant prompt IDs for concurrent lint calls", async () => {
+    handlers.length = 0;
+    new PromptRefinerServer(directory);
+    const dispatch = handlers[1] as (request: unknown) => Promise<{ content: Array<{ type: string; text: string }> }>;
+
+    const [first, second] = await Promise.all([
+      dispatch({ params: { name: "lint_prompt", arguments: { prompt: "Implement A", semantic: false } } }),
+      dispatch({ params: { name: "lint_prompt", arguments: { prompt: "Implement B", semantic: false } } }),
+    ]);
+    const firstBody = JSON.parse(first.content[0].text) as { promptId: string };
+    const secondBody = JSON.parse(second.content[0].text) as { promptId: string };
+
+    expect(firstBody.promptId).toMatch(/^prm_[0-9a-f-]{36}$/u);
+    expect(secondBody.promptId).toMatch(/^prm_[0-9a-f-]{36}$/u);
+    expect(firstBody.promptId).not.toBe(secondBody.promptId);
+  });
+
   it("executes every advertised dispatcher path with valid arguments", async () => {
     handlers.length = 0;
     const server = new PromptRefinerServer(directory);

universal-refiner/tests/autopilot-dashboard.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
@@ -68,4 +68,17 @@ describe("/api/autopilot dashboard route (AUTO-05, AUTO-06)", () => {
     const body = await res.json() as { lastCycleAt: string | null };
     expect(body.lastCycleAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
   });
+
+  it("returns a sanitized autopilot route failure", async () => {
+    vi.spyOn(AutoPilotStatus, "getSnapshot").mockImplementationOnce(() => {
+      throw new Error("autopilot secret");
+    });
+    const app = CommandCenterDashboard.createApp(testDir);
+
+    const res = await app.request("/api/autopilot");
+    const body = await res.json() as { error: string };
+
+    expect(res.status).toBe(500);
+    expect(body.error).toBe("Auto-pilot status unavailable");
+  });
 });

universal-refiner/tests/background-service.test.ts

@@ -32,6 +32,7 @@ vi.mock("../src/history/git-poller.js", () => ({
 }));
 
 import { BackgroundAutonomyService } from "../src/core/background-service.js";
+import { AutoPilotStatus } from "../src/core/autopilot-status.js";
 
 describe("BackgroundAutonomyService", () => {
   beforeEach(() => {
@@ -41,6 +42,7 @@ describe("BackgroundAutonomyService", () => {
     mocks.ingest.mockResolvedValue(2);
     mocks.correlate.mockResolvedValue(undefined);
     mocks.extract.mockResolvedValue(undefined);
+    AutoPilotStatus.reset();
   });
 
   it("starts once, runs the initial serialized cycle, and stops the watcher", async () => {
@@ -66,6 +68,31 @@ describe("BackgroundAutonomyService", () => {
     expect(mocks.error).toHaveBeenCalledWith("Background autonomy watcher failed", expect.any(Error));
   });
 
+  it("completes a cycle when no commits or lessons are discovered", async () => {
+    mocks.ingest.mockResolvedValue(0);
+    const service = new BackgroundAutonomyService("C:/repo", vi.fn());
+
+    service.start();
+    await service.idle();
+    service.stop();
+
+    expect(mocks.dashboard).toHaveBeenCalledWith("Background Autonomy: Ingested 0 commits.");
+    expect(AutoPilotStatus.getSnapshot().stats.commitsIngested).toBe(0);
+  });
+
+  it("records extracted lesson activity when extraction increments the counter", async () => {
+    mocks.extract.mockImplementation(async () => {
+      AutoPilotStatus.addLessons(2);
+    });
+    const service = new BackgroundAutonomyService("C:/repo", vi.fn());
+
+    service.start();
+    await service.idle();
+    service.stop();
+
+    expect(AutoPilotStatus.getSnapshot().activity.some(activity => activity.kind === "lesson")).toBe(true);
+  });
+
   it("debounces file changes and logs cycle failures for queue retries", async () => {
     vi.useFakeTimers();
     mocks.correlate.mockRejectedValue(new Error("correlation failed"));
@@ -83,6 +110,17 @@ describe("BackgroundAutonomyService", () => {
     expect(mocks.error).toHaveBeenCalledWith("Background Autonomy cycle failed", expect.any(Error));
   });
 
+  it("records non-Error cycle failures", async () => {
+    mocks.correlate.mockRejectedValue("correlation failed");
+    const service = new BackgroundAutonomyService("C:/repo", vi.fn());
+
+    service.start();
+    await service.idle();
+    service.stop();
+
+    expect(AutoPilotStatus.getSnapshot().activity.some(activity => activity.message === "Cycle failed: correlation failed")).toBe(true);
+  });
+
   it("starts and stops git polling and reacts to discovered commits", async () => {
     vi.useFakeTimers();
     const service = new BackgroundAutonomyService("C:/repo", vi.fn(), 25);

universal-refiner/tests/dashboard-events.test.ts

@@ -199,9 +199,7 @@ describe("dashboard event stream and render failures", () => {
 
     const response = await app.request("/api/events");
 
-      expect(response.status).toBe(500);
-      expect(html).toContain("See sanitized runtime logs");
-      expect(html).not.toContain("Could not find dashboard.html");
+    expect(response.status).toBe(500);
     expect(await response.text()).toBe("Dashboard event stream unavailable");
   });
 
@@ -225,6 +223,7 @@ describe("dashboard event stream and render failures", () => {
 
     expect(response.status).toBe(500);
     expect(html).toContain("Dashboard Error");
-    expect(html).toContain("Could not find dashboard.html");
+    expect(html).toContain("See sanitized runtime logs");
+    expect(html).not.toContain("Could not find dashboard.html");
   });
 });

universal-refiner/tests/dashboard-start.test.ts

@@ -46,4 +46,11 @@ describe("dashboard server startup", () => {
     await CommandCenterDashboard.stop();
     expect(mocks.close).toHaveBeenCalledOnce();
   });
+
+  it("rejects when closing the active dashboard server fails", async () => {
+    mocks.close.mockImplementationOnce((callback?: (error?: Error) => void) => callback?.(new Error("close failed")));
+    CommandCenterDashboard.start(3999, ".");
+
+    await expect(CommandCenterDashboard.stop()).rejects.toThrow("close failed");
+  });
 });

universal-refiner/tests/index.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 const mocks = vi.hoisted(() => ({
   dashboardStart: vi.fn(),
@@ -45,7 +45,14 @@ vi.mock("../src/history/event-store.js", () => ({
 }));
 
 describe("runtime bootstrap", () => {
+  let sigintListeners: NodeJS.SignalsListener[];
+  let sigtermListeners: NodeJS.SignalsListener[];
+  let stdinEndListeners: Array<(...args: unknown[]) => void>;
+
   beforeEach(() => {
+    sigintListeners = process.listeners("SIGINT") as NodeJS.SignalsListener[];
+    sigtermListeners = process.listeners("SIGTERM") as NodeJS.SignalsListener[];
+    stdinEndListeners = process.stdin.listeners("end") as Array<(...args: unknown[]) => void>;
     vi.resetModules();
     vi.clearAllMocks();
     mocks.serverRun.mockResolvedValue(undefined);
@@ -57,13 +64,29 @@ describe("runtime bootstrap", () => {
     delete process.env.PROMPT_REFINER_BACKGROUND;
   });
 
+  afterEach(() => {
+    process.removeAllListeners("SIGINT");
+    process.removeAllListeners("SIGTERM");
+    process.stdin.removeAllListeners("end");
+    for (const listener of sigintListeners) process.on("SIGINT", listener);
+    for (const listener of sigtermListeners) process.on("SIGTERM", listener);
+    for (const listener of stdinEndListeners) process.stdin.on("end", listener);
+    vi.restoreAllMocks();
+  });
+
   it("starts a lightweight MCP server without competing background services", async () => {
     await import("../src/index.js");
 
     expect(mocks.dashboardStart).not.toHaveBeenCalled();
     expect(mocks.serverConstructor).toHaveBeenCalledWith(process.cwd());
     expect(mocks.watcherConstructor).not.toHaveBeenCalled();
     expect(mocks.serverRun).toHaveBeenCalledWith({ background: false });
+
+    const stdinHandler = process.stdin.listeners("end").at(-1) as () => void;
+    stdinHandler();
+    stdinHandler();
+    await vi.waitFor(() => expect(mocks.serverStop).toHaveBeenCalledOnce());
+    expect(mocks.flush).toHaveBeenCalledOnce();
   });
 
   it("starts background ownership explicitly and exits on fatal server failure", async () => {
@@ -79,7 +102,33 @@ describe("runtime bootstrap", () => {
 
     expect(mocks.dashboardStart).toHaveBeenCalledWith(4321, process.cwd());
     expect(mocks.watcherStart).toHaveBeenCalledOnce();
+    const changeHandler = mocks.watcherOn.mock.calls.find(call => call[0] === "change")?.[1];
+    changeHandler({ event: "change", path: `${process.cwd()}\\src\\a.ts` });
+    expect(mocks.loggerInfo).toHaveBeenCalledWith(expect.stringContaining("[FS] change"));
+    expect(mocks.dashboardLog).toHaveBeenCalledWith(expect.stringContaining("[FS] change"));
     expect(consoleError).toHaveBeenCalledWith("[FATAL ERROR]", error);
     expect(mocks.serverStop).toHaveBeenCalledOnce();
   });
+
+  it("ignores stdin end while background ownership is active", async () => {
+    process.env.PROMPT_REFINER_BACKGROUND = "true";
+    await import("../src/index.js");
+
+    const stdinHandler = process.stdin.listeners("end").at(-1) as () => void;
+    stdinHandler();
+
+    await new Promise(resolve => setTimeout(resolve, 0));
+    expect(mocks.serverStop).not.toHaveBeenCalled();
+  });
+
+  it("shuts down on process signals", async () => {
+    const exit = vi.spyOn(process, "exit").mockImplementation((() => undefined) as never);
+
+    await import("../src/index.js");
+    const signalHandler = process.listeners("SIGTERM").at(-1) as () => void;
+    signalHandler();
+
+    await vi.waitFor(() => expect(exit).toHaveBeenCalledWith(0));
+    expect(mocks.serverStop).toHaveBeenCalledOnce();
+  });
 });

universal-refiner/tests/logger.test.ts

@@ -5,6 +5,7 @@ import * as path from "path";
 import { RuntimeLogger } from "../src/core/logger.js";
 import { REDACTED, containsSensitiveContent, isSensitiveFilename, redact, redactString } from "../src/core/redaction.js";
 
+// secret-scan: allow-fixture
 describe("redaction", () => {
   it("redacts free-form assignments, authorization values, and URL secrets", () => {
     const value = redactString("password=hunter2 Bearer abc.def https://user:pass@example.com/a?token=abc&safe=yes");

universal-refiner/tests/mcp-client.test.ts

@@ -129,7 +129,10 @@ describe("hook MCP client", () => {
 
     expect(resolveServerPath()).toMatch(/src[\\/]index\.js$/);
     await callMcpTool("lint_prompt", {});
-    expect(mocks.request.mock.calls[0][2]).toEqual({ timeout: 15_000, maxTotalTimeout: 15_000 });
+    const options = mocks.request.mock.calls[0][2] as { timeout: number; maxTotalTimeout: number };
+    expect(options.timeout).toBeGreaterThan(0);
+    expect(options.timeout).toBeLessThanOrEqual(15_000);
+    expect(options.maxTotalTimeout).toBe(options.timeout);
   });
 
   it("selects an existing built candidate, rejects invalid timeouts, and tolerates close failures", async () => {
@@ -140,6 +143,9 @@ describe("hook MCP client", () => {
 
     expect(resolveServerPath()).toMatch(/dist[\\/]src[\\/]index\.js$/);
     await expect(callMcpTool("lint_prompt", {})).resolves.toBe("ok");
-    expect(mocks.request.mock.calls[0][2]).toEqual({ timeout: 15_000, maxTotalTimeout: 15_000 });
+    const options = mocks.request.mock.calls[0][2] as { timeout: number; maxTotalTimeout: number };
+    expect(options.timeout).toBeGreaterThan(0);
+    expect(options.timeout).toBeLessThanOrEqual(15_000);
+    expect(options.maxTotalTimeout).toBe(options.timeout);
   });
 });

universal-refiner/tests/register-global.test.ts

@@ -76,7 +76,7 @@ describe("global registration doctor", () => {
     const second = run(root, "-Apply");
     expect(second.status, second.stderr || second.stdout).toBe(0);
     expect(readdirSync(root, { recursive: true }).filter((name) => name.includes("promptimprover-backup"))).toHaveLength(backupCount);
-  });
+  }, 30_000);
 
   it("reports drift, mojibake, and credential field paths without printing values", () => {
     const root = makeRoot();