import { describe, expect, it } from "vitest";

import { createCustomMessage } from "./messages.js";

describe("harness message timestamps", () => {

it("rejects invalid timestamps before creating context messages", () => {

expect(() => createCustomMessage("note", "content", true, {}, "not-a-date")).toThrow(

"custom message timestamp must be a valid timestamp",

);

});

});

import type { ImageContent, Message, TextContent } from "../llm.js";

import type { AgentMessage } from "../types.js";

import { requireSessionTimestampMs } from "./session/timestamps.js";

export const COMPACTION_SUMMARY_PREFIX = `The conversation history before this point was compacted into the following summary:

role: "branchSummary",

summary,

fromId,

timestamp: new Date(timestamp).getTime(),

timestamp: requireSessionTimestampMs(timestamp, "branch summary timestamp"),

};

}

role: "compactionSummary",

summary,

tokensBefore,

timestamp: new Date(timestamp).getTime(),

timestamp: requireSessionTimestampMs(timestamp, "compaction summary timestamp"),

};

}

content,

display,

details,

timestamp: new Date(timestamp).getTime(),

timestamp: requireSessionTimestampMs(timestamp, "custom message timestamp"),

};

}

getFileSystemResultOrThrow,

toSession,

} from "./repo-utils.js";

import { parseSessionTimestampMs } from "./timestamps.js";

type JsonlSessionRepoFileSystem = Pick<

FileSystem,

}

}

}

sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());

sessions.sort(

(a, b) =>

(parseSessionTimestampMs(b.createdAt) ?? Number.NEGATIVE_INFINITY) -

(parseSessionTimestampMs(a.createdAt) ?? Number.NEGATIVE_INFINITY),

);

return sessions;

}

import { describe, expect, it } from "vitest";

import { ok, type FileSystem } from "../types.js";

import { JsonlSessionStorage, loadJsonlSessionMetadata } from "./jsonl-storage.js";

type JsonlStorageFs = Pick<

FileSystem,

"readTextFile" | "readTextLines" | "writeFile" | "appendFile"

>;

function createReadOnlyFs(content: string): JsonlStorageFs {

return {

readTextFile: async () => ok(content),

readTextLines: async (_path, options) => ok(content.split("\n").slice(0, options?.maxLines)),

writeFile: async () => ok(undefined),

appendFile: async () => ok(undefined),

};

}

describe("JsonlSessionStorage timestamps", () => {

it("rejects invalid session header timestamps", async () => {

const fs = createReadOnlyFs(

`${JSON.stringify({

type: "session",

version: 3,

id: "session-1",

timestamp: "not-a-date",

cwd: "/repo",

})}\n`,

);

await expect(loadJsonlSessionMetadata(fs, "/sessions/invalid.jsonl")).rejects.toThrow(

"session header has invalid timestamp",

);

});

it("rejects invalid entry timestamps", async () => {

const fs = createReadOnlyFs(

`${JSON.stringify({

type: "session",

version: 3,

id: "session-1",

timestamp: "2026-01-01T00:00:00.000Z",

cwd: "/repo",

})}\n${JSON.stringify({

type: "custom",

id: "entry-1",

parentId: null,

timestamp: "not-a-date",

customType: "note",

})}\n`,

);

await expect(JsonlSessionStorage.open(fs, "/sessions/invalid-entry.jsonl")).rejects.toThrow(

"line 2 has invalid timestamp",

);

});

});

import { SessionError, toError } from "../types.js";

import { getFileSystemResultOrThrow } from "./repo-utils.js";

import { BaseSessionStorage, leafIdAfterEntry } from "./storage-base.js";

import { parseSessionTimestampMs } from "./timestamps.js";

type JsonlSessionStorageFileSystem = Pick<

FileSystem,

if (typeof parsed.timestamp !== "string" || !parsed.timestamp) {

throw invalidSession(filePath, "session header is missing timestamp");

}

if (parseSessionTimestampMs(parsed.timestamp) === undefined) {

throw invalidSession(filePath, "session header has invalid timestamp");

}

if (typeof parsed.cwd !== "string" || !parsed.cwd) {

throw invalidSession(filePath, "session header is missing cwd");

}

if (typeof parsed.timestamp !== "string" || !parsed.timestamp) {

throw invalidEntry(filePath, lineNumber, "is missing timestamp");

}

if (parseSessionTimestampMs(parsed.timestamp) === undefined) {

throw invalidEntry(filePath, lineNumber, "has invalid timestamp");

}

if (parsed.type === "leaf" && parsed.targetId !== null && typeof parsed.targetId !== "string") {

throw invalidEntry(filePath, lineNumber, "has invalid targetId");

}

export function parseSessionTimestampMs(value: unknown): number | undefined {

if (typeof value !== "string" || !value.trim()) {

return undefined;

}

const parsed = Date.parse(value);

return Number.isFinite(parsed) ? parsed : undefined;

}

export function requireSessionTimestampMs(value: string, label: string): number {

const parsed = parseSessionTimestampMs(value);

if (parsed === undefined) {

throw new Error(`${label} must be a valid timestamp`);

}

return parsed;

}