| undefined;

return entries?.find((entry) => entry.pluginId === "active-memory")?.lines ?? [];

};

const expectLinesToContain = (lines: string[], text: string) => {

expect(lines).toEqual(expect.arrayContaining([expect.stringContaining(text)]));

};

const expectLinesNotToContain = (lines: string[], text: string) => {

expect(lines).not.toEqual(expect.arrayContaining([expect.stringContaining(text)]));

};

const writeTranscriptJsonl = async (sessionFile: string, records: unknown[], suffix = "\n") => {

await fs.mkdir(path.dirname(sessionFile), { recursive: true });

await fs.writeFile(

expect(result).toBeUndefined();

const lines = getActiveMemoryLines(sessionKey);

expect(lines).toEqual([expect.stringContaining("🧩 Active Memory: status=timeout")]);

expect(lines.some((line) => line.includes("timeout_partial"))).toBe(false);

expectLinesNotToContain(lines, "timeout_partial");

});

it("keeps timeout status when the timeout transcript path does not exist", async () => {

expect(result).toBeUndefined();

const lines = getActiveMemoryLines(sessionKey);

expect(lines).toEqual([expect.stringContaining("🧩 Active Memory: status=timeout")]);

expect(lines.some((line) => line.includes("timeout_partial"))).toBe(false);

expectLinesNotToContain(lines, "timeout_partial");

});

it("does not inject embedded timeout boilerplate from partial transcripts", async () => {

expect(result).toBeUndefined();

const lines = getActiveMemoryLines(sessionKey);

expect(lines).toEqual([expect.stringContaining("🧩 Active Memory: status=timeout")]);

expect(lines.some((line) => line.includes("timeout_partial"))).toBe(false);

expect(lines.some((line) => line.includes("LLM request timed out"))).toBe(false);

expectLinesNotToContain(lines, "timeout_partial");

expectLinesNotToContain(lines, "LLM request timed out");

});

it("returns partial transcript text when an aborted subagent rejects before the race timeout wins", async () => {

const infoLines = vi

.mocked(api.logger.info)

.mock.calls.map((call: unknown[]) => String(call[0]));

expect(infoLines.some((line: string) => line.includes(" cached "))).toBe(false);

expectLinesNotToContain(infoLines, " cached ");

});

it("does not share cached recall results across session-id-only contexts", async () => {

const infoLines = vi

.mocked(api.logger.info)

.mock.calls.map((call: unknown[]) => String(call[0]));

expect(infoLines.some((line: string) => line.includes(" cached "))).toBe(false);

expectLinesNotToContain(infoLines, " cached ");

});

it("ignores late subagent payloads once the active-memory timeout signal has fired", async () => {

const infoLines = vi

.mocked(api.logger.info)

.mock.calls.map((call: unknown[]) => String(call[0]));

expect(infoLines.some((line: string) => line.includes("status=timeout"))).toBe(true);

expectLinesToContain(infoLines, "status=timeout");

expect(

infoLines.some(

(line: string) =>

const infoLines = vi

.mocked(api.logger.info)

.mock.calls.map((call: unknown[]) => String(call[0]));

expect(infoLines.some((line: string) => line.includes("status=timeout"))).toBe(false);

expectLinesNotToContain(infoLines, "status=timeout");

});

it("returns timeout within a hard deadline even when the subagent never checks the abort signal", async () => {

const infoLines = vi

.mocked(api.logger.info)

.mock.calls.map((call: unknown[]) => String(call[0]));

expect(infoLines.some((line: string) => line.includes("status=timeout"))).toBe(true);

expectLinesToContain(infoLines, "status=timeout");

// Hard deadline: wall-clock time must be near timeoutMs, not 30s.

expect(wallClockMs).toBeLessThan(CONFIGURED_TIMEOUT_MS + HARD_DEADLINE_MARGIN_MS);

});

const infoLines = vi

.mocked(api.logger.info)

.mock.calls.map((call: unknown[]) => String(call[0]));

expect(infoLines.some((line: string) => line.includes("done status=empty"))).toBe(true);

expect(infoLines.some((line: string) => line.includes("done status=timeout"))).toBe(false);

expectLinesToContain(infoLines, "done status=empty");

expectLinesNotToContain(infoLines, "done status=timeout");

expect(getActiveMemoryLines(sessionKey)).toEqual([

expect.stringContaining("🧩 Active Memory: status=empty"),

expect.stringContaining("🔎 Active Memory Debug: backend=qmd searchMs=8 hits=0"),

const infoLines = vi

.mocked(api.logger.info)

.mock.calls.map((call: unknown[]) => String(call[0]));

expect(infoLines.some((line: string) => line.includes("done status=empty"))).toBe(true);

expect(infoLines.some((line: string) => line.includes("done status=timeout"))).toBe(false);

expectLinesToContain(infoLines, "done status=empty");

expectLinesNotToContain(infoLines, "done status=timeout");

expect(getActiveMemoryLines(sessionKey)).toEqual([

expect.stringContaining("🧩 Active Memory: status=empty"),

expect.stringContaining(

const warnLines = vi

.mocked(api.logger.warn)

.mock.calls.map((call: unknown[]) => String(call[0]));

expect(warnLines.some((line: string) => line.includes("before_prompt_build"))).toBe(true);

expectLinesToContain(warnLines, "before_prompt_build");

});

it("honors configured timeoutMs values above the former 60 000 ms ceiling", async () => {

const lines =

(store[sessionKey]?.pluginDebugEntries as Array<{ lines?: string[] }> | undefined)?.[0]

?.lines ?? [];

expect(lines.some((line) => line.includes("\u001b"))).toBe(false);

expect(lines.some((line) => line.includes("\r"))).toBe(false);

expectLinesNotToContain(lines, "\u001b");

expectLinesNotToContain(lines, "\r");

});

it("caps the active-memory cache size and evicts the oldest entries", () => {

const infoLines = vi

.mocked(api.logger.info)

.mock.calls.map((call: unknown[]) => String(call[0]));

expect(infoLines.some((line: string) => line.includes("circuit breaker open"))).toBe(true);

expectLinesToContain(infoLines, "circuit breaker open");

});

it("resets circuit breaker after a successful recall", async () => {