k0-board 0.4.0 → 0.5.0

package/server/watcher.js

@@ -27,18 +27,49 @@ export function transcriptPath(cwd, sessionId) {
 }
 
 /**
- * Changes the name of a session that has already ended, so that renaming a card makes the new
+ * Where the transcript of a session really is.
+ *
+ * Usually under the slug of the directory the session was started in — but a session that moved
+ * into a worktree writes under the worktree's slug from then on, and the story only knows the
+ * repository. So the hints are tried first, cheaply, and when none of them has the file the whole
+ * projects directory is read once: one `readdir` per rename, never on the per-second scan.
+ */
+export function findTranscript(sessionId, ...cwds) {
+  for (const cwd of cwds) {
+    if (!cwd) continue
+    const file = transcriptPath(cwd, sessionId)
+    if (fs.existsSync(file)) return file
+  }
+  let dirs
+  try {
+    dirs = fs.readdirSync(PROJECTS_DIR)
+  } catch {
+    return null
+  }
+  for (const d of dirs) {
+    const file = path.join(PROJECTS_DIR, d, `${sessionId}.jsonl`)
+    if (fs.existsSync(file)) return file
+  }
+  return null
+}
+
+/**
+ * Changes the name of a session that has already ended, so that renaming a story makes the new
  * name show up in the list of sessions you can resume.
  *
  * These are the two lines Claude Code writes for itself at the end of the transcript on every
  * turn, and the last one wins: all this does is write another copy.
  *
  * Only on a closed session: if the process is alive it holds the file open for appending and
- * would put the old name back on the next turn. There, the `-n` of Resume takes care of it.
+ * would put the old name back on the next turn. There, `/rename` typed into its window takes care
+ * of it — `renameLive` in launcher.js — and the `-n` of Resume does the rest.
+ *
+ * `story` is the flat row: the session's id, and the two places its transcript is likeliest to be.
  */
-export function renameSession(cwd, sessionId, name) {
-  const file = transcriptPath(cwd, sessionId)
-  if (!fs.existsSync(file)) return false
+export function renameSession(story, name) {
+  const sessionId = story.session_id
+  const file = findTranscript(sessionId, story.work_path, story.project_path)
+  if (!file) return false
   const line = (o) => JSON.stringify({ ...o, sessionId }) + '\n'
   fs.appendFileSync(
     file,
@@ -162,6 +193,22 @@ export function forgetSession(sessionId) {
   scans.delete(sessionId)
 }
 
+/**
+ * Lets go of every session that is not running any more.
+ *
+ * `forgetSession` above is the deliberate goodbye — a story deleted, a terminal closed by hand —
+ * and a session that simply ends is none of those, so nothing ever said goodbye to it. One entry
+ * stayed behind per session this server had ever watched, each holding the tail of a transcript
+ * and the tools it was waiting on; on a board that has seen a few hundred of them, that was most
+ * of what the process was holding on to at rest. It had grown to 479 against 11 really alive.
+ *
+ * Losing the offset of a session that comes back is not a loss: the next scan reads the file from
+ * the top, which is what the first scan of any session does anyway.
+ */
+export function forgetDeadSessions(alive) {
+  for (const sessionId of scans.keys()) if (!alive.has(sessionId)) scans.delete(sessionId)
+}
+
 /**
  * Something is really running behind this status. It is the one question two different places
  * ask: whether a status that survives the death of a process would be a lie, and whether a
@@ -170,23 +217,30 @@ export function forgetSession(sessionId) {
 export const busy = (status) => status === 'WORKING' || status === 'PLANNING'
 
 /**
- * Translates Claude Code's signals into the board's statuses.
+ * Translates Claude Code's signals into the board's five live statuses.
  * Returns { status, alive }.
+ *
+ * Five, not seven: `BACKLOG` and `COMPLETED` were never things a session does — one means the
+ * story has no session at all, the other means you have ticked it off — and they are the story's
+ * business now, on the other axis. What is left here is what the process is actually doing.
  */
-export function deriveStatus(card, live) {
-  if (card.completed_at) return { status: 'COMPLETED', alive: false }
-  if (!card.session_id) return { status: 'BACKLOG', alive: false }
+export function deriveStatus(story, live) {
+  // Ticked off. The terminal was closed when you said Done, so whatever the session was in the
+  // middle of, it is not in the middle of it any more — and until the process really goes, the
+  // post-it must not go on breathing.
+  if (story.completed_at) return { status: story.session_status || 'IDLE', alive: false }
+  if (!story.session_id) return { status: story.session_status || 'IDLE', alive: false }
 
-  const session = live.get(card.session_id)
+  const session = live.get(story.session_id)
   if (!session) {
     // Process dead: the session can still be resumed. We keep the last status only if it said
     // something about you (an open question, a plan left sitting there); WORKING and PLANNING
     // would be a lie, nothing is grinding away any more.
-    const stale = busy(card.status) || card.status === 'BACKLOG'
-    return { status: stale ? 'IDLE' : card.status, alive: false }
+    const last = story.session_status || 'IDLE'
+    return { status: busy(last) ? 'IDLE' : last, alive: false }
   }
 
-  const t = scanTranscript(session.cwd || card.project_path, card.session_id)
+  const t = scanTranscript(session.cwd || story.project_path, story.session_id)
 
   switch (session.status) {
     case 'busy':