@izkac/forgekit 0.3.13 → 0.3.15

package/src/fleet.mjs

@@ -24,6 +24,7 @@ import {
   queueMessage,
   sessionDirFor,
 } from './lib/fleet.mjs';
+import { healthCell, sessionHealth } from './health.mjs';
 
 function usage() {
   process.stderr.write(
@@ -70,21 +71,45 @@ function pad(str, len) {
   return s.length >= len ? s.slice(0, len) : s + ' '.repeat(len - s.length);
 }
 
+/**
+ * Health per entry, read from that project's session dir. A row showing a
+ * healthy-looking `27/32` while its e2e run is red and nobody has touched it
+ * for 14 hours is the failure this column exists to prevent.
+ */
+function healthFor(entry) {
+  if (entry.missing) return { state: 'unknown', line: 'missing' };
+  try {
+    const sessionDir = sessionDirFor(entry);
+    const session = JSON.parse(fs.readFileSync(path.join(sessionDir, 'session.json'), 'utf8'));
+    return sessionHealth({ cwd: entry.project, sessionDir, session });
+  } catch {
+    return { state: 'unknown', line: 'unknown' };
+  }
+}
+
 function renderTable(entries) {
   if (entries.length === 0) return 'No fleet sessions. Start one with `forge new <slug>`.\n';
-  const header = `${pad('PROJECT', 18)} ${pad('SESSION', 26)} ${pad('ENGINE', 7)} ${pad('PHASE', 18)} ${pad('TASKS', 16)} ${pad('PACE', 9)} ${pad('AGE', 4)} MSGS`;
+  const header = `${pad('PROJECT', 18)} ${pad('SESSION', 26)} ${pad('ENGINE', 7)} ${pad('PHASE', 18)} ${pad('TASKS', 16)} ${pad('HEALTH', 6)} ${pad('PACE', 9)} ${pad('AGE', 4)} MSGS`;
   const lines = [header, '-'.repeat(header.length)];
+  /** @type {string[]} */
+  const notes = [];
   for (const e of entries) {
     const pending = e.missing ? 0 : peekInbox(sessionDirFor(e)).length;
+    const health = healthFor(e);
+    if (health.state === 'red' || health.state === 'stale') {
+      notes.push(`${e.projectName}/${e.slug}: ${health.line}`);
+    }
     lines.push(
       `${pad(e.projectName, 18)} ${pad(e.slug, 26)} ${pad(e.engine ?? '—', 7)} ${pad(
         e.missing ? 'missing' : phaseBar(e.phase),
         18,
-      )} ${pad(tasksCell(e), 16)} ${pad(e.pace ?? '—', 9)} ${pad(relTime(e.lastSeen ?? e.updatedAt), 4)} ${
+      )} ${pad(tasksCell(e), 16)} ${pad(healthCell(health.state), 6)} ${pad(e.pace ?? '—', 9)} ${pad(relTime(e.lastSeen ?? e.updatedAt), 4)} ${
         pending > 0 ? `✉ ${pending}` : ''
       }`,
     );
   }
+  // The column says which row; the notes say why, without a second command.
+  if (notes.length) lines.push('', ...notes.map((n) => `  ! ${n}`));
   return `${lines.join('\n')}\n`;
 }
 

package/src/fleet.test.mjs

@@ -80,6 +80,56 @@ test('listFleet self-heals entries whose session dir is gone', () => {
   assert.equal(fs.existsSync(entryFile(project, 'gone')), false);
 });
 
+test('listFleet reconciles a stale entry against session.json on disk', () => {
+  // Regression: the registry is a cache, not a source of truth. A session
+  // whose phase advanced without a mirroring write (older CLI, a crash, a
+  // hand-edited record) showed its first-registered phase forever — helm's
+  // phase-0 sat at `brainstorm` in `forge fleet list` after reaching `done`.
+  process.env.FORGEKIT_FLEET_DIR = path.join(tmp('fleet-reconcile-'), 'sessions');
+  const project = tmp('fleet-proj-');
+  const sessionDir = makeProject(project, 's5');
+
+  registerSession(project, makeSession('s5', { phase: 'brainstorm', tasksComplete: 0 }));
+  // Disk moves on without the registry.
+  const later = new Date(Date.now() + 60_000).toISOString();
+  fs.writeFileSync(
+    path.join(sessionDir, 'session.json'),
+    `${JSON.stringify(
+      makeSession('s5', {
+        phase: 'done',
+        tasksTotal: 20,
+        tasksComplete: 20,
+        openspecChange: 'phase-0',
+        updatedAt: later,
+      }),
+    )}\n`,
+    'utf8',
+  );
+
+  const [entry] = listFleet();
+  assert.equal(entry.phase, 'done');
+  assert.equal(entry.tasksComplete, 20);
+  assert.equal(entry.tasksTotal, 20);
+  assert.equal(entry.openspecChange, 'phase-0');
+  assert.equal(entry.updatedAt, later);
+  // Reconciliation is persisted, so the next read is already correct.
+  assert.equal(JSON.parse(fs.readFileSync(entryFile(project, 's5'), 'utf8')).phase, 'done');
+  // lastSeen is a heartbeat, not a session field — reconciling must not forge one.
+  assert.ok(entry.lastSeen <= new Date().toISOString());
+});
+
+test('listFleet keeps registry-only fields when session.json is unreadable', () => {
+  process.env.FORGEKIT_FLEET_DIR = path.join(tmp('fleet-unreadable-'), 'sessions');
+  const project = tmp('fleet-proj-');
+  const sessionDir = makeProject(project, 's6');
+  registerSession(project, makeSession('s6', { phase: 'verify' }));
+  fs.writeFileSync(path.join(sessionDir, 'session.json'), '{ not json', 'utf8');
+
+  const [entry] = listFleet();
+  assert.equal(entry.phase, 'verify');
+  assert.equal(entry.missing, false);
+});
+
 test('saveSession mirrors into the fleet registry', () => {
   process.env.FORGEKIT_FLEET_DIR = path.join(tmp('fleet-mirror-'), 'sessions');
   const project = tmp('fleet-proj-');

package/src/health.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+/**
+ * Session health — a verdict, not a data dump.
+ *
+ * `forge status` printed every field a session had and said nothing about
+ * whether the session was in trouble, so a session could sit at
+ * `implement 27/32` with a red e2e run for 14 hours and look exactly like one
+ * that was mid-stride. Health answers the one question the operator actually
+ * asks: is this session fine, stopped, or broken?
+ *
+ * Cheap on purpose — file reads only, no subprocesses — because it runs on
+ * every `forge status`, every reminder hook, and once per row in
+ * `forge fleet list`.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { e2ePath, e2eStepsHash, loadE2eResults } from './integrity.mjs';
+import { readJson } from './lib.mjs';
+
+/** Hours of no session write after which an unfinished session reads as stopped. */
+export const DEFAULT_IDLE_HOURS = 4;
+
+const SEVERITY = { done: 0, healthy: 1, stale: 2, red: 3 };
+
+/**
+ * @param {number} ms
+ * @returns {string}
+ */
+function humanDuration(ms) {
+  const min = Math.floor(ms / 60000);
+  if (min < 60) return `${Math.max(min, 1)}m`;
+  const hours = Math.floor(min / 60);
+  if (hours < 48) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+
+/**
+ * The failing step of a red run, for a reason line that names the problem
+ * instead of pointing at a file.
+ *
+ * @param {Record<string, any> | null} results
+ */
+function failedStepName(results) {
+  if (!results || !Array.isArray(results.steps)) return null;
+  const failed = results.steps.find((s) => s && s.ok === false);
+  return failed?.name ?? null;
+}
+
+/**
+ * @param {{ cwd?: string, sessionDir: string, session: Record<string, any>, now?: number, idleHours?: number }} opts
+ * @returns {{ state: 'healthy'|'stale'|'red'|'done', reasons: string[], line: string }}
+ */
+export function sessionHealth(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const { sessionDir, session } = opts;
+  const now = opts.now ?? Date.now();
+  const idleHours = Number.isFinite(opts.idleHours) ? Number(opts.idleHours) : DEFAULT_IDLE_HOURS;
+
+  /** @type {string[]} */
+  const reasons = [];
+  let state = 'healthy';
+  const escalate = (next) => {
+    if (SEVERITY[next] > SEVERITY[state]) state = next;
+  };
+
+  if (session.phase === 'done' || session.phase === 'skipped') {
+    return {
+      state: 'done',
+      reasons: [],
+      line: `DONE — ${session.slug ?? session.id} (${session.phase})`,
+    };
+  }
+
+  // --- executed product loop: the strongest signal we have on disk ---
+  try {
+    const results = loadE2eResults(sessionDir);
+    if (results) {
+      let currentHash = null;
+      try {
+        const doc = readJson(e2ePath({ cwd, session, sessionDir }));
+        currentHash = e2eStepsHash(doc.steps);
+      } catch {
+        currentHash = null;
+      }
+      // A failed run outranks a stale one: staleness asks "does this proof
+      // still describe the current steps", a failure says the loop is broken
+      // either way.
+      if (results.ok === false) {
+        const step = failedStepName(results);
+        const since = results.ranAt ? ` since ${results.ranAt}` : '';
+        reasons.push(`e2e failing${since}${step ? ` at step "${step}"` : ''}`);
+        escalate('red');
+      } else if (currentHash && results.stepsHash !== currentHash) {
+        reasons.push('e2e results are stale — e2e.json changed since the last run');
+        escalate('stale');
+      }
+    }
+  } catch {
+    /* health must never throw — a broken artifact is the caller's problem */
+  }
+
+  // --- an explicit BLOCKED beats any inference we could make ---
+  try {
+    const verify = path.join(sessionDir, 'verify-evidence.md');
+    if (fs.existsSync(verify) && /\bBLOCKED\b/.test(fs.readFileSync(verify, 'utf8'))) {
+      reasons.push('verify-evidence records BLOCKED — product loop not proven');
+      escalate('red');
+    }
+  } catch {
+    /* ignore */
+  }
+
+  // --- idle: nobody is driving this session ---
+  const updatedAt = new Date(session.updatedAt ?? session.createdAt ?? NaN).getTime();
+  if (!Number.isNaN(updatedAt)) {
+    const idleMs = now - updatedAt;
+    if (idleMs > idleHours * 3600 * 1000) {
+      const where = `${session.phase ?? 'unknown'}${
+        Number(session.tasksTotal) > 0 ? ` ${session.tasksComplete ?? 0}/${session.tasksTotal}` : ''
+      }`;
+      reasons.push(`idle ${humanDuration(idleMs)} at ${where}`);
+      escalate('stale');
+    }
+  }
+
+  const label = state.toUpperCase();
+  const line = reasons.length ? `${label} — ${reasons.join('; ')}` : `${label} — ${session.phase}`;
+  return { state, reasons, line };
+}
+
+/** Short cell for table renderers (`forge fleet list`). */
+export function healthCell(state) {
+  switch (state) {
+    case 'red':
+      return 'RED';
+    case 'stale':
+      return 'STALE';
+    case 'done':
+      return 'done';
+    default:
+      return 'ok';
+  }
+}

package/src/health.test.mjs

@@ -0,0 +1,138 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import { DEFAULT_IDLE_HOURS, sessionHealth } from './health.mjs';
+import { e2eStepsHash } from './integrity.mjs';
+
+function tmp(prefix) {
+  return fs.realpathSync(fs.mkdtempSync(path.join(tmpdir(), prefix)));
+}
+
+const HOUR = 3600 * 1000;
+const NOW = new Date('2026-07-25T12:00:00.000Z').getTime();
+const ago = (hours) => new Date(NOW - hours * HOUR).toISOString();
+
+/** Project + session dir; session.json is passed separately. */
+function makeProject(overrides = {}) {
+  const cwd = tmp('forge-health-');
+  const sessionDir = path.join(cwd, '.forge', 'sessions', 's1');
+  fs.mkdirSync(sessionDir, { recursive: true });
+  const session = {
+    id: 's1',
+    slug: 'phase-1',
+    phase: 'implement',
+    planType: 'specs',
+    openspecChange: 'phase-1',
+    tasksTotal: 32,
+    tasksComplete: 27,
+    createdAt: ago(30),
+    updatedAt: ago(1),
+    ...overrides,
+  };
+  return { cwd, sessionDir, session };
+}
+
+/** e2e.json in the change dir + a results file in the session dir. */
+function writeE2e({ cwd, sessionDir }, { ok, stale = false, ranAt = ago(2) } = {}) {
+  const changeDir = path.join(cwd, 'specs', 'changes', 'phase-1');
+  fs.mkdirSync(changeDir, { recursive: true });
+  const steps = [{ name: 'bench-check-enforces-the-budget-gate', cmd: 'true' }];
+  fs.writeFileSync(path.join(changeDir, 'e2e.json'), `${JSON.stringify({ steps })}\n`, 'utf8');
+  // stepsHash is computed by integrity.e2eStepsHash; a wrong hash is what a
+  // post-run edit of e2e.json looks like.
+  const results = {
+    ok,
+    ranAt,
+    stepsHash: stale ? 'deadbeef' : e2eStepsHash(steps),
+    steps: [{ name: 'bench-check-enforces-the-budget-gate', ok, exitCode: ok ? 0 : 1 }],
+  };
+  fs.writeFileSync(
+    path.join(sessionDir, 'e2e-results.json'),
+    `${JSON.stringify(results)}\n`,
+    'utf8',
+  );
+  return changeDir;
+}
+
+test('a session that ran recently and has no failing proof is healthy', () => {
+  const p = makeProject();
+  const health = sessionHealth({ ...p, now: NOW });
+  assert.equal(health.state, 'healthy');
+  assert.deepEqual(health.reasons, []);
+  assert.match(health.line, /^HEALTHY/);
+});
+
+test('a failing e2e run is RED and names the failing step', () => {
+  // helm phase-1: 27/32 with e2e red on the bench budget gate, and nothing
+  // anywhere said so.
+  const p = makeProject();
+  writeE2e(p, { ok: false });
+  const health = sessionHealth({ ...p, now: NOW });
+
+  assert.equal(health.state, 'red');
+  assert.equal(health.reasons.length, 1);
+  assert.match(health.reasons[0], /e2e failing/);
+  assert.match(health.reasons[0], /bench-check-enforces-the-budget-gate/);
+  assert.match(health.line, /^RED —/);
+});
+
+test('e2e results that no longer match e2e.json are stale, not green', () => {
+  const p = makeProject();
+  writeE2e(p, { ok: true, stale: true });
+  const health = sessionHealth({ ...p, now: NOW });
+
+  assert.equal(health.state, 'stale');
+  assert.match(health.reasons.join(' '), /e2e results.*stale|stale.*e2e/i);
+});
+
+test('a green current e2e run keeps the session healthy', () => {
+  const p = makeProject();
+  writeE2e(p, { ok: true });
+  assert.equal(sessionHealth({ ...p, now: NOW }).state, 'healthy');
+});
+
+test('an idle session is STALE and says where it stopped', () => {
+  const p = makeProject({ updatedAt: ago(14) });
+  const health = sessionHealth({ ...p, now: NOW });
+
+  assert.equal(health.state, 'stale');
+  assert.match(health.reasons[0], /idle 14h/);
+  assert.match(health.reasons[0], /implement 27\/32/);
+});
+
+test('idle threshold is configurable and defaults to DEFAULT_IDLE_HOURS', () => {
+  const p = makeProject({ updatedAt: ago(DEFAULT_IDLE_HOURS + 1) });
+  assert.equal(sessionHealth({ ...p, now: NOW }).state, 'stale');
+  assert.equal(sessionHealth({ ...p, now: NOW, idleHours: 48 }).state, 'healthy');
+});
+
+test('BLOCKED verify evidence is RED', () => {
+  const p = makeProject({ phase: 'verify' });
+  fs.writeFileSync(
+    path.join(p.sessionDir, 'verify-evidence.md'),
+    '# Verify\n\n## Product loop\n\nBLOCKED — the queue worker has no runtime owner yet.\n',
+    'utf8',
+  );
+  const health = sessionHealth({ ...p, now: NOW });
+  assert.equal(health.state, 'red');
+  assert.match(health.reasons.join(' '), /BLOCKED/);
+});
+
+test('a finished session is neither stale nor red', () => {
+  // Idle for a month and carrying an old failing run: done is done.
+  const p = makeProject({ phase: 'done', updatedAt: ago(720), tasksComplete: 32 });
+  writeE2e(p, { ok: false });
+  const health = sessionHealth({ ...p, now: NOW });
+  assert.equal(health.state, 'done');
+  assert.match(health.line, /^DONE/);
+});
+
+test('red outranks stale when both fire', () => {
+  const p = makeProject({ updatedAt: ago(14) });
+  writeE2e(p, { ok: false });
+  const health = sessionHealth({ ...p, now: NOW });
+  assert.equal(health.state, 'red');
+  assert.equal(health.reasons.length, 2, 'both reasons are reported, severity picks the state');
+});

package/src/integrity.mjs

@@ -112,9 +112,15 @@ export function resolveChangeDir(opts = {}) {
     return forWrite ? openspecDir : liveOrArchived(openspecChanges, change);
   }
 
+  // Only a *specs* engine resolution can name the specs dir. The engine
+  // resolver's last resort is {engine:'openspec', dir:'openspec'}, so taking
+  // `.dir` unconditionally pointed specs sessions at `openspec/changes/<name>`
+  // in every project whose .forge/config.json has no `plan` block — the change
+  // dir, its brief.html, spine.json and e2e.json all silently missing.
   let specsRoot = DEFAULT_SPECS_DIR;
   try {
-    specsRoot = resolveProjectPlanEngine(cwd, { useUserDefault: false }).dir;
+    const engine = resolveProjectPlanEngine(cwd, { useUserDefault: false });
+    if (engine.engine === 'specs') specsRoot = engine.dir;
   } catch {
     // keep default
   }

package/src/integrity.test.mjs

@@ -146,6 +146,52 @@ test('resolveChangeDir: falls back to the archived copy after archive', () => {
   }
 });
 
+test('resolveChangeDir: a specs session never falls back to the openspec dir', () => {
+  // Regression: resolveProjectPlanEngine's last-resort default is
+  // {engine:'openspec', dir:'openspec'}, so a specs-engine session in a
+  // project whose .forge/config.json has no `plan` block (ADR-only config,
+  // pre-engine config, hand-written) resolved into openspec/changes/<name> —
+  // which made `forge phase implement` refuse a brief that was right there.
+  const cwd = tmp('forge-specs-dir-');
+  try {
+    const session = { planType: 'specs', openspecChange: 'my-change' };
+    fs.mkdirSync(path.join(cwd, '.forge'), { recursive: true });
+    fs.writeFileSync(
+      path.join(cwd, '.forge', 'config.json'),
+      `${JSON.stringify({ adr: { enabled: true, dir: 'docs/adr' } })}\n`,
+      'utf8',
+    );
+    const specsChange = path.join(cwd, 'specs', 'changes', 'my-change');
+    fs.mkdirSync(specsChange, { recursive: true });
+
+    assert.equal(resolveChangeDir({ cwd, session }), specsChange);
+    assert.equal(resolveChangeDir({ cwd, session, forWrite: true }), specsChange);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('resolveChangeDir: specs engine honors a configured plan.dir', () => {
+  // `forge init --no-openspec --plan-dir openspec` — specs engine reusing an
+  // existing OpenSpec tree without moving files.
+  const cwd = tmp('forge-specs-plandir-');
+  try {
+    const session = { planType: 'specs', openspecChange: 'my-change' };
+    fs.mkdirSync(path.join(cwd, '.forge'), { recursive: true });
+    fs.writeFileSync(
+      path.join(cwd, '.forge', 'config.json'),
+      `${JSON.stringify({ plan: { engine: 'specs', dir: 'openspec' } })}\n`,
+      'utf8',
+    );
+    const changeDir = path.join(cwd, 'openspec', 'changes', 'my-change');
+    fs.mkdirSync(changeDir, { recursive: true });
+
+    assert.equal(resolveChangeDir({ cwd, session }), changeDir);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
 test('spinePath/e2ePath forWrite target the live dir even after archive', () => {
   const cwd = tmp('forge-write-guard-');
   try {

package/src/lib/fleet.mjs

@@ -134,10 +134,59 @@ export function unregisterSession(projectRoot, sessionId) {
 }
 
 /**
- * All registry entries, newest first. Self-heals: entries whose session dir
- * vanished (cleanup ran without unregister, project deleted the .forge dir)
- * are removed; entries whose whole project path is unreachable (unplugged
- * drive) are kept and marked `missing`.
+ * Fields the registry mirrors from session.json. `session.json` is the source
+ * of truth; the entry is only a cache, so reads refresh it.
+ */
+const MIRRORED_FIELDS = [
+  'slug',
+  'phase',
+  'planType',
+  'openspecChange',
+  'tasksTotal',
+  'tasksComplete',
+  'createdAt',
+  'updatedAt',
+];
+
+/**
+ * Refresh a cached entry from the session on disk. Returns true when anything
+ * changed. A registry write that never happened (older CLI, a crash mid-run,
+ * a hand-edited record) otherwise pins the entry at whatever phase it was
+ * first registered with, forever.
+ *
+ * @param {Record<string, any>} entry
+ * @param {string} sessionDir
+ */
+function reconcileEntry(entry, sessionDir) {
+  let session;
+  try {
+    session = JSON.parse(fs.readFileSync(path.join(sessionDir, 'session.json'), 'utf8'));
+  } catch {
+    return false; // unreadable/absent — keep the cached view
+  }
+  let changed = false;
+  for (const key of MIRRORED_FIELDS) {
+    const value = session[key];
+    if (value === undefined) continue;
+    if (entry[key] !== value) {
+      entry[key] = value;
+      changed = true;
+    }
+  }
+  const pace = session.resolvedPace ?? session.pace ?? null;
+  if (pace !== null && entry.pace !== pace) {
+    entry.pace = pace;
+    changed = true;
+  }
+  return changed;
+}
+
+/**
+ * All registry entries, newest first. Self-heals: entries are reconciled
+ * against each session.json on disk; entries whose session dir vanished
+ * (cleanup ran without unregister, project deleted the .forge dir) are
+ * removed; entries whose whole project path is unreachable (unplugged drive)
+ * are kept and marked `missing`.
  *
  * @returns {Array<Record<string, any>>}
  */
@@ -156,6 +205,14 @@ export function listFleet() {
     }
     const sessionDir = path.join(entry.project, '.forge', 'sessions', entry.sessionId);
     if (fs.existsSync(sessionDir)) {
+      // Persist before stamping `missing`, which is a view flag, not state.
+      if (reconcileEntry(entry, sessionDir)) {
+        try {
+          fs.writeFileSync(file, `${JSON.stringify(entry, null, 2)}\n`, 'utf8');
+        } catch {
+          /* registry is advisory — a read-only registry still renders */
+        }
+      }
       entry.missing = false;
     } else if (fs.existsSync(entry.project)) {
       fs.rmSync(file, { force: true });

package/src/lib.mjs

@@ -7,8 +7,11 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { registerSession } from './lib/fleet.mjs';
+import { findRepoRoot } from './repo-root.mjs';
 
-export const REPO_ROOT = process.cwd();
+export { findRepoRoot };
+
+export const REPO_ROOT = findRepoRoot();
 export const FORGE_DIR = path.join(REPO_ROOT, '.forge');
 export const SESSIONS_DIR = path.join(FORGE_DIR, 'sessions');
 export const ACTIVE_FILE = path.join(FORGE_DIR, 'active.json');
@@ -137,7 +140,21 @@ export function saveSession(dir, session) {
   registerSession(path.resolve(dir, '..', '..', '..'), session);
 }
 
+/**
+ * Age of a session in days, for retention. Legacy and hand-written records
+ * carry `startedAt` (or nothing) instead of `createdAt`; an undatable record
+ * counts as **infinitely old** rather than brand new — `new Date(undefined)`
+ * is NaN and `NaN > RETENTION_DAYS` is false, which let abandoned sessions
+ * survive every cleanup run forever.
+ *
+ * @param {Record<string, any>} session
+ * @returns {number} days, or Infinity when no date can be read
+ */
 export function sessionAgeDays(session) {
-  const created = new Date(session.createdAt).getTime();
-  return (Date.now() - created) / (1000 * 60 * 60 * 24);
+  for (const value of [session?.createdAt, session?.startedAt, session?.updatedAt]) {
+    if (!value) continue;
+    const at = new Date(value).getTime();
+    if (!Number.isNaN(at)) return (Date.now() - at) / (1000 * 60 * 60 * 24);
+  }
+  return Infinity;
 }