@link-assistant/hive-mind 2.0.2 → 2.0.4

package/CHANGELOG.md

@@ -1,5 +1,143 @@
 # @link-assistant/hive-mind
 
+## 2.0.4
+
+### Patch Changes
+
+- f1f9b10: fix(telegram): detect OOM/SIGKILL-ed detached sessions and resume tracking after a bot restart (#1927)
+
+  A `/solve` running in a detached `screen` session was OOM-killed (exit `137`),
+  but the Telegram bot stayed alive and **never reported the failure** — the job
+  silently hung forever. Two compounding gaps caused this:
+
+  **Root cause (RC-1, upstream).** The external `start-command` CLI's
+  `enrichDetachedStatus` re-derives a detached session's status from backend
+  liveness (`screen -ls`). When a shell lingers after the wrapped command is
+  already dead, `$ <id> --status` flips an already-completed record
+  (`status: executed`, `exitCode: 137`) **back to `executing` and nulls the exit
+  code**, even though `start` itself wrote an authoritative `Exit Code: 137` footer
+  to the log. The bot's monitor only reacts to a _terminal_ status, so the kill is
+  never surfaced. Confirmed against upstream source and filed with a runnable repro
+  as [link-foundation/start#134](https://github.com/link-foundation/start/issues/134)
+  (a regression of the fix for upstream #60/#101).
+
+  **Root cause (RC-2/3/4).** The session monitor's registry was in-memory only, so
+  a bot restart orphaned every detached `/solve`; there was no "last alive" marker
+  to bound what to resume; and the bot log could be overwritten on restart,
+  destroying the evidence needed to reconstruct the failure.
+
+  **Fix (defensive, consumer side — correct regardless of when upstream lands):**
+  - **`src/session-status.lib.mjs`** — a shared, dependency-free status vocabulary
+    (`RUNNING`/`KILLED`/`FAILURE`, signal classification for 137/143/139/130) so
+    every call site agrees on what an exit code means.
+  - **`src/isolation-runner.lib.mjs`** — `parseSessionExitFooter` /
+    `readSessionExitFromLog` read the **authoritative log footer**, plus
+    `checkBackendSessionAlive` / `isSessionRunning` probe the real backend.
+  - **`src/session-monitor.lib.mjs`** — when `--status` says `executing`, cross-check
+    the footer (authoritative) and a backend-liveness probe gated by a 90s minimum
+    session age, so a SIGKILL is reported instead of hanging, while a just-started
+    session is never misread.
+  - **`src/session-store.lib.mjs`** — durable session registry (atomic
+    `sessions.json` snapshot + append-only, never-truncated `sessions-events.jsonl`)
+    so a restart can **resume** tracking and finally report sessions killed while
+    the bot was down — resuming only sessions started **before** the bot's start
+    time.
+  - **`src/bot-logger.lib.mjs`** — every log line is prefixed with an ISO-8601
+    millisecond timestamp; structured `event()`/`heartbeat()` markers record "last
+    alive"; logs **rotate, never overwrite** (prior log preserved as a timestamped
+    backup) so no evidence is destroyed.
+  - **`src/bot-lifecycle.lib.mjs`** — heartbeat / resume-on-launch / orderly
+    shutdown extracted from `telegram-bot.mjs` as pure injectable factories; a
+    timestamped `bot_shutdown` marker distinguishes a clean stop from a hard kill.
+  - **`src/work-session-formatting.lib.mjs`** + `telegram-bot.mjs` — completion
+    messages now call out a **killed** outcome (❌ killed / signal) distinctly from
+    an ordinary failure.
+  - **`src/telegram-terminal-watch-command.lib.mjs`** — the same fix applied to the
+    live `/terminal_watch` loop (req #8, "fix in all places"): it decided
+    "completed" purely from `--status`, so a session killed while `--status` still
+    read `executing` would be **polled forever** with a misleading "running"
+    snapshot — the #1927 silent-hang, in the watch path. It now cross-checks the
+    authoritative log footer (`reconcileWatchCompletion`), stops on a recorded exit,
+    corrects the displayed status to the real terminal one (e.g. `killed`), and a
+    completed-but-failed session renders a ❌ failure title instead of a ✅.
+  - **`src/cleanup.os.lib.mjs`** + `src/cleanup.lib.mjs` — review follow-up:
+    deduplicated `$` session-data access (cleanup no longer re-derives sessions
+    from `screen -ls`/`tmux ls` + per-session `$ --status`; a single
+    `listSessionTasks()` reads the whole catalog from `$ --list`, the same source
+    `/queue`, `/limits` and the monitor already funnel through), and the cleanup
+    listing now annotates **every** hive-mind folder — active _and_ finished — with
+    which PR/issue and which session it belongs (or belonged) to.
+  - **`src/session-resume.lib.mjs`** — review follow-up: when a detached `/solve`
+    is killed, the surviving parent (the bot, or `/hive`) now surfaces a
+    ready-to-run `solve <url> … --resume <lastSessionId>` command in the
+    killed-session notification. A single `/solve` run prints many `Session ID:`
+    markers (auto-continue, watch restarts, manual resume chains); the module reads
+    the **last** marker from the log tail (`selectLastSessionId` /
+    `readLastSessionIdFromLog`), with a filesystem fallback
+    (`findLatestSessionLogId`). The bot deliberately **surfaces** the command rather
+    than auto-relaunching (a job that reliably OOMs would storm);
+    `planKilledSessionResume` bounds any automatic resume (default `maxAttempts: 1`).
+    The section is additive (existing `extraSections` path), emitted only for
+    `killed` `/solve` sessions, and failure-isolated so it can never break the
+    notification. `args` was added to the persisted session fields so the resume
+    command reproduces the original invocation exactly.
+
+  A `verbose` flag is threaded through the new status/footer/liveness/resume paths
+  with explicit `[VERBOSE]` tracing so the next failure leaves a trail (req #6).
+
+  Added `tests/test-issue-1927-*.mjs` (9 suites, 266 assertions: status vocabulary,
+  log-footer parsing, completion labeling, killed-detection, session store, resume,
+  bot logger, bot lifecycle, terminal-watch kill). Full deep-dive in
+  `docs/case-studies/issue-1927`
+  (timeline, 8 requirements, 5 root causes, per-requirement solutions, preserved
+  source artifacts), plus a runnable upstream repro under `experiments/`.
+
+## 2.0.3
+
+### Patch Changes
+
+- 40fbf3d: fix(isolation): mount git identity into docker-isolated containers and stop trusting premature terminal status (#1939)
+
+  A `solve` task launched with `--isolation docker` inside a Docker-in-Docker host
+  (`konard/hive-mind-dind:2.0.2`) failed at the system-check stage with
+  `❌ Git identity not configured`, even though `gh` was fully authenticated
+  (account `konard`). The captured terminal log shows the native start-command
+  (`$`) invocation mounting only `~/.config/gh`, `~/.claude`, and `~/.claude.json`
+  — **no git identity** — so `git config user.name`/`user.email` were unset inside
+  the container and `solve` aborted before doing any work.
+
+  Root cause: `getDockerIsolationAuthMounts` (`src/isolation-runner.lib.mjs`)
+  mounted `gh` and the per-tool credentials but never the git identity. `gh`
+  authentication is not a git identity. The fix mounts the host git identity
+  (`~/.gitconfig` and the XDG `~/.config/git`, honoring `GIT_CONFIG_GLOBAL` /
+  `XDG_CONFIG_HOME`) for **every** tool, alongside `gh`, so the fix applies to all
+  isolation callers at once. A new self-healing preflight,
+  `ensureHostGitIdentityForIsolation`, gives the mount something to mount: when the
+  host has no git identity it derives one from the authenticated `gh` account
+  (`gh-setup-git-identity` / `repairGitIdentity`) and, if that is impossible, emits
+  one actionable warning naming the exact downstream failure.
+
+  The same run also exposed a second problem: `$ --list` reported the detached
+  session as `status executed` with `exitCode -1` (and no `containerId`) while the
+  container was still running, masking the live container and its real exit code.
+  `isUnknownDockerExitCode` plus a docker-only cross-check in `isSessionRunning`
+  and `getIsolationSessionState` (`src/session-monitor.lib.mjs`) keep an ambiguous
+  `terminal + -1` docker session "running" until `docker inspect` confirms the
+  container has actually exited; real exit codes and non-docker backends are
+  unaffected. A verbose post-launch diagnostic now records `$ --status`, container
+  state, and local image presence so the next iteration can confirm the premature
+  status and the image re-pull from data.
+
+  The premature-terminal-status behaviour was reported upstream to
+  link-foundation/start and fixed there in `start-command@0.29.1`
+  (link-foundation/start#136); `Dockerfile` and `Dockerfile.dind` now pin
+  `start-command@0.29.1` so the fixed `$` binary ships in the images, while the
+  downstream cross-check stays as defense-in-depth for older hosts.
+
+  Added `tests/test-issue-1939-docker-isolation.mjs` (25 assertions) and a full
+  case study with timeline, root-cause analysis, and the captured logs under
+  `docs/case-studies/issue-1939`.
+
 ## 2.0.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/bot-lifecycle.lib.mjs

@@ -0,0 +1,128 @@
+/**
+ * Bot lifecycle helpers extracted from telegram-bot.mjs (issue #1927).
+ *
+ * These three concerns — a periodic liveness heartbeat, resuming tracked
+ * sessions on launch, and an orderly shutdown that records a final timestamped
+ * marker — were inline in the bot entrypoint, where they could not be unit
+ * tested and pushed the file toward the 1500-line limit (see issue #1593). They
+ * are pure factories here: every external dependency (logger, clock, process,
+ * console, timer) is injected, so production wiring stays identical while the
+ * behaviour is exercised directly by tests.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1927
+ */
+
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 60 * 1000;
+
+/**
+ * Periodic timestamped heartbeat (requirements #3/#4).
+ *
+ * Writes a heartbeat line on a fixed interval so the "last time the bot was
+ * alive" is always discoverable from the log, even when nothing else happens.
+ * That marker is what a later restart uses to decide which sessions were running
+ * when the bot was last alive. The beat is wrapped so a logging failure can never
+ * crash the bot, and the interval is unref'd so it never keeps the process alive
+ * on its own.
+ *
+ * @returns {{ start: () => void, stop: () => void, beat: () => void, get timer(): any }}
+ */
+export function createHeartbeat({ logger, getActiveSessionCount, intervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS, processImpl = process, setIntervalImpl = setInterval, clearIntervalImpl = clearInterval } = {}) {
+  let timer = null;
+
+  const beat = () => {
+    try {
+      logger.heartbeat({
+        activeSessions: typeof getActiveSessionCount === 'function' ? getActiveSessionCount(false) : undefined,
+        uptimeSec: Math.floor(processImpl.uptime()),
+      });
+    } catch {
+      /* heartbeat must never crash the bot */
+    }
+  };
+
+  return {
+    start() {
+      if (timer) return;
+      timer = setIntervalImpl(beat, intervalMs);
+      if (timer && typeof timer.unref === 'function') timer.unref();
+      beat();
+    },
+    stop() {
+      if (timer) {
+        clearIntervalImpl(timer);
+        timer = null;
+      }
+    },
+    beat,
+    get timer() {
+      return timer;
+    },
+  };
+}
+
+/**
+ * Resume sessions left tracked by a previous run (requirements #2/#4).
+ *
+ * After a restart, reload sessions that were still being tracked when the
+ * previous process died and re-register them so the monitor resumes watching —
+ * and finally reports any that were killed while the bot was down. Logs a
+ * `sessions_resumed` event either way and never throws: a resume failure must
+ * not stop the bot from coming up.
+ *
+ * @returns {Promise<{ resumed: any[], skipped: any[], error?: Error }>}
+ */
+export async function resumeSessionsOnLaunch({ resumeTrackedSessions, botStartTime, verbose = false, logger, consoleImpl = console } = {}) {
+  try {
+    const { resumed, skipped } = await resumeTrackedSessions({ botStartTime, verbose });
+    if (resumed.length > 0) {
+      consoleImpl.log(`♻️  Resumed ${resumed.length} session(s) from previous run`);
+    }
+    logger.event('sessions_resumed', {
+      resumed: resumed.length,
+      skipped: skipped.length,
+      sessions: resumed.map(r => r.sessionName),
+    });
+    return { resumed, skipped };
+  } catch (error) {
+    consoleImpl.error(`[telegram-bot] Failed to resume tracked sessions: ${error.message}`);
+    logger.error('Failed to resume tracked sessions', { error: error.message });
+    return { resumed: [], skipped: [], error };
+  }
+}
+
+/**
+ * Build the shutdown signal handler (requirement #3).
+ *
+ * Records a `bot_shutdown` event (with a timestamp) so the log shows the bot
+ * stopped cleanly — the ABSENCE of this line before the next startup is exactly
+ * how a later analysis tells an orderly stop apart from a hard kill. The
+ * mutation of module state (the `isShuttingDown` flag, aborting the launch
+ * controller, clearing timers, stopping the queue) stays with the caller via the
+ * injected `onShutdown` / `cleanup` closures, so the timer references live where
+ * they are created. Neither logging nor cleanup is allowed to block `bot.stop`.
+ *
+ * @returns {(signal: string) => void}
+ */
+export function createShutdownHandler({ logger, getActiveSessionCount, verbose = false, onShutdown, cleanup, bot, processImpl = process, consoleImpl = console } = {}) {
+  return function handleShutdownSignal(signal) {
+    if (typeof onShutdown === 'function') onShutdown();
+    try {
+      logger.event('bot_shutdown', {
+        signal,
+        pid: processImpl.pid,
+        ppid: processImpl.ppid,
+        activeSessions: typeof getActiveSessionCount === 'function' ? getActiveSessionCount(false) : undefined,
+        uptimeSec: Math.floor(processImpl.uptime()),
+      });
+    } catch {
+      /* a logging failure must never block shutdown */
+    }
+    if (verbose) consoleImpl.log(`[VERBOSE] Signal: ${signal}, PID: ${processImpl.pid}, PPID: ${processImpl.ppid}`);
+    try {
+      if (typeof cleanup === 'function') cleanup();
+    } catch {
+      /* cleanup is best-effort during shutdown */
+    }
+    if (bot && typeof bot.stop === 'function') bot.stop(signal);
+  };
+}

package/src/bot-logger.lib.mjs

@@ -0,0 +1,253 @@
+/**
+ * Durable, timestamped logger for the Telegram bot.
+ *
+ * Issue #1927: when a detached /solve session was OOM-killed (exit 137) the bot
+ * stayed alive but never reported the failure, and there was NO bot log file to
+ * reconstruct what happened — only ephemeral console output that scrolled away.
+ * Requirements #3 and #4 of that issue ask for:
+ *
+ *   - Every log line carries a timestamp, so the exact moment of a total failure
+ *     (process killed mid-write) can be located afterwards.
+ *   - Previous bot logs are never destroyed. A restart must not overwrite the
+ *     log of the run that was killed — that log is the only evidence of when the
+ *     bot was last alive, which gates which sessions we try to resume.
+ *
+ * This module mirrors every line to the console (so existing behaviour and
+ * `journalctl`/screen capture are unchanged) AND appends it to a rotating log
+ * file. On startup the previous active log is preserved under a timestamped
+ * backup name instead of being overwritten, and oversized logs rotate the same
+ * way mid-run. Backups are pruned only down to a generous configurable cap.
+ *
+ * The logger is intentionally dependency-free (node:fs/node:path only) and fully
+ * injectable so it can be unit-tested without touching the real filesystem.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1927
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+
+const DEFAULT_MAX_BYTES = 10 * 1024 * 1024; // 10 MiB per active file before rotating
+const DEFAULT_MAX_BACKUPS = 100; // keep up to 100 rotated logs (newest wins on prune)
+
+/**
+ * Resolve the directory bot logs are written to. Honors HIVE_MIND_LOG_DIR, then
+ * the start-command log root, then a stable per-user fallback. Never throws.
+ *
+ * @param {object} [env=process.env]
+ * @param {Function} [homedir=os.homedir]
+ * @returns {string} Absolute directory path
+ */
+export function resolveBotLogDir(env = process.env, homedir = os.homedir) {
+  const explicit = String(env.HIVE_MIND_LOG_DIR || '').trim();
+  if (explicit) return explicit;
+  const home = (() => {
+    try {
+      return homedir();
+    } catch {
+      return '/tmp';
+    }
+  })();
+  return path.join(home, '.hive-mind', 'logs');
+}
+
+/**
+ * Build the timestamp prefix used on every line: ISO 8601 with milliseconds.
+ * @param {Date} date
+ * @returns {string}
+ */
+export function formatLogTimestamp(date) {
+  try {
+    return date.toISOString();
+  } catch {
+    return new Date(0).toISOString();
+  }
+}
+
+/**
+ * Turn an ISO timestamp into a filesystem-safe token (no colons) so it can be
+ * embedded in a backup filename on every platform.
+ * @param {Date} date
+ * @returns {string}
+ */
+function fileStamp(date) {
+  return formatLogTimestamp(date).replace(/[:.]/g, '-');
+}
+
+function serializeMeta(meta) {
+  if (meta === undefined || meta === null) return '';
+  if (typeof meta === 'string') return meta ? ` ${meta}` : '';
+  try {
+    const json = JSON.stringify(meta, (_key, value) => (typeof value === 'bigint' ? value.toString() : value));
+    return json && json !== '{}' ? ` ${json}` : '';
+  } catch {
+    return ` ${String(meta)}`;
+  }
+}
+
+/**
+ * Format a single structured log line (without trailing newline).
+ * Shape: `<ISO> <LEVEL> <message> <json-meta?>`
+ *
+ * @param {string} level
+ * @param {string} message
+ * @param {*} [meta]
+ * @param {Date} [date]
+ * @returns {string}
+ */
+export function formatLogLine(level, message, meta, date = new Date()) {
+  const lvl = String(level || 'info')
+    .toUpperCase()
+    .padEnd(5);
+  return `${formatLogTimestamp(date)} ${lvl} ${message}${serializeMeta(meta)}`;
+}
+
+/**
+ * Create a durable bot logger.
+ *
+ * @param {object} [options]
+ * @param {string} [options.dir] - Directory for log files (default: resolveBotLogDir()).
+ * @param {string} [options.baseName='telegram-bot'] - Base file name (without extension).
+ * @param {number} [options.maxBytes] - Rotate the active file once it exceeds this size.
+ * @param {number} [options.maxBackups] - Keep at most this many rotated backups.
+ * @param {boolean} [options.mirrorConsole=true] - Also write each line to console.
+ * @param {boolean} [options.verbose=false] - Emit debug-level lines (otherwise suppressed).
+ * @param {boolean} [options.rotateOnStart=true] - Preserve a previous active log on startup.
+ * @param {object} [options.fsImpl=fs] - Injectable fs (for tests).
+ * @param {Function} [options.now] - Injectable clock returning a Date (for tests).
+ * @param {object} [options.consoleImpl=console] - Injectable console (for tests).
+ * @returns {object} Logger instance.
+ */
+export function createBotLogger(options = {}) {
+  const { dir = resolveBotLogDir(), baseName = 'telegram-bot', maxBytes = DEFAULT_MAX_BYTES, maxBackups = DEFAULT_MAX_BACKUPS, mirrorConsole = true, verbose = false, rotateOnStart = true, fsImpl = fs, now = () => new Date(), consoleImpl = console } = options;
+
+  const activePath = path.join(dir, `${baseName}.log`);
+  let fileDisabled = false; // set if the filesystem is unusable; console still works
+
+  function ensureDir() {
+    try {
+      fsImpl.mkdirSync(dir, { recursive: true });
+      return true;
+    } catch (error) {
+      if (!fileDisabled) {
+        consoleImpl.error(`[bot-logger] Could not create log dir ${dir}: ${error.message} — file logging disabled, console only`);
+      }
+      fileDisabled = true;
+      return false;
+    }
+  }
+
+  function backupName(date) {
+    return path.join(dir, `${baseName}-${fileStamp(date)}.log`);
+  }
+
+  // Preserve the previous run's log instead of overwriting it (requirement #4).
+  function rotateExisting(reason) {
+    try {
+      if (!fsImpl.existsSync(activePath)) return;
+      const stat = fsImpl.statSync(activePath);
+      if (!stat || stat.size === 0) return;
+      let target = backupName(now());
+      // Avoid clobbering an existing backup created within the same millisecond.
+      let suffix = 1;
+      while (fsImpl.existsSync(target)) {
+        target = path.join(dir, `${baseName}-${fileStamp(now())}-${suffix}.log`);
+        suffix += 1;
+      }
+      fsImpl.renameSync(activePath, target);
+      if (verbose) consoleImpl.log(`[bot-logger] Rotated previous log to ${target} (${reason})`);
+      pruneBackups();
+    } catch (error) {
+      consoleImpl.error(`[bot-logger] Log rotation failed (${reason}): ${error.message}`);
+    }
+  }
+
+  function pruneBackups() {
+    if (!Number.isFinite(maxBackups) || maxBackups < 0) return; // unbounded: never destroy
+    try {
+      const entries = fsImpl
+        .readdirSync(dir)
+        .filter(name => name.startsWith(`${baseName}-`) && name.endsWith('.log'))
+        .sort(); // timestamped names sort chronologically
+      const excess = entries.length - maxBackups;
+      for (let i = 0; i < excess; i++) {
+        try {
+          fsImpl.unlinkSync(path.join(dir, entries[i]));
+        } catch {
+          /* best effort */
+        }
+      }
+    } catch {
+      /* best effort */
+    }
+  }
+
+  if (ensureDir() && rotateOnStart) {
+    rotateExisting('startup');
+  }
+
+  function appendLine(line) {
+    if (fileDisabled) return;
+    try {
+      // Size-based rotation: keep the active file bounded mid-run while never
+      // destroying data (the oversized file becomes a timestamped backup).
+      let size = 0;
+      try {
+        size = fsImpl.statSync(activePath).size;
+      } catch {
+        size = 0;
+      }
+      if (size > 0 && size + line.length + 1 > maxBytes) {
+        rotateExisting('size');
+      }
+      fsImpl.appendFileSync(activePath, line + '\n');
+    } catch (error) {
+      if (!fileDisabled) {
+        consoleImpl.error(`[bot-logger] Could not write log line: ${error.message} — file logging disabled`);
+      }
+      fileDisabled = true;
+    }
+  }
+
+  function emit(level, message, meta) {
+    if (level === 'debug' && !verbose) return;
+    const date = now();
+    const line = formatLogLine(level, message, meta, date);
+    appendLine(line);
+    if (mirrorConsole) {
+      const sink = level === 'error' ? consoleImpl.error : level === 'warn' ? consoleImpl.warn : consoleImpl.log;
+      sink(line);
+    }
+  }
+
+  return {
+    /** Absolute path of the active log file. */
+    get filePath() {
+      return activePath;
+    },
+    /** Absolute directory holding the active + backup logs. */
+    get dir() {
+      return dir;
+    },
+    /** True when file writes have been disabled (console still works). */
+    get fileDisabled() {
+      return fileDisabled;
+    },
+    debug: (message, meta) => emit('debug', message, meta),
+    info: (message, meta) => emit('info', message, meta),
+    warn: (message, meta) => emit('warn', message, meta),
+    error: (message, meta) => emit('error', message, meta),
+    /**
+     * Record a structured lifecycle/session event. `type` is uppercased into the
+     * message so events are greppable (e.g. `grep ' EVENT session_killed '`).
+     */
+    event: (type, data) => emit('info', `EVENT ${type}`, data),
+    /** Record a heartbeat marker so the last-active time is always discoverable. */
+    heartbeat: data => emit('info', 'EVENT heartbeat', { pid: process.pid, ...data }),
+    /** Re-export of the formatter for callers that need raw lines. */
+    formatLine: formatLogLine,
+  };
+}

package/src/cleanup.lib.mjs

@@ -17,7 +17,7 @@
  * @see https://github.com/link-assistant/hive-mind/issues/1848
  */
 
-import { isValidIssueBranchName } from './solve.branch.lib.mjs';
+import { isValidIssueBranchName, parseIssueBranchName } from './solve.branch.lib.mjs';
 
 /**
  * Directory names directly under the tmp root that must never be removed by
@@ -296,12 +296,17 @@ export function classifyEntry(entry, ctx) {
 export function classifyEntries(entries, ctx) {
   const keep = [];
   const remove = [];
-  const { matchers = [], gitInfoByPath = new Map() } = ctx || {};
+  const { matchers = [], sessionMatchers = [], gitInfoByPath = new Map() } = ctx || {};
   for (const entry of entries || []) {
     const { action, reason } = classifyEntry(entry, ctx);
     const gitInfo = gitInfoByPath.get(entry.path) || null;
     const activeTask = reason === 'active-task' ? folderMatchesActiveTask(gitInfo, matchers) : null;
-    const record = { name: entry.name, path: entry.path, size: entry.size ?? null, reason, gitInfo, activeTask };
+    // For folders that are NOT an active task, look up the (possibly finished)
+    // session this folder once belonged to so the listing can still report its
+    // PR and session id — issue #1927 review: "also for non active tasks to
+    // which pull request and to which session it was belonging."
+    const session = activeTask ? null : folderMatchesActiveTask(gitInfo, sessionMatchers);
+    const record = { name: entry.name, path: entry.path, size: entry.size ?? null, reason, gitInfo, activeTask, session };
     if (action === 'remove') remove.push(record);
     else keep.push(record);
   }
@@ -399,7 +404,13 @@ export function formatTaskSummary(task) {
  */
 export function formatEntryContext(item) {
   const details = [];
-  if (item?.activeTask) details.push(`task ${formatTaskSummary(item.activeTask)}`);
+  if (item?.activeTask) {
+    details.push(`task ${formatTaskSummary(item.activeTask)}`);
+  } else if (item?.session) {
+    // A finished (or otherwise non-active) folder still tells us which PR/issue
+    // and session it belonged to — render it with a "was" prefix.
+    details.push(`was ${formatTaskSummary(item.session)}`);
+  }
 
   const gitInfo = item?.gitInfo;
   if (gitInfo) {
@@ -408,6 +419,13 @@ export function formatEntryContext(item) {
     if (remote) gitParts.push(`repo ${remote.owner}/${remote.repo}`);
     if (gitInfo.branch) gitParts.push(`branch ${gitInfo.branch}`);
     if (gitInfo.dirty) gitParts.push('dirty/unpushed');
+    // When neither an active task nor a known session resolved the issue/PR,
+    // derive the issue number from the folder's branch so every hive-mind
+    // folder in the listing still shows which issue it belongs to.
+    if (!item?.activeTask && !item?.session && gitInfo.branch) {
+      const parsed = parseIssueBranchName(gitInfo.branch);
+      if (parsed) gitParts.push(`issue #${parsed.issueNumber}`);
+    }
     if (gitParts.length > 0) details.push(gitParts.join(', '));
   }
 

package/src/cleanup.mjs

@@ -36,7 +36,7 @@ import { promises as fsp } from 'node:fs';
 
 import { isConfirmationYes, readConfirmationLine } from './confirmation.lib.mjs';
 import { classifyEntries, summarize, formatBytes, describeReason, buildActiveMatchers, DEFAULT_PROTECTED_NAMES, formatEntryContext, formatTaskSummary } from './cleanup.lib.mjs';
-import { getTempRoot, listTempEntries, getPathSize, readFolderGitInfo, listProcessHeldPaths, getActiveTasks, removePath, runSystemCleanup, collectProcessDebugReport, signalOrphanedAgentTrees } from './cleanup.os.lib.mjs';
+import { getTempRoot, listTempEntries, getPathSize, readFolderGitInfo, listProcessHeldPaths, getActiveTasks, listSessionTasks, removePath, runSystemCleanup, collectProcessDebugReport, signalOrphanedAgentTrees } from './cleanup.os.lib.mjs';
 import { formatProcessDebugReport } from './process-debug.lib.mjs';
 
 const args = process.argv.slice(2);
@@ -238,9 +238,21 @@ async function main() {
   const heldPaths = listProcessHeldPaths(tempRoot);
   await vlog(`Process-held paths: ${[...heldPaths].join(', ') || '(none)'}`);
 
+  // Enumerate every start-command session once (active AND finished) so we can
+  // both detect active tasks and annotate finished folders with the PR/session
+  // they belonged to. Reused as the source for getActiveTasks to avoid a second
+  // `$ --list` call.
+  let sessionTasks = [];
+  let sessionMatchers = [];
+  if (options.useSessions) {
+    sessionTasks = await listSessionTasks({ verbose: options.verbose, resolveBranches: options.resolveBranches });
+    sessionMatchers = buildActiveMatchers(sessionTasks);
+    await vlog(`Known sessions (active + finished): ${sessionTasks.length}`);
+  }
+
   let matchers = [];
   if (options.keepActiveTasks) {
-    const activeTasks = await getActiveTasks({ useSessions: options.useSessions, resolveBranches: options.resolveBranches });
+    const activeTasks = await getActiveTasks({ useSessions: options.useSessions, resolveBranches: options.resolveBranches, sessionTasks });
     matchers = buildActiveMatchers(activeTasks);
     if (activeTasks.length > 0) {
       await log(`🏃 Active tasks detected: ${activeTasks.length}`);
@@ -275,6 +287,7 @@ async function main() {
     selfPaths,
     heldPaths,
     matchers,
+    sessionMatchers,
     gitInfoByPath,
   };
   const classified = classifyEntries(entries, ctx);