const d = now instanceof Date ? now : new Date();

const stamp = d.toISOString().replace(/[:.]/g, '-').slice(0, 19); // 2026-07-28T09-12-33

const r = rand != null ? String(rand) : crypto.randomBytes(3).toString('hex').slice(0, 4);

return stamp + '-' + r;

const m = { kind: 'meta', v: SCHEMA_V, id: String(id), project: String(projectPath == null ? '' : projectPath),

createdAt: String(createdAtIso), title: title == null ? null : String(title) };

// Provenance for a forked session, and ONLY for one — the key is absent on an ordinary session so

// every existing file and expectation stays byte-identical. Unknown meta keys are ignored by

// parseSession and deriveEntry, so this is additive in both directions: an older build reading a

// forked session simply does not know it was forked, rather than failing to read it.

if (forkedFrom != null && String(forkedFrom)) { m.forkedFrom = String(forkedFrom); }

return m;

const lines = String(text == null ? '' : text).split('\n');

let meta = null;

const events = [];

for (let i = 0; i < lines.length; i++) {

const line = lines[i];

if (!line) { continue; } // blank (incl. the trailing newline's empty tail)

let obj;

try { obj = JSON.parse(line); }

catch { if (i === lines.length - 1) { break; } else { continue; } } // torn last line → stop; a mid-file junk line → skip

if (obj && obj.kind === 'meta' && !meta) { meta = obj; }

else { events.push(obj); }

}

return { meta, events };

const evs = Array.isArray(events) ? events : [];

const id = meta && meta.id ? String(meta.id) : null;

const createdAt = meta && meta.createdAt ? meta.createdAt : (evs[0] && evs[0].t) || null;

let title = null, updatedAt = createdAt, model = null, state = 'active', lifecycle = 'active', pinned = false;

let turns = 0, firstUser = null;

const editCounts = new Map(); // path → times edited (order-preserving via Map)

const spark = [];

for (const e of evs) {

if (!e || typeof e !== 'object') { continue; }

if (e.t) { updatedAt = e.t; }

switch (e.kind) {

case 'user': turns++; if (firstUser == null && e.content != null) { firstUser = String(e.content); } break;

case 'assistant': case 'agent': if (e.model) { model = e.model; } break;

case 'title': if (e.title != null) { title = String(e.title); } break;

case 'end': if (e.state) { state = String(e.state); } break;

case 'label':

if (e.lifecycle) { lifecycle = String(e.lifecycle); }

if (typeof e.pinned === 'boolean') { pinned = e.pinned; }

break;

}

// files edited + the activity sparkline come from agent turns (explicit `edits` + `tools` count)

if (e.kind === 'agent' || e.kind === 'edit') {

const paths = e.kind === 'edit' ? (e.path ? [e.path] : []) : (Array.isArray(e.edits) ? e.edits.map((x) => x && x.path).filter(Boolean) : []);

for (const p of paths) { editCounts.set(p, (editCounts.get(p) || 0) + 1); }

}

if (e.kind === 'agent') { spark.push(Number.isFinite(e.tools) ? e.tools : (Array.isArray(e.edits) ? e.edits.length : 0)); }

}

if (title == null) { title = (meta && meta.title != null) ? String(meta.title) : (firstUser != null ? truncate(firstUser, 56) : null); }

const filesEdited = [...editCounts.entries()].sort((a, b) => b[1] - a[1]).map(([p]) => p);

return { id, title, createdAt, updatedAt, turns, model, state, lifecycle, pinned,

filesEdited, spark, preview: firstUser != null ? truncate(firstUser, PREVIEW_MAX) : null };

fs.mkdirSync(projectDir(root, slug), { recursive: true });

fs.writeFileSync(sessionFile(root, slug, id), encodeEvent(metaLine(id, projectPath, createdAtIso, title, forkedFrom)));

return sessionFile(root, slug, id);

let names;

try { names = fs.readdirSync(projectDir(root, slug)); }

catch { return []; } // no project dir yet → no sessions

return names.filter((n) => n.endsWith('.jsonl')).map((n) => path.join(root, slug, n));

const entries = [];

for (const file of listSessionFiles(root, slug)) {

try { const { meta, events } = readSession(file); const e = deriveEntry(meta, events); if (e.id) { entries.push(e); } }

catch { /* a single unreadable file must not sink the scan */ }

}

return sortEntries(entries);

try {

const raw = fs.readFileSync(indexFile(root, slug), 'utf8');

const obj = JSON.parse(raw);

if (obj && obj.v === SCHEMA_V && Array.isArray(obj.entries)) {

return { v: SCHEMA_V, entries: sortEntries(obj.entries), rebuilt: false };

}

} catch { /* fall through to rebuild */ }

return { v: SCHEMA_V, entries: scanProject(root, slug), rebuilt: true };

fs.mkdirSync(projectDir(root, slug), { recursive: true });

const tmp = indexFile(root, slug) + '.' + process.pid + '.tmp';

fs.writeFileSync(tmp, JSON.stringify({ v: SCHEMA_V, entries: sortEntries(entries) }));

fs.renameSync(tmp, indexFile(root, slug));

const out = (Array.isArray(entries) ? entries : []).filter((e) => e && e.id !== entry.id);

out.push(entry);

return sortEntries(out);

const entries = index && Array.isArray(index.entries) ? index.entries : [];

for (const e of entries) { if (e && e.id === id) { return e; } }

return null;

const o = opts || {};

let entries = (index && Array.isArray(index.entries) ? index.entries : []).slice();

if (o.lifecycle) { entries = entries.filter((e) => (e.lifecycle || 'active') === o.lifecycle); }

return sortEntries(entries);