heyiam 0.3.2 → 0.3.4

package/dist/routes/publish.js

@@ -5,20 +5,19 @@ import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { getAuthToken } from '../auth.js';
 import { API_URL, PUBLIC_URL, warnIfNonDefaultApiUrl } from '../config.js';
-import { loadEnhancedData, saveEnhancedData, saveUploadedState, getDefaultTemplate, getPortfolioProfile, hashPortfolioProfile, updatePortfolioPublishTarget, getPortfolioPublishState, isTranscriptIncluded, DEFAULT_PORTFOLIO_TARGET, } from '../settings.js';
+import { loadEnhancedData, saveUploadedState, getDefaultTemplate, getPortfolioProfile, hashPortfolioProfile, updatePortfolioPublishTarget, getPortfolioPublishState, DEFAULT_PORTFOLIO_TARGET, } from '../settings.js';
 import { generatePortfolioHtmlFragment, generateProjectHtmlFragment, generatePortfolioSite, createZipBuffer } from '../export.js';
 import { buildPortfolioRenderData } from './portfolio-render-data.js';
 import { buildProjectDetail } from './context.js';
 import { captureScreenshot } from '../screenshot.js';
-import { redactSession, redactText, scanTextSync, formatFindings, stripHomePathsInText } from '../redact.js';
-import { renderProjectHtml, renderSessionHtml } from '../render/index.js';
-import { buildSessionRenderData, buildSessionCard, buildProjectRenderData } from '../render/build-render-data.js';
-import { buildAgentSummary } from './context.js';
+import { renderProjectHtml } from '../render/index.js';
+import { buildProjectRenderData } from '../render/build-render-data.js';
+import { uploadSelectedSessions } from './project-session-upload.js';
 import { invalidatePortfolioPreviewCache } from './preview.js';
 import { startSSE } from './sse.js';
 import { displayNameFromDir } from '../sync.js';
 import { toSlug } from '../format-utils.js';
-import { getProjectUuid, getFileCountWithChildren } from '../db.js';
+import { getProjectUuid } from '../db.js';
 const IMAGE_KEY_PREFIX = 'images/';
 export function createPublishRouter(ctx) {
     const router = Router();
@@ -210,220 +209,17 @@ export function createPublishRouter(ctx) {
             const proj = projects.find((p) => p.dirName === project);
             let uploadedCount = 0;
             const failedSessions = [];
-            const uploadedSessionCards = [];
+            let uploadedSessionCards = [];
             if (proj) {
-                const selectedTemplate = getDefaultTemplate() || 'editorial';
-                for (const sessionId of selectedSessionIds) {
-                    const meta = proj.sessions.find((s) => s.sessionId === sessionId);
-                    if (!meta)
-                        continue;
-                    send({ type: 'session', sessionId, status: 'uploading' });
-                    try {
-                        const session = await ctx.loadSession(meta.path, proj.name, sessionId);
-                        const enhanced = loadEnhancedData(sessionId);
-                        const sessionSlug = toSlug(enhanced?.title ?? session.title ?? sessionId, 80);
-                        const includeTranscript = isTranscriptIncluded(sessionId);
-                        const agentSummary = await buildAgentSummary(meta.children ?? [], (c) => ctx.getSessionStats(c, proj.name), { deduplicate: true });
-                        const devTake = (enhanced?.developerTake ?? session.developerTake ?? '').slice(0, 2000);
-                        const sessionNarrative = enhanced?.narrative ?? '';
-                        const sessionTitle = enhanced?.title ?? session.title;
-                        const sessionSkills = enhanced?.skills ?? session.skills ?? [];
-                        const sessionSourceTool = session.source ?? meta.source ?? 'claude';
-                        const sessionRecordedAt = session.date ? new Date(session.date).toISOString() : new Date().toISOString();
-                        const renderOpts = {
-                            sessionId,
-                            session,
-                            enhanced,
-                            username: auth.username,
-                            projectSlug: projectData.slug,
-                            sessionSlug,
-                            sourceTool: sessionSourceTool,
-                            agentSummary,
-                            template: selectedTemplate,
-                        };
-                        let sessionRenderedHtml = null;
-                        try {
-                            const sessionRenderData = buildSessionRenderData(renderOpts);
-                            sessionRenderedHtml = renderSessionHtml(sessionRenderData, selectedTemplate);
-                        }
-                        catch (renderErr) {
-                            console.error(`[upload] Session render failed for ${sessionId}:`, renderErr.message);
-                        }
-                        uploadedSessionCards.push(buildSessionCard(renderOpts));
-                        const childLoc = agentSummary?.agents?.reduce((s, a) => s + (a.loc_changed ?? 0), 0) ?? 0;
-                        const totalLocChanged = (session.linesOfCode ?? 0) + childLoc;
-                        const totalFilesChanged = getFileCountWithChildren(ctx.db, sessionId) || session.filesChanged?.length || 0;
-                        const sessionPayload = {
-                            session: {
-                                title: sessionTitle,
-                                dev_take: devTake,
-                                context: enhanced?.context ?? '',
-                                duration_minutes: session.durationMinutes ?? 0,
-                                turns: session.turns ?? 0,
-                                files_changed: totalFilesChanged,
-                                loc_changed: totalLocChanged,
-                                recorded_at: sessionRecordedAt,
-                                end_time: session.endTime ? new Date(session.endTime).toISOString() : null,
-                                cwd: session.cwd ?? null,
-                                wall_clock_minutes: session.wallClockMinutes ?? null,
-                                template: selectedTemplate,
-                                language: null,
-                                tools: session.toolBreakdown?.map((t) => t.tool) ?? [],
-                                skills: sessionSkills,
-                                narrative: sessionNarrative,
-                                project_name: proj.name,
-                                project_id: projectData.project_id,
-                                slug: sessionSlug,
-                                status: 'unlisted',
-                                source_tool: sessionSourceTool,
-                                agent_summary: agentSummary,
-                                rendered_html: sessionRenderedHtml,
-                            },
-                        };
-                        // Transcript-derived fields. When the user has toggled the
-                        // transcript OFF for this session we omit them from the
-                        // uploaded JSON entirely — see the spread below. The
-                        // session's main payload (dev take, skills, Q&A, etc.) is
-                        // unaffected.
-                        const turnTimeline = (session.turnTimeline ?? []).map((t) => ({
-                            timestamp: t.timestamp,
-                            type: t.type,
-                            content: (t.content ?? '').slice(0, 200),
-                            tools: t.tools ?? [],
-                        }));
-                        const transcriptExcerpt = (session.rawLog ?? []).slice(0, 10).map((line, i) => {
-                            const role = line.startsWith('> ') ? 'dev' : 'ai';
-                            const text = role === 'dev' ? line.slice(2) : line;
-                            return { role, id: `Turn ${i + 1}`, text, timestamp: null };
-                        });
-                        const sessionData = {
-                            version: 1,
-                            id: sessionId,
-                            title: sessionTitle,
-                            dev_take: devTake,
-                            context: enhanced?.context ?? '',
-                            duration_minutes: session.durationMinutes ?? 0,
-                            turns: session.turns ?? 0,
-                            files_changed: (session.filesChanged ?? []).slice(0, 20).map((f) => (typeof f === 'string' ? { path: f, additions: 0, deletions: 0 } : f)),
-                            loc_changed: totalLocChanged,
-                            date: sessionRecordedAt,
-                            end_time: (() => {
-                                if (!session.endTime || !session.date)
-                                    return null;
-                                const wallMs = new Date(session.endTime).getTime() - new Date(session.date).getTime();
-                                const activeMs = (session.durationMinutes ?? 0) * 60_000;
-                                return wallMs <= activeMs * 3 ? new Date(session.endTime).toISOString() : null;
-                            })(),
-                            cwd: session.cwd ?? null,
-                            wall_clock_minutes: session.wallClockMinutes ?? null,
-                            template: selectedTemplate,
-                            skills: sessionSkills,
-                            tools: session.toolBreakdown?.map((t) => t.tool) ?? [],
-                            source: sessionSourceTool,
-                            slug: sessionSlug,
-                            project_name: proj.name,
-                            narrative: sessionNarrative,
-                            status: 'unlisted',
-                            raw_log: [],
-                            execution_path: (enhanced?.executionSteps ?? session.executionPath ?? []).map((s, i) => ({
-                                label: s.title ?? `Step ${i + 1}`,
-                                description: s.description ?? s.body ?? '',
-                            })),
-                            qa_pairs: enhanced?.qaPairs ?? session.qaPairs ?? [],
-                            highlights: [],
-                            tool_breakdown: (session.toolBreakdown ?? []).map((t) => ({ tool: t.tool, count: t.count })),
-                            top_files: (session.filesChanged ?? []).slice(0, 20).map((f) => (typeof f === 'string' ? { path: f, additions: 0, deletions: 0 } : f)),
-                            ...(includeTranscript ? { turn_timeline: turnTimeline } : {}),
-                            ...(includeTranscript ? { transcript_excerpt: transcriptExcerpt } : {}),
-                            agent_summary: agentSummary,
-                            children: agentSummary?.agents?.map((a) => ({
-                                sessionId: a.role,
-                                role: a.role,
-                                durationMinutes: a.duration_minutes,
-                                linesOfCode: a.loc_changed,
-                            })) ?? [],
-                        };
-                        const sessionCwd = session.cwd ?? undefined;
-                        const redactedPayload = redactSession(sessionPayload, 'high', sessionCwd);
-                        const redactedData = redactSession(sessionData, 'high', sessionCwd);
-                        const payloadFindings = scanTextSync(JSON.stringify(sessionPayload));
-                        if (payloadFindings.length > 0) {
-                            const summary = formatFindings(payloadFindings);
-                            send({ type: 'redaction', sessionId, message: summary });
-                        }
-                        const sessionRes = await fetch(`${API_URL}/api/sessions`, {
-                            method: 'POST',
-                            headers: {
-                                'Content-Type': 'application/json',
-                                Authorization: `Bearer ${auth.token}`,
-                            },
-                            body: JSON.stringify(redactedPayload),
-                        });
-                        if (sessionRes.ok) {
-                            uploadedCount++;
-                            try {
-                                const sesData = await sessionRes.json();
-                                if (sesData.upload_urls && includeTranscript) {
-                                    // Transcript-bearing S3 uploads. Skipped entirely when
-                                    // the user has toggled the transcript OFF for this
-                                    // session — the server never sees raw_log, turn
-                                    // timeline, or the bundled session-data JSON in that
-                                    // case.
-                                    const { raw: rawUrl, log: logUrl } = sesData.upload_urls;
-                                    if (rawUrl && meta.path && !meta.path.startsWith('cursor://')) {
-                                        try {
-                                            const rawText = readFileSync(meta.path, 'utf-8');
-                                            let redactedRaw = redactText(rawText);
-                                            redactedRaw = stripHomePathsInText(redactedRaw, sessionCwd);
-                                            await fetch(rawUrl, { method: 'PUT', body: Buffer.from(redactedRaw, 'utf-8'), headers: { 'Content-Type': 'application/octet-stream' } });
-                                        }
-                                        catch { /* S3 upload is best-effort */ }
-                                    }
-                                    if (logUrl && session.rawLog && session.rawLog.length > 0) {
-                                        try {
-                                            const redactedLog = session.rawLog.map((line) => {
-                                                let cleaned = redactText(line);
-                                                cleaned = stripHomePathsInText(cleaned, sessionCwd);
-                                                return cleaned;
-                                            });
-                                            await fetch(logUrl, { method: 'PUT', body: JSON.stringify(redactedLog), headers: { 'Content-Type': 'application/json' } });
-                                        }
-                                        catch { /* S3 upload is best-effort */ }
-                                    }
-                                    if (sesData.upload_urls.session) {
-                                        try {
-                                            await fetch(sesData.upload_urls.session, {
-                                                method: 'PUT',
-                                                body: JSON.stringify(redactedData),
-                                                headers: { 'Content-Type': 'application/json' },
-                                            });
-                                        }
-                                        catch { /* S3 upload is best-effort */ }
-                                    }
-                                }
-                            }
-                            catch { /* Response already consumed or no upload_urls -- not fatal */ }
-                            if (enhanced) {
-                                saveEnhancedData(sessionId, { ...enhanced, uploaded: true });
-                            }
-                            send({ type: 'session', sessionId, status: 'uploaded' });
-                        }
-                        else {
-                            const sesErrBody = await sessionRes.json().catch(() => null);
-                            const rawSesErr = sesErrBody && typeof sesErrBody === 'object' ? sesErrBody.error : null;
-                            const errMsg = typeof rawSesErr === 'string' ? rawSesErr
-                                : (rawSesErr && typeof rawSesErr === 'object' && 'message' in rawSesErr) ? rawSesErr.message
-                                    : `HTTP ${sessionRes.status}`;
-                            failedSessions.push({ sessionId, error: errMsg });
-                            send({ type: 'session', sessionId, status: 'failed', error: errMsg });
-                        }
-                    }
-                    catch (err) {
-                        const errMsg = err.message;
-                        failedSessions.push({ sessionId, error: errMsg });
-                        send({ type: 'session', sessionId, status: 'failed', error: errMsg });
-                    }
-                }
+                const sessionResult = await uploadSelectedSessions(ctx, auth, {
+                    proj,
+                    projectData,
+                    selectedSessionIds,
+                    send,
+                });
+                uploadedCount = sessionResult.uploadedCount;
+                failedSessions.push(...sessionResult.failedSessions);
+                uploadedSessionCards = sessionResult.uploadedSessionCards;
             }
             // Step 3: Render project HTML using the same path as HTML export
             if (uploadedSessionCards.length > 0) {
@@ -563,44 +359,156 @@ export function createPublishRouter(ctx) {
             // Upload individual project pages for every project included in the
             // portfolio. This ensures project detail pages exist on heyi.am even
             // if the user never published them individually.
+            const MAX_SLUG_RETRIES = 10;
             for (const rawProj of filteredProjects) {
                 try {
+                    const allProjectsList = await ctx.getProjects();
+                    const projInfo = allProjectsList.find((p) => p.dirName === rawProj.dirName);
+                    if (!projInfo) {
+                        console.warn(`[portfolio-upload] project not found: ${rawProj.dirName}`);
+                        continue;
+                    }
                     const detail = buildProjectDetail(ctx.db, rawProj);
-                    const proj = detail.project;
-                    const cache = detail.enhanceCache
-                        ?? { fingerprint: 'portfolio-upload', enhancedAt: new Date().toISOString(), selectedSessionIds: detail.sessions.map((s) => s.id), result: { narrative: '', arc: [], skills: [], timeline: [], questions: [] } };
+                    const enhance = detail.enhanceCache;
+                    const cache = enhance ?? {
+                        fingerprint: 'portfolio-upload',
+                        enhancedAt: new Date().toISOString(),
+                        selectedSessionIds: detail.sessions.map((s) => s.id),
+                        result: { narrative: '', arc: [], skills: [], timeline: [], questions: [] },
+                    };
+                    const selectedSessionIds = enhance !== null && enhance.selectedSessionIds !== undefined
+                        ? enhance.selectedSessionIds
+                        : detail.sessions.map((s) => s.id);
+                    const projRecord = detail.project;
                     const title = cache.title
-                        || proj.name || displayNameFromDir(rawProj.dirName);
-                    const slug = toSlug(title);
+                        || projRecord.name || displayNameFromDir(rawProj.dirName);
+                    const baseSlug = toSlug(title);
                     const clientProjectId = getProjectUuid(ctx.db, rawProj.dirName);
-                    const projectHtml = generateProjectHtmlFragment(rawProj.dirName, cache, detail.sessions, auth.username, {
-                        totalFilesChanged: proj.totalFiles,
-                        totalAgentDurationMinutes: proj.totalAgentDuration,
-                        totalInputTokens: proj.totalInputTokens,
-                        totalOutputTokens: proj.totalOutputTokens,
+                    const projectHtmlPreview = generateProjectHtmlFragment(rawProj.dirName, cache, detail.sessions, auth.username, {
+                        totalFilesChanged: projRecord.totalFiles,
+                        totalAgentDurationMinutes: projRecord.totalAgentDuration,
+                        totalInputTokens: projRecord.totalInputTokens,
+                        totalOutputTokens: projRecord.totalOutputTokens,
                     });
-                    await fetch(`${API_URL}/api/projects`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            Authorization: `Bearer ${auth.token}`,
-                        },
-                        body: JSON.stringify({
-                            project: {
-                                client_project_id: clientProjectId,
-                                title, slug,
-                                narrative: cache.result?.narrative ?? '',
-                                skills: cache.result?.skills ?? [],
-                                total_sessions: proj.sessionCount,
-                                total_loc: proj.totalLoc,
-                                total_duration_minutes: proj.totalDuration,
-                                total_agent_duration_minutes: proj.totalAgentDuration || null,
-                                total_files_changed: proj.totalFiles,
-                                total_input_tokens: proj.totalInputTokens,
-                                total_output_tokens: proj.totalOutputTokens,
-                                rendered_html: projectHtml,
+                    const projectBodyBase = {
+                        client_project_id: clientProjectId,
+                        title,
+                        narrative: cache.result?.narrative ?? '',
+                        repo_url: cache.repoUrl || null,
+                        project_url: cache.projectUrl || null,
+                        timeline: cache.result?.timeline ?? [],
+                        skills: cache.result?.skills ?? [],
+                        total_sessions: projRecord.sessionCount,
+                        total_loc: projRecord.totalLoc,
+                        total_duration_minutes: projRecord.totalDuration,
+                        total_agent_duration_minutes: projRecord.totalAgentDuration || null,
+                        total_files_changed: projRecord.totalFiles,
+                        total_input_tokens: projRecord.totalInputTokens,
+                        total_output_tokens: projRecord.totalOutputTokens,
+                        skipped_sessions: [],
+                    };
+                    let slug = baseSlug;
+                    let projectRes = null;
+                    if (selectedSessionIds.length === 0) {
+                        for (let attempt = 0; attempt <= MAX_SLUG_RETRIES; attempt++) {
+                            projectRes = await fetch(`${API_URL}/api/projects`, {
+                                method: 'POST',
+                                headers: {
+                                    'Content-Type': 'application/json',
+                                    Authorization: `Bearer ${auth.token}`,
+                                },
+                                body: JSON.stringify({
+                                    project: {
+                                        ...projectBodyBase,
+                                        slug,
+                                        rendered_html: projectHtmlPreview,
+                                    },
+                                }),
+                            });
+                            if (projectRes.status === 409) {
+                                slug = `${baseSlug}-${attempt + 1}`;
+                                continue;
+                            }
+                            break;
+                        }
+                        if (!projectRes?.ok) {
+                            const errText = await projectRes?.text().catch(() => '');
+                            console.warn(`[portfolio-upload] project ${rawProj.dirName} create failed:`, projectRes?.status, errText);
+                        }
+                        continue;
+                    }
+                    for (let attempt = 0; attempt <= MAX_SLUG_RETRIES; attempt++) {
+                        projectRes = await fetch(`${API_URL}/api/projects`, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                                Authorization: `Bearer ${auth.token}`,
                             },
-                        }),
+                            body: JSON.stringify({
+                                project: {
+                                    ...projectBodyBase,
+                                    slug,
+                                },
+                            }),
+                        });
+                        if (projectRes.status === 409) {
+                            slug = `${baseSlug}-${attempt + 1}`;
+                            continue;
+                        }
+                        break;
+                    }
+                    if (!projectRes || !projectRes.ok) {
+                        const errText = await projectRes?.text().catch(() => '') ?? '';
+                        console.warn(`[portfolio-upload] project ${rawProj.dirName} create failed:`, projectRes?.status, errText);
+                        continue;
+                    }
+                    const projectData = await projectRes.json();
+                    const { uploadedSessionCards } = await uploadSelectedSessions(ctx, auth, {
+                        proj: projInfo,
+                        projectData,
+                        selectedSessionIds,
+                    });
+                    if (uploadedSessionCards.length === 0) {
+                        continue;
+                    }
+                    try {
+                        const detailAfter = buildProjectDetail(ctx.db, rawProj);
+                        const cacheAfter = detailAfter.enhanceCache ?? cache;
+                        const totalFiles = detailAfter.project.totalFiles;
+                        const projectHtmlFinal = generateProjectHtmlFragment(rawProj.dirName, cacheAfter, detailAfter.sessions, auth.username, {
+                            totalFilesChanged: totalFiles,
+                            totalInputTokens: detailAfter.project.totalInputTokens,
+                            totalOutputTokens: detailAfter.project.totalOutputTokens,
+                        });
+                        const renderRes = await fetch(`${API_URL}/api/projects`, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                                Authorization: `Bearer ${auth.token}`,
+                            },
+                            body: JSON.stringify({
+                                project: {
+                                    ...projectBodyBase,
+                                    slug: projectData.slug,
+                                    rendered_html: projectHtmlFinal,
+                                },
+                            }),
+                        });
+                        if (!renderRes.ok) {
+                            console.warn(`[portfolio-upload] project ${rawProj.dirName} rendered_html update failed:`, renderRes.status);
+                        }
+                    }
+                    catch (renderErr) {
+                        console.warn(`[portfolio-upload] project render update ${rawProj.dirName}:`, renderErr.message);
+                    }
+                    const uploadedSessionIds = selectedSessionIds.filter((sid) => {
+                        const enhanced = loadEnhancedData(sid);
+                        return enhanced?.uploaded;
+                    });
+                    saveUploadedState(rawProj.dirName, {
+                        slug: projectData.slug,
+                        projectId: projectData.project_id,
+                        uploadedSessions: uploadedSessionIds,
                     });
                 }
                 catch (projErr) {

package/dist/source-audit.js

@@ -1,9 +1,6 @@
 // Source Audit — cross-references live sessions with the archive to
 // produce per-source scan results and archive health metrics.
-import { readdir, stat } from "node:fs/promises";
-import { join } from "node:path";
 import { SOURCE_DISPLAY_NAMES } from "./parsers/types.js";
-import { getArchiveDir } from "./settings.js";
 import { getDatabase, getSessionCount } from "./db.js";
 // ── Source paths ─────────────────────────────────────────────
 const SOURCE_PATHS = {
@@ -74,64 +71,47 @@ export async function getSourceAudit(configDir) {
     return { sources };
 }
 /**
- * Return archive-level statistics: total archived, oldest session date,
- * source count, last sync time, and disk usage.
+ * Return archive-level statistics: total preserved sessions, oldest session
+ * date, source count, last sync time.
+ *
+ * Reads from the SQLite `sessions` table rather than walking the filesystem
+ * archive dir. The DB is authoritative for "what's been preserved" — the
+ * filesystem archive is a secondary copy, and the previous version reported
+ * `total: 0` whenever the archive dir was empty even though the sessions
+ * table held hundreds of indexed sessions. That made the top card diverge
+ * from the "By source" table directly beneath it, which was the bug the
+ * user called out.
  */
-export async function getArchiveStats(configDir) {
-    const archiveDir = getArchiveDir(configDir);
+export async function getArchiveStats(_configDir) {
     let total = 0;
-    let oldestMs = Infinity;
+    let oldestIso = null;
+    let lastSyncMs = 0;
     const sourcesFound = new Set();
-    let newestMs = 0;
-    try {
-        const projectDirs = await readdir(archiveDir, { withFileTypes: true });
-        for (const projectEntry of projectDirs) {
-            if (!projectEntry.isDirectory())
-                continue;
-            const projectPath = join(archiveDir, projectEntry.name);
-            const files = await readdir(projectPath, { withFileTypes: true }).catch(() => []);
-            for (const file of files) {
-                if (!file.name.endsWith(".jsonl") || file.isDirectory())
-                    continue;
-                total++;
-                const filePath = join(projectPath, file.name);
-                try {
-                    const fileStat = await stat(filePath);
-                    const mtimeMs = fileStat.mtimeMs;
-                    if (mtimeMs < oldestMs)
-                        oldestMs = mtimeMs;
-                    if (mtimeMs > newestMs)
-                        newestMs = mtimeMs;
-                }
-                catch {
-                    // stat failed — skip
-                }
-                // Detect source from file content (first line) would be expensive;
-                // instead use the parser detection on the archive path.
-                // For now, we count by project dir presence — the main signal.
-            }
-        }
-    }
-    catch {
-        // Archive directory doesn't exist yet
-    }
-    // Count distinct sources from SQLite (fast)
     try {
         const db = getDatabase();
-        const rows = db.prepare('SELECT DISTINCT source FROM sessions WHERE is_subagent = 0').all();
-        for (const row of rows) {
+        const totalRow = db.prepare('SELECT COUNT(*) as c, MIN(start_time) as earliest FROM sessions WHERE is_subagent = 0').get();
+        total = totalRow.c;
+        oldestIso = totalRow.earliest;
+        const sourceRows = db.prepare('SELECT DISTINCT source FROM sessions WHERE is_subagent = 0').all();
+        for (const row of sourceRows)
             sourcesFound.add(row.source);
+        // Last sync = newest indexed_at (the clock set when sync wrote the row).
+        const syncRow = db.prepare('SELECT MAX(indexed_at) as latest FROM sessions WHERE is_subagent = 0').get();
+        if (syncRow.latest) {
+            const ms = Date.parse(syncRow.latest);
+            if (!Number.isNaN(ms))
+                lastSyncMs = ms;
         }
     }
     catch {
-        // DB not ready
+        // DB not ready — return empty state.
     }
-    const oldest = oldestMs === Infinity
-        ? "none"
-        : formatMonthYear(new Date(oldestMs));
-    const lastSync = newestMs === 0
+    const oldest = oldestIso
+        ? formatMonthYear(new Date(oldestIso))
+        : "none";
+    const lastSync = lastSyncMs === 0
         ? "never"
-        : formatRelativeTime(newestMs);
+        : formatRelativeTime(lastSyncMs);
     return {
         total,
         oldest,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyiam",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Turn AI coding sessions into portfolio case studies",
   "type": "module",
   "license": "MIT",