pi-keyboard 0.1.2 → 0.1.3

package/features/keyboard.feature

@@ -96,6 +96,14 @@ Feature: Pi Keyboard Lighting Indicator
     Then the unread status is cleared
     And the keyboard state machine transitions to "thinking"
 
+  Scenario: Orphaned unread record from an unexpectedly-exited session is cleaned up
+    Given a session had an unread chat state and then exited unexpectedly (crash / kill)
+    And that session's process is no longer alive, leaving an orphaned unread record
+    When a new session starts and sweeps the registry
+    Then the orphaned unread record is removed
+    And it no longer contributes to the green unread light
+    And a live unread session still keeps its green light
+
   Scenario: Target lighting zone selection
     Given the user configures the target zone
     When the zone is set to "matrix"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-keyboard",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Dynamic VIA/QMK keyboard RGB lighting indicator reflecting Pi states (idle, thinking, unread, need-approval, error)",
   "author": "Frad LEE <fradser@gmail.com>",
   "license": "MIT",
@@ -36,4 +36,4 @@
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"
   }
-}
+}

package/src/global-sessions.ts

@@ -13,6 +13,10 @@ export interface SessionGlowRecord {
 }
 
 export function getRegistryDir(): string {
+  // Test seam: allow pointing at an isolated registry so tests never touch the
+  // real ~/.pi/agent/directory-sessions directory.
+  const override = process.env.PI_DIRECTORY_SESSIONS_DIR;
+  if (override) return override;
   return path.join(os.homedir(), ".pi", "agent", "directory-sessions");
 }
 
@@ -81,6 +85,57 @@ export function removeSessionGlowState(cwd: string, sessionId: string): void {
   }
 }
 
+/**
+ * Sweeps the whole registry and removes glow records whose owning process is no
+ * longer alive. Sessions that exit unexpectedly (crash, SIGKILL, terminal closed
+ * without a clean session_shutdown) never run removeSessionGlowState, so their
+ * leftover unread (settled) records would otherwise pile up and keep the green
+ * light on. Called at session start to clear that residue before evaluating.
+ *
+ * Deliberately cleans only dead-process records: a genuinely live session that
+ * is still unread keeps its glow record (and green light). No time-based expiry.
+ */
+export function pruneOrphanedGlowStates(): number {
+  const baseDir = getRegistryDir();
+  if (!fs.existsSync(baseDir)) return 0;
+
+  let removed = 0;
+  try {
+    const dirEntries = fs.readdirSync(baseDir, { withFileTypes: true });
+    for (const dirEntry of dirEntries) {
+      if (!dirEntry.isDirectory()) continue;
+      const subDirPath = path.join(baseDir, dirEntry.name);
+      let sessionFiles: string[] = [];
+      try {
+        sessionFiles = fs.readdirSync(subDirPath);
+      } catch {
+        continue;
+      }
+
+      for (const file of sessionFiles) {
+        if (!file.endsWith(".json")) continue;
+        const filePath = path.join(subDirPath, file);
+        try {
+          const content = fs.readFileSync(filePath, "utf-8");
+          const record = JSON.parse(content) as SessionGlowRecord;
+          if (!record || typeof record !== "object" || typeof record.pid !== "number") continue;
+          if (!isProcessAlive(record.pid)) {
+            try {
+              fs.unlinkSync(filePath);
+              removed++;
+            } catch {}
+          }
+        } catch {
+          // Ignore unreadable / non-glow files (all .json in the shared dir)
+        }
+      }
+    }
+  } catch {
+    // Best-effort sweep
+  }
+  return removed;
+}
+
 export interface GlobalStateSummary {
   effectiveState: KeyboardState;
   hasAnyUnread: boolean;

package/src/state-machine.ts

@@ -2,6 +2,7 @@ import crypto from "node:crypto";
 import { applyKeyboardState } from "./driver";
 import {
   evaluateGlobalLightingState,
+  pruneOrphanedGlowStates,
   removeSessionGlowState,
   writeSessionGlowState,
   type GlobalStateSummary,
@@ -114,6 +115,11 @@ export class KeyboardStateMachine {
     this.isProcessing = false;
     this.hasUnreadChat = false;
     this.hasFatalError = false;
+    // Clean up unread (settled) glow records left behind by sessions that exited
+    // unexpectedly (crash / kill / terminal closed). Without this their leftover
+    // unread would pile up and keep the green light on. Only dead-process records
+    // are removed; a live unread session keeps its glow state.
+    pruneOrphanedGlowStates();
     await this.syncAndEvaluate("idle");
   }