readFileSpy.mockRestore();

});

it("defaults non-finite partial read line options before streaming canonical memory files", async () => {

const readFileSpy = vi.spyOn(fs, "readFile");

const relPath = path.join("memory", "non-finite-window.md");

await fs.mkdir(path.join(workspaceDir, "memory"), { recursive: true });

await fs.writeFile(

path.join(workspaceDir, relPath),

["line-1", "line-2", "line-3"].join("\n"),

"utf-8",

);

const { manager } = await createManager();

const result = await manager.readFile({

relPath,

from: Number.NaN,

lines: Number.POSITIVE_INFINITY,

});

expect(result).toEqual({

path: relPath,

text: "line-1\nline-2\nline-3",

from: 1,

lines: 3,

});

expect(readFileSpy).not.toHaveBeenCalled();

await manager.close();

readFileSpy.mockRestore();

});

it("returns a bounded default excerpt for qmd memory reads without explicit lines", async () => {

const relPath = path.join("memory", "default-window.md");

await fs.mkdir(path.join(workspaceDir, "memory"), { recursive: true });

daemonStart: Promise<void> | null;

};

function normalizePositiveInteger(value: number | undefined, fallback: number): number {

return typeof value === "number" && Number.isFinite(value)

? Math.max(1, Math.floor(value))

: fallback;

}

type QmdEmbedQueueState = {

tail: Promise<void>;

};

}

const contextLimits = this.contextLimits;

if (params.from !== undefined || params.lines !== undefined) {

const requestedCount = Math.max(

1,

const startLine = normalizePositiveInteger(params.from, 1);

const requestedCount = normalizePositiveInteger(

params.lines ?? contextLimits?.memoryGetDefaultLines ?? DEFAULT_MEMORY_READ_LINES,

DEFAULT_MEMORY_READ_LINES,

);

const partial = await this.readPartialText(absPath, params.from, requestedCount);

const partial = await this.readPartialText(absPath, startLine, requestedCount);

if (partial.missing) {

return { text: "", path: relPath };

}

return buildMemoryReadResultFromSlice({

selectedLines: partial.selectedLines,

relPath,

startLine: Math.max(1, params.from ?? 1),

startLine,

moreSourceLinesRemain: partial.moreSourceLinesRemain,

maxChars: contextLimits?.memoryGetMaxChars,

suggestReadFallback: isDefaultMemoryPath(relPath),

): Promise<

{ missing: true } | { missing: false; selectedLines: string[]; moreSourceLinesRemain: boolean }

> {

const start = Math.max(1, from ?? 1);

const count = Math.max(1, lines ?? Number.POSITIVE_INFINITY);

const start = normalizePositiveInteger(from, 1);

const count = normalizePositiveInteger(lines, Number.MAX_SAFE_INTEGER);

let handle;

try {

handle = await fs.open(absPath);