fix(scheduler): keep cacheRemainingMs JSON-safe and restore invalid-TTL diagnostics

- rpc-handlers: the cacheNeverExpires branch assigned Infinity to
  cacheRemainingMs; JSON.stringify converts Infinity to null over RPC,
  violating the numeric StatusDetail contract. Use 0 and let the
  cacheNeverExpires flag carry the semantics (the TUI keys on it first).
- computeHardCacheExpired: the extraction dropped the
  invalid-cache-ttl-fallback pass outcome and session log on parse
  failure. Add an onInvalid callback; the transform call site restores
  the exact pre-extraction record + log.
- test: seed last_response_time in the never-TTL status test — the
  guarded branch only runs when lastResponseTime > 0, so the assertion
  was vacuous without it (verified red: Infinity revert now fails it).

Author: Tehan

packages/plugin/src/hooks/magic-context/transform-context-state.test.ts

@@ -163,4 +163,39 @@ describe("computeHardCacheExpired", () => {
         const sixMinutesAgo = now - 6 * 60 * 1000;
         expect(computeHardCacheExpired("garbage", sixMinutesAgo, now)).toBe(true);
     });
+
+    it("invokes onInvalid callback for invalid TTL but not for valid ones", () => {
+        const now = Date.now();
+        const tenDaysAgo = now - 10 * 24 * 60 * 60 * 1000;
+        const invalidErrors: unknown[] = [];
+
+        // Invalid TTL: callback fires + 5m fallback applied
+        const result = computeHardCacheExpired("bad-format", tenDaysAgo, now, (error) => {
+            invalidErrors.push(error);
+        });
+        expect(invalidErrors.length).toBe(1);
+        expect(invalidErrors[0]).toBeInstanceOf(Error);
+        expect(result).toBe(true); // 5m fallback, 10-day-old → expired
+
+        // Valid TTLs: callback NOT invoked
+        const validErrors: unknown[] = [];
+        computeHardCacheExpired("never", tenDaysAgo, now, (error) => {
+            validErrors.push(error);
+        });
+        expect(validErrors.length).toBe(0);
+
+        computeHardCacheExpired("5m", tenDaysAgo, now, (error) => {
+            validErrors.push(error);
+        });
+        expect(validErrors.length).toBe(0);
+    });
+
+    it("omitting onInvalid is harmless (5m fallback still applies)", () => {
+        const now = Date.now();
+        const tenDaysAgo = now - 10 * 24 * 60 * 60 * 1000;
+        // No callback — should not throw, should still fall back to 5m
+        expect(computeHardCacheExpired("bad-format", tenDaysAgo, now)).toBe(true);
+        // "never" with no callback still works
+        expect(computeHardCacheExpired("never", tenDaysAgo, now)).toBe(false);
+    });
 });

packages/plugin/src/hooks/magic-context/transform.ts

@@ -242,16 +242,21 @@ export function __getMessageTokensCacheForTest(
  *
  * Returns false when cacheTtl is "never" (Infinity) because any finite
  * elapsed time is < Infinity.
+ *
+ * @param onInvalid Optional callback invoked when cacheTtl fails to parse;
+ *        the 5m fallback is applied AFTER the callback returns.
  */
 export function computeHardCacheExpired(
     cacheTtl: string,
     lastResponseTime: number,
     now: number,
+    onInvalid?: (error: unknown) => void,
 ): boolean {
     let ttlMs: number;
     try {
         ttlMs = parseCacheTtl(cacheTtl);
-    } catch {
+    } catch (error) {
+        onInvalid?.(error);
         ttlMs = 5 * 60 * 1000;
     }
     return lastResponseTime > 0 && now - lastResponseTime >= ttlMs;
@@ -1896,6 +1901,10 @@ export function createTransform(deps: TransformDeps) {
             sessionMeta.cacheTtl,
             sessionMeta.lastResponseTime,
             Date.now(),
+            (error) => {
+                passOutcome.record("invalid-cache-ttl-fallback");
+                sessionLog(sessionId, "invalid cache_ttl; using the 5m default:", error);
+            },
         );
         const m0HardSignals = {
             systemHash: hardSystemHash,

packages/plugin/src/plugin/rpc-handlers.test.ts

@@ -331,15 +331,23 @@ describe("buildStatusDetail — cacheNeverExpires with 'never' TTL", () => {
 
             // Force-create the session meta row so the UPDATE lands on an existing row.
             db.prepare(`INSERT INTO session_meta (session_id) VALUES (?)`).run(sessionId);
-            db.prepare("UPDATE session_meta SET cache_ttl = ? WHERE session_id = ?").run(
-                "never",
-                sessionId,
-            );
+            // Seed last_response_time: the cacheNeverExpires branch only runs
+            // inside `if (lastResponseTime > 0)` — without this the test would
+            // pass even if Infinity leaked into cacheRemainingMs.
+            db.prepare(
+                "UPDATE session_meta SET cache_ttl = ?, last_response_time = ? WHERE session_id = ?",
+            ).run("never", Date.now() - 60_000, sessionId);
 
             const detail = buildStatusDetail(db, sessionId, directory);
 
             expect(detail.cacheNeverExpires).toBe(true);
             expect(detail.cacheExpired).toBe(false);
+            // Infinity must NOT leak into the numeric RPC field — JSON.stringify
+            // converts Infinity to null, violating the StatusDetail contract.
+            expect(detail.cacheRemainingMs).toBe(0);
+            const roundTripped = JSON.parse(JSON.stringify(detail));
+            expect(roundTripped.cacheRemainingMs).toBe(0);
+            expect(roundTripped.cacheRemainingMs).not.toBeNull();
         } finally {
             closeQuietly(db);
         }

packages/plugin/src/plugin/rpc-handlers.ts

@@ -703,7 +703,10 @@ export function buildStatusDetail(
         if (detail.lastResponseTime > 0) {
             const elapsed = Date.now() - detail.lastResponseTime;
             if (detail.cacheNeverExpires) {
-                detail.cacheRemainingMs = Number.POSITIVE_INFINITY;
+                // Infinity does not survive JSON-RPC; cacheNeverExpires is the
+                // authoritative flag — the TUI keys on it first.
+                detail.cacheRemainingMs = 0;
+                detail.cacheExpired = false;
             } else {
                 detail.cacheRemainingMs = Math.max(0, detail.cacheTtlMs - elapsed);
                 detail.cacheExpired = detail.cacheRemainingMs === 0;