const MIN_PROMPT_BLOB_CHARS = 512;

const MAX_PROMPT_BLOB_BYTES = 512 * 1024;

const PROMPT_REF_CACHE_MAX_ENTRIES = 256;

const VALID_PROMPT_BLOB_CACHE_MAX_ENTRIES = 256;

type PersistedSessionStore = {

store: Record<string, SessionEntry>;

};

const promptRefCache = new Map<string, SessionSkillPromptRef>();

const validPromptBlobCache = new Map<string, { mtimeMs: number; size: number; prompt: string }>();

function hashPrompt(prompt: string): string {

return crypto.createHash(PROMPT_BLOB_ALGORITHM).update(prompt).digest("hex");

}

export function clearSessionSkillPromptRefCache(): void {

promptRefCache.clear();

validPromptBlobCache.clear();

}

export function getSessionSkillPromptRefCacheStatsForTest(): {

};

}

export function getValidSessionSkillPromptBlobCacheStatsForTest(): {

entries: number;

maxEntries: number;

} {

return {

entries: validPromptBlobCache.size,

maxEntries: VALID_PROMPT_BLOB_CACHE_MAX_ENTRIES,

};

}

function isSha256Hex(value: string): boolean {

return /^[a-f0-9]{64}$/u.test(value);

}

return prompt.length >= MIN_PROMPT_BLOB_CHARS && bytes <= MAX_PROMPT_BLOB_BYTES;

}

function rememberValidPromptBlob(blobPath: string, stat: fs.Stats, prompt: string): void {

validPromptBlobCache.set(blobPath, { mtimeMs: stat.mtimeMs, size: stat.size, prompt });

while (validPromptBlobCache.size > VALID_PROMPT_BLOB_CACHE_MAX_ENTRIES) {

const oldest = validPromptBlobCache.keys().next().value;

if (typeof oldest !== "string") {

break;

}

validPromptBlobCache.delete(oldest);

}

}

function readValidPromptBlob(storePath: string, ref: SessionSkillPromptRef): string | null {

if (

ref.version !== PROMPT_BLOB_VERSION ||

try {

const stat = fs.statSync(blobPath);

if (!stat.isFile() || stat.size !== ref.bytes) {

validPromptBlobCache.delete(blobPath);

return null;

}

const cached = validPromptBlobCache.get(blobPath);

if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {

return cached.prompt;

}

const prompt = fs.readFileSync(blobPath, "utf8");

return hashPrompt(prompt) === ref.hash && Buffer.byteLength(prompt, "utf8") === ref.bytes

? prompt

: null;

if (hashPrompt(prompt) !== ref.hash || Buffer.byteLength(prompt, "utf8") !== ref.bytes) {

validPromptBlobCache.delete(blobPath);

return null;

}

rememberValidPromptBlob(blobPath, stat, prompt);

return prompt;

} catch {

validPromptBlobCache.delete(blobPath);

return null;

}

}

// sessions.json is replaced. Refresh its mtime so orphan cleanup does not

// reclaim the blob while the store write is still in flight.

await fs.promises.utimes(blobPath, now, now);

rememberValidPromptBlob(blobPath, await fs.promises.stat(blobPath), prompt);

return ref;

} catch {

// A concurrent cleanup may have removed it; rewrite below.

mode: 0o600,

tempPrefix: path.basename(blobPath),

});

rememberValidPromptBlob(blobPath, await fs.promises.stat(blobPath), prompt);

return ref;

}