import {

applyShortTermPromotions,

auditShortTermPromotionArtifacts,

filterLiveShortTermRecallEntries,

isShortTermMemoryPath,

loadShortTermPromotionDreamingStats,

recordGroundedShortTermCandidates,

});

});

it("deduplicates source-file checks within a recall batch", async () => {

await withTempWorkspace(async (workspaceDir) => {

const notePath = await writeDailyMemoryNote(workspaceDir, "2026-04-03", [

"Deduplicated source check note.",

]);

const relativePath = path.relative(workspaceDir, notePath).replaceAll("\\", "/");

const entry = {

key: "duplicate-source",

path: relativePath,

startLine: 1,

endLine: 1,

source: "memory" as const,

snippet: "Deduplicated source check note.",

recallCount: 1,

dailyCount: 1,

groundedCount: 0,

totalScore: 0.9,

maxScore: 0.9,

firstRecalledAt: "2026-04-03T00:00:00.000Z",

lastRecalledAt: "2026-04-03T00:00:00.000Z",

queryHashes: ["query"],

recallDays: ["2026-04-03"],

conceptTags: [],

};

const statSpy = vi.spyOn(fs, "stat");

const live = await filterLiveShortTermRecallEntries({

workspaceDir,

entries: [entry, { ...entry, key: "duplicate-source-2" }],

});

expect(live).toHaveLength(2);

expect(statSpy).toHaveBeenCalledTimes(1);

});

});

it("falls back when the injected recall timestamp is outside Date range", async () => {

vi.spyOn(Date, "now").mockReturnValue(Date.UTC(2026, 4, 30, 12, 0, 0));

await withTempWorkspace(async (workspaceDir) => {

};

}

async function shortTermRecallSourceExists(params: {

workspaceDir: string;

entry: Pick<ShortTermRecallEntry, "path">;

}): Promise<boolean> {

const workspaceDir = params.workspaceDir.trim();

if (!workspaceDir) {

return false;

}

for (const sourcePath of resolveShortTermSourcePathCandidates(workspaceDir, params.entry.path)) {

try {

const stat = await fs.stat(sourcePath);

if (stat.isFile()) {

return true;

}

} catch (err) {

if ((err as NodeJS.ErrnoException).code === "ENOENT") {

continue;

}

throw err;

async function shortTermRecallSourceIsFile(sourcePath: string): Promise<boolean> {

try {

const stat = await fs.stat(sourcePath);

return stat.isFile();

} catch (err) {

if ((err as NodeJS.ErrnoException).code === "ENOENT") {

return false;

}

throw err;

}

return false;

}

export async function filterLiveShortTermRecallEntries(params: {

workspaceDir: string;

entries: ShortTermRecallEntry[];

}): Promise<ShortTermRecallEntry[]> {

const workspaceDir = params.workspaceDir.trim();

if (!workspaceDir) {

return [];

}

const sourceFileChecks = new Map<string, Promise<boolean>>();

const checkSourceFile = (sourcePath: string): Promise<boolean> => {

const existing = sourceFileChecks.get(sourcePath);

if (existing) {

return existing;

}

const check = shortTermRecallSourceIsFile(sourcePath);

sourceFileChecks.set(sourcePath, check);

return check;

};

const results = await Promise.all(

params.entries.map(async (entry) => ({

entry,

exists: await shortTermRecallSourceExists({ workspaceDir: params.workspaceDir, entry }),

})),

params.entries.map(async (entry) => {

let exists = false;

for (const sourcePath of resolveShortTermSourcePathCandidates(workspaceDir, entry.path)) {

if (await checkSourceFile(sourcePath)) {

exists = true;

break;

}

}

return { entry, exists };

}),

);

return results.filter((result) => result.exists).map((result) => result.entry);

}

expect(chunks.map((chunk) => chunk.source.text)).toEqual(["A", "😀"]);

});

it("keeps split order while processing the worklist as a stack", () => {

const text = "abcdefghijklmnopqrstuvwx";

const chunks = renderMarkdownIRChunksWithinLimit({

ir: markdownToIR(text),

limit: 5,

renderChunk: (chunk) => chunk.text,

measureRendered: (rendered) => rendered.length,

});

expect(chunks.map((chunk) => chunk.source.text).join("")).toBe(text);

expect(chunks.every((chunk) => chunk.rendered.length <= 5)).toBe(true);

});

it("treats Infinity as no size cap and returns a single chunk", () => {

const text = "one two three four five six seven eight nine ten";

const ir = markdownToIR(text);

}

const normalizedLimit = resolveIntegerOption(options.limit, 1, { min: 1 });

const pending = chunkMarkdownIR(options.ir, normalizedLimit);

// Treat the pending worklist as a stack so each dequeue/enqueue stays O(1).

// The initial reverse keeps the final order stable while avoiding shift/unshift

// moving every remaining chunk for long messages.

const pending = chunkMarkdownIR(options.ir, normalizedLimit).toReversed();

const finalized: MarkdownIR[] = [];

while (pending.length > 0) {

const chunk = pending.shift();

const chunk = pending.pop();

if (!chunk) {

continue;

}

finalized.push(chunk);

continue;

}

pending.unshift(...split);

for (let index = split.length - 1; index >= 0; index -= 1) {

const next = split[index];

if (next) {

pending.push(next);

}

}

}

return coalesceWhitespaceOnlyMarkdownIRChunks(finalized, normalizedLimit, options).map(

const toolCallBlocksByIndex = new Map<number, ToolCallBlock>();

const toolCallBlocksById = new Map<string, ToolCallBlock>();

const toolCallBlockBytes = new WeakMap<ToolCallBlock, number>();

const toolCallBlockIndices = new WeakMap<ToolCallBlock, number>();

let sawStopFinishReason = false;

const blockIndex = () => output.content.length - 1;

const measureUtf8Bytes = (text: string) => Buffer.byteLength(text, "utf8");

};

currentBlock = block;

output.content.push(block);

toolCallBlockIndices.set(block, output.content.length - 1);

pushStreamEvent({

type: "toolcall_start",

contentIndex: output.content.indexOf(block),

contentIndex: toolCallBlockIndices.get(block) ?? -1,

partial: output,

});

pushStreamEvent({

type: "toolcall_delta",

contentIndex: output.content.indexOf(block),

contentIndex: toolCallBlockIndices.get(block) ?? -1,

delta: toolCall.partialArgs,

partial: output,

});

...(initialSig ? { thoughtSignature: initialSig } : {}),

};

output.content.push(block);

toolCallBlockIndices.set(block, output.content.length - 1);

pushStreamEvent({

type: "toolcall_start",

contentIndex: output.content.indexOf(block),

contentIndex: toolCallBlockIndices.get(block) ?? -1,

partial: output,

});

}

block.arguments = parseStreamingJson(block.partialArgs);

pushStreamEvent({

type: "toolcall_delta",

contentIndex: output.content.indexOf(block),

contentIndex: toolCallBlockIndices.get(block) ?? -1,

delta: toolCall.function.arguments,

partial: output,

});

return { appendMode: "active" };

}

async function readTranscriptLeafInfo(transcriptPath: string): Promise<TranscriptLeafInfo> {

async function readTranscriptLeafInfoForward(transcriptPath: string): Promise<TranscriptLeafInfo> {

let leafId: string | undefined;

let hasParentLinkedEntries = false;

let nonSessionEntryCount = 0;

};

}

async function readTranscriptLeafInfo(transcriptPath: string): Promise<TranscriptLeafInfo> {

let latestEntryId: string | undefined;

for await (const line of streamSessionTranscriptLinesReverse(transcriptPath)) {

const lineInfo = readTranscriptLineInfo(line);

if (!lineInfo.entryId) {

continue;

}

if (lineInfo.invalidLeafControl) {

break;

}

if (lineInfo.leafControl) {

if (latestEntryId) {

const valid = await validateTranscriptLeafControlReferences({

transcriptPath,

leafControlId: lineInfo.entryId,

leafControl: lineInfo.leafControl,

});

if (!valid) {

break;

}

return {

leafId: latestEntryId,

appendMode: lineInfo.leafControl.appendMode === "side" ? "side" : "active",

hasParentLinkedEntries: true,

nonSessionEntryCount: 0,

};

}

const resolvedLeaf = await resolveTranscriptLeafIdFromTrailingControls(transcriptPath);

return {

...(resolvedLeaf.leafId ? { leafId: resolvedLeaf.leafId } : {}),

appendMode: resolvedLeaf.appendMode,

hasParentLinkedEntries: true,

nonSessionEntryCount: 0,

};

}

latestEntryId ??= lineInfo.entryId;

if (lineInfo.isCanonicalEntry && lineInfo.hasParentLinkedEntry) {

return {

leafId: latestEntryId,

appendMode: lineInfo.appendMode === "side" ? "side" : "active",

hasParentLinkedEntries: true,

nonSessionEntryCount: 0,

};

}

// A latest entry without parent linkage may be a legacy linear transcript.

// Fall back to the full scan only when migration detection needs it.

break;

}

return await readTranscriptLeafInfoForward(transcriptPath);

}

async function migrateLinearTranscriptToParentLinked(transcriptPath: string): Promise<{

leafId?: string;

}> {