jackherd 1.12.1 → 1.12.3

package/src/plans/page-sync.ts

@@ -0,0 +1,39 @@
+import { existsSync } from 'node:fs'
+import { errorText } from './error-text'
+import { type KnownPage, pageAfterWrite, pageKey, pageNeedsWriting } from './plan-chips'
+import type { Snapshot, Source } from './snapshot'
+import { writeSprintPageInSteps } from './sprint-export'
+import { boardTexts } from './texts'
+
+/** The sprint page last written, a write still running, and why the last one failed. */
+export type PageState = { page: KnownPage | null; writing: boolean; error: string | null }
+
+export const initialPageState = (): PageState => ({ page: null, writing: false, error: null })
+
+/**
+ * Writes the sprint page, so a plan chip's link points at a file that exists. Only when the plans `read` holds changed
+ * or the file is gone: building it takes seconds, with the event loop blocked for all of them. `whole` gives the whole
+ * board to build it from, `read` itself unless it shows one lane. True when it wrote or failed, so the owner draws again.
+ */
+export const syncSprintPage = async (
+  state: PageState,
+  source: Source,
+  read: Snapshot,
+  whole: () => Promise<Snapshot>,
+): Promise<boolean> => {
+  const key = pageKey(read)
+  if (state.writing || !pageNeedsWriting(state.page, key, state.page !== null && existsSync(state.page.path))) {
+    return false
+  }
+  state.writing = true
+  try {
+    const written = await writeSprintPageInSteps(source, await whole())
+    state.error = 'error' in written ? boardTexts(source.settings.board.term).pageNotWritten(written.error) : null
+    state.page = pageAfterWrite(state.page, written, key)
+  } catch (error) {
+    state.error = boardTexts(source.settings.board.term).pageNotWritten(errorText(error))
+  } finally {
+    state.writing = false
+  }
+  return true
+}

package/src/plans/phase-source.ts

@@ -1,4 +1,4 @@
-import type { PlanPhase } from '../plan-format'
+import { PHASE_WORK, type PlanPhase, phaseWorkFields } from '../plan-format'
 
 /** What a lane has done in its own worktree: commits ahead of the base ref (null when unknown) and changed files. */
 export type OwnWork = { ahead: number | null; dirty: number }
@@ -56,7 +56,10 @@ export const newerPhases = (base: readonly PlanPhase[], copy: readonly PlanPhase
  */
 const markTouched = (phase: PlanPhase, basePhase: PlanPhase | undefined): PlanPhase => {
   if (basePhase && sameTicks(phase, basePhase)) return phase
-  return basePhase && tickCount(basePhase) > 0 ? { ...phase, touched: true, merged: true } : { ...phase, touched: true }
+  return {
+    ...phase,
+    ...phaseWorkFields(basePhase && tickCount(basePhase) > 0 ? PHASE_WORK.merged : PHASE_WORK.touched),
+  }
 }
 
 /**

package/src/plans/reader.ts

@@ -0,0 +1,217 @@
+import { type FSWatcher, watch } from 'node:fs'
+import { join } from 'node:path'
+import { stampOf } from '../shared/stat-cache'
+import type { LaneMemory } from './current-phase'
+import { errorText } from './error-text'
+import {
+  type FetchState,
+  fetchBase,
+  fetchNotice,
+  fetchPlanHeads,
+  goneLanePullRequests,
+  initialFetchState,
+  shouldFetch,
+  watchedFiles,
+} from './fetch'
+import { fetchHeadPath } from './git'
+import { fetchPullRequests, noPullRequests, type PullRequestState } from './github'
+import { recallLanes, rememberLanes } from './herd-memory'
+import { planPullRequests } from './plan-heads'
+import { newReadCache, type ReadCache } from './read-cache'
+import { quietRoundsAfter, REFRESH_PACE, refreshDelay } from './refresh-pace'
+import { createRefreshSchedule, type RefreshSchedule } from './refresh-schedule'
+import { BASE_REMOTE, baseRefOf, CLOCK_LOCALE } from './settings'
+import { singleFlight } from './single-flight'
+import { loadSnapshot, type Snapshot, type Source } from './snapshot'
+import { isOwnFetchWrite } from './watch-burst'
+
+/** What one read gave: the snapshot, or why it failed. */
+export type ReadOutcome = { read: Snapshot } | { error: string }
+
+/** What the reader's owner does with a read; true when it changed what the owner shows, which keeps the pace up. */
+export type OnRead = (outcome: ReadOutcome) => boolean
+
+/** A running reader: what it knows besides the snapshot, a read asked for at once, and its end. */
+export type Reader = {
+  /** The pull requests of the last GitHub read. */
+  pullRequests: () => PullRequestState
+  /** The footer line after a failed fetch of the base branch, null while the last one worked. */
+  fetchLine: () => string | null
+  /** Reads soon, bundled with other asks (`RefreshSchedule`). */
+  schedule: () => void
+  stop: () => void
+}
+
+/** The state of a running reader; only the functions below `startReader` change it. */
+type ReaderState = {
+  source: Source
+  onRead: OnRead
+  pullRequests: PullRequestState
+  fetch: FetchState
+  watchers: Map<string, FSWatcher>
+  /** This clone's `FETCH_HEAD`, watched beside the plan files; null when git names none. */
+  fetchHead: string | null
+  /** Per lane, the ticks seen at the last read, the phase that moved last and when each moved; kept across herds (`rememberLanes`). */
+  memories: Map<string, LaneMemory>
+  /** Session logs, plans and git answers kept from the last read while they did not change. */
+  cache: ReadCache
+  flight: (() => Promise<void>) | null
+  /** The reads in a row that changed nothing the owner shows; the next one waits `refreshDelay` of it. */
+  quietRounds: number
+  stopped: boolean
+}
+
+const PULL_REQUEST_REFRESH_MS = 60_000
+
+/** Where the hooks write what agents report (`jh task`, open questions, sent files): a change there is read at once. */
+const RECORDS_DIRECTORY = '.jackherd'
+
+/** When `file` was last written (epoch milliseconds); 0 when it cannot be stat-ed, which no fetch of the herd claims. */
+const modifiedAt = (file: string): number => stampOf(file)?.mtimeMs ?? 0
+
+const syncWatchers = (watchers: Map<string, FSWatcher>, files: string[], onChange: (file: string) => void) => {
+  for (const [file, watcher] of watchers) {
+    if (files.includes(file)) continue
+    watcher.close()
+    watchers.delete(file)
+  }
+  for (const file of files.filter((candidate) => !watchers.has(candidate))) {
+    try {
+      const watcher = watch(file, (event) => {
+        if (event === 'rename') {
+          watcher.close()
+          watchers.delete(file)
+        }
+        onChange(file)
+      })
+      watchers.set(file, watcher)
+    } catch {
+      // A file that cannot be watched right now is retried on the next refresh, which also covers it meanwhile.
+    }
+  }
+}
+
+/** Watches the hooks' records below the checkout, so a reported task or question shows without waiting for the pace. */
+const watchRecords = (root: string, onChange: () => void): FSWatcher | null => {
+  try {
+    return watch(join(root, RECORDS_DIRECTORY), { recursive: true }, onChange)
+  } catch {
+    return null
+  }
+}
+
+const readOnce = async (state: ReaderState, schedule: RefreshSchedule) => {
+  schedule.refreshStarted()
+  let outcome: ReadOutcome
+  try {
+    const read = await loadSnapshot(state.source, state.pullRequests, state.memories, state.cache)
+    rememberLanes(state.source.root, state.memories, read.documents.laneOrder)
+    if (!state.stopped) syncWatchers(state.watchers, watchedFiles(read.files, state.fetchHead), schedule.onFileChange)
+    outcome = { read }
+  } catch (error) {
+    outcome = { error: errorText(error) }
+  }
+  if (state.stopped) return
+  state.quietRounds = quietRoundsAfter(state.quietRounds, state.onRead(outcome))
+}
+
+/** A read never overlaps another: one asked for meanwhile runs once after the running one, so no older read wins. */
+const refresh = (state: ReaderState, schedule: RefreshSchedule): Promise<void> => {
+  state.flight ??= singleFlight(() => readOnce(state, schedule))
+  return state.flight()
+}
+
+/**
+ * Reads the board, its plans and the lanes' state for `source` and hands each read to `onRead`: at once, then at the
+ * pace of `refreshDelay` (faster while reads change what the owner shows), at once when a watched plan file, this
+ * clone's `FETCH_HEAD` or a hook record changes, and after a fetch of the base branch. It reads GitHub's pull requests
+ * every minute and fetches the base branch when due, both as the herd always did. The herd runs one for itself, the
+ * watcher one for every herd of the board.
+ */
+export const startReader = (source: Source, onRead: OnRead): Reader => {
+  /** The lanes' branches at the last read: a pull request of one of them that is gone asks for a fetch. */
+  const laneBranches = new Set<string>()
+  const state: ReaderState = {
+    source,
+    onRead: (outcome) => {
+      if ('read' in outcome) {
+        laneBranches.clear()
+        for (const { status } of outcome.read.views) if (status.branch) laneBranches.add(status.branch)
+      }
+      return onRead(outcome)
+    },
+    pullRequests: noPullRequests(),
+    fetch: initialFetchState(),
+    watchers: new Map(),
+    fetchHead: fetchHeadPath(source.root),
+    memories: recallLanes(source.root),
+    cache: newReadCache(),
+    flight: null,
+    quietRounds: 0,
+    stopped: false,
+  }
+  const timers: { poll: Timer | null } = { poll: null }
+  const schedule: RefreshSchedule = createRefreshSchedule({
+    now: Date.now,
+    setTimer: (run, delayMs) => void setTimeout(() => state.stopped || run(), delayMs),
+    refresh: () => void refresh(state, schedule),
+    isOwnFetchWrite: (file) => file === state.fetchHead && isOwnFetchWrite(modifiedAt(file), state.fetch),
+  })
+  const fetchBaseBranch = async () => {
+    state.fetch = { ...state.fetch, lastAttempt: Date.now(), running: true }
+    const failure = await fetchBase(source.root, BASE_REMOTE, source.settings.baseBranch)
+    const planHeads = planPullRequests([...state.pullRequests.byBranch.values()].flat(), source.settings.planDirectory)
+    if (failure === null) await fetchPlanHeads(source.root, BASE_REMOTE, planHeads)
+    state.fetch = {
+      ...state.fetch,
+      running: false,
+      failure,
+      lastSuccess: failure === null ? new Date() : state.fetch.lastSuccess,
+    }
+    schedule.schedule()
+  }
+  /** Starts a fetch when one is due; true when it did, whose end then refreshes. */
+  const fetchWhenDue = (pullRequestGone: boolean): boolean => {
+    const due = shouldFetch({
+      now: Date.now(),
+      state: state.fetch,
+      intervalMinutes: source.settings.fetchIntervalMinutes,
+      pullRequestGone,
+    })
+    if (due) void fetchBaseBranch()
+    return due
+  }
+  const refreshPullRequests = async () => {
+    const previous = state.pullRequests
+    state.pullRequests = await fetchPullRequests(source.root)
+    if (state.stopped) return
+    const readable = previous.errors.length === 0 && state.pullRequests.errors.length === 0
+    const gone = goneLanePullRequests(previous.byBranch, state.pullRequests.byBranch, laneBranches)
+    if (!fetchWhenDue(readable && gone.length > 0)) schedule.schedule()
+  }
+  const poll = () => {
+    if (state.stopped) return
+    fetchWhenDue(false)
+    void refresh(state, schedule).finally(() => {
+      if (!state.stopped) timers.poll = setTimeout(poll, refreshDelay(state.quietRounds))
+    })
+  }
+  const records = watchRecords(source.root, () => schedule.schedule())
+  timers.poll = setTimeout(poll, REFRESH_PACE.baseMs)
+  const pullRequestTimer = setInterval(refreshPullRequests, PULL_REQUEST_REFRESH_MS)
+  void refresh(state, schedule)
+  void refreshPullRequests()
+  return {
+    pullRequests: () => state.pullRequests,
+    fetchLine: () => fetchNotice(state.fetch, baseRefOf(source.settings), CLOCK_LOCALE),
+    schedule: () => schedule.schedule(),
+    stop: () => {
+      state.stopped = true
+      if (timers.poll) clearTimeout(timers.poll)
+      clearInterval(pullRequestTimer)
+      records?.close()
+      for (const watcher of state.watchers.values()) watcher.close()
+      state.watchers.clear()
+    },
+  }
+}

package/src/plans/refresh-schedule.ts

@@ -0,0 +1,53 @@
+import { watchRefreshDelay } from './watch-burst'
+
+export type RefreshScheduleDeps = {
+  /** The clock, epoch milliseconds. */
+  now: () => number
+  /** Runs `run` once after `delayMs`. */
+  setTimer: (run: () => void, delayMs: number) => void
+  /** Starts the refresh; it tells `refreshStarted` when it begins reading. */
+  refresh: () => void
+  /** Whether a write to `file` came from the herd's own fetch, whose end refreshes once on its own. */
+  isOwnFetchWrite: (file: string) => boolean
+}
+
+export type RefreshSchedule = {
+  /** A refresh asked for outside the pace, bundled by `watchRefreshDelay`: one already waiting covers the ask. */
+  schedule: () => void
+  /** A watched file changed; the herd's own fetch writing `FETCH_HEAD` asks nothing. */
+  onFileChange: (file: string) => void
+  /** A refresh began reading; the asks that follow wait for the end of its window. */
+  refreshStarted: () => void
+}
+
+export const createRefreshSchedule = ({
+  now,
+  setTimer,
+  refresh,
+  isOwnFetchWrite,
+}: RefreshScheduleDeps): RefreshSchedule => {
+  let waiting = false
+  let lastRefreshAt: number | null = null
+
+  const schedule = () => {
+    if (waiting) return
+    waiting = true
+    setTimer(
+      () => {
+        waiting = false
+        refresh()
+      },
+      watchRefreshDelay(lastRefreshAt, now()),
+    )
+  }
+
+  return {
+    schedule,
+    onFileChange: (file) => {
+      if (!isOwnFetchWrite(file)) schedule()
+    },
+    refreshStarted: () => {
+      lastRefreshAt = now()
+    },
+  }
+}

package/src/plans/snapshot.ts

@@ -36,17 +36,7 @@ import {
 } from './current-phase'
 import { activityTextOf, taskSignalsOf } from './current-task'
 import { errorText } from './error-text'
-import {
-  type BaseReader,
-  type BranchStatusReader,
-  baseReaderAt,
-  branchStatusAt,
-  gitStatusOf,
-  lastChangesAt,
-  refCommits,
-  refExists,
-  resolveCommit,
-} from './git'
+import { type BaseReader, baseReaderAt, gitStatusOf, lastChangesAt, refCommits, refExists, resolveCommit } from './git'
 import type { PullRequestState } from './github'
 import { groomedDaysAgo } from './groomed'
 import {
@@ -77,7 +67,7 @@ import { readAllSignalsSliced } from './signals-read'
 import { createSliceGate, type SliceGate } from './slice-gate'
 import { withSourcePrefix } from './source-prefix'
 import type { HerdSource, SourceBlock } from './source-rows'
-import { type KeptStatus, logMark, pacedStatus } from './status-pace'
+import { type KeptStatus, logMark, pacedStatus, type WorktreeStatus } from './status-pace'
 import type { SubagentActivity } from './subagents'
 import { readSubagentActivitySliced, subagentSourceOf } from './subagents-read'
 import { boardTexts } from './texts'
@@ -128,6 +118,8 @@ export type Snapshot = {
   planned: PlannedPlan[]
   files: string[]
   titles: Map<string, string | null>
+  /** The pane of each lane whose agent has one, by lane name: which of `titles` a lane's own herd sets. */
+  panes?: Record<string, string>
   errors: string[]
   /**
    * The watcher's health; absent when no lane has an open pull request and no source is marked `ticket`, so the
@@ -171,8 +163,10 @@ type LaneSources = {
   parsed?: PlanSources['parsed']
   /** The gate each lane passes before a piece of synchronous work, so the lanes take turns with keys and drawing. */
   gate: SliceGate
-  /** Each worktree's last `git status`, kept between the herd's reads; absent for a single read, which asks git. */
+  /** Each worktree's last git answer, kept between the herd's reads; absent for a single read, which asks git. */
   statuses?: Map<string, KeptStatus>
+  /** The base ref's commit at this read, null when it does not resolve: a kept answer from another base is asked again. */
+  baseCommit: string | null
   /** When this read happens, epoch milliseconds. */
   now: number
 }
@@ -248,28 +242,27 @@ const workText = ({ readLog, subagents }: LaneSources, lane: string, agent: Lane
 }
 
 /**
- * `git status` of a lane's worktree asked only when something there may have moved: its index or HEAD, its agent's
- * log or its subagents' work (`worktreeStamp`), or the kept answer is old; git every time without kept statuses.
+ * `git status` and the commits ahead of the base of a lane's worktree, asked only when something there may have moved:
+ * its index, HEAD or commits, the base's commit, its agent's log or its subagents' work (`worktreeStamp`), or the kept
+ * answer is old; git every time without kept statuses.
  */
-const pacedStatusReader = (sources: LaneSources, name: string, agent: LaneAgent | undefined): BranchStatusReader => {
-  const { statuses, now } = sources
-  if (!statuses) return branchStatusAt
-  return (worktree, pass) => {
-    const activity = `${logMark(agent ? sources.readLog(agent) : null)}|${sources.subagents.get(name)?.activity ?? ''}`
-    const ask = { worktree, stamp: worktreeStamp(worktree, activity), now }
-    return pacedStatus(statuses, ask, () => branchStatusAt(worktree, pass))
-  }
+const pacedGitStatus = (sources: LaneSources, name: string, agent: LaneAgent | undefined): Promise<WorktreeStatus> => {
+  const { source, statuses, now, baseCommit, gate } = sources
+  const worktree = worktreeOf(source.root, source.settings, name)
+  const read = () => gitStatusOf(worktree, baseRefOf(source.settings), gate.pass)
+  if (!statuses) return read()
+  const activity = [
+    baseCommit ?? '',
+    logMark(agent ? sources.readLog(agent) : null),
+    sources.subagents.get(name)?.activity ?? '',
+  ].join('|')
+  return pacedStatus(statuses, { worktree, stamp: worktreeStamp(worktree, activity), now }, read)
 }
 
 /** What a lane's worktree and agent say, listed in the sprint or not: git state, pull requests, context. */
 const runningState = async (sources: LaneSources, name: string, agent: LaneAgent | undefined) => {
   const { source, pullRequests } = sources
-  const gitStatus = await gitStatusOf(
-    worktreeOf(source.root, source.settings, name),
-    baseRefOf(source.settings),
-    sources.gate.pass,
-    pacedStatusReader(sources, name, agent),
-  )
+  const gitStatus = await pacedGitStatus(sources, name, agent)
   await sources.gate.pass()
   const subagent = agent ? undefined : sources.subagents.get(name)
   return {
@@ -531,6 +524,7 @@ const laneSetOf = async (
   source: Source,
   context: {
     base: BaseReader
+    baseCommit: string | null
     board: BoardLanes
     sprintDirectory: string
     worktrees: string
@@ -540,7 +534,7 @@ const laneSetOf = async (
   pullRequests: PullRequestState,
   now: number,
 ): Promise<LaneSet> => {
-  const { base, board, sprintDirectory, worktrees, cache, gate } = context
+  const { base, baseCommit, board, sprintDirectory, worktrees, cache, gate } = context
   await gate.pass()
   const { agents, errors } = await readAgents(source)
   const isWanted = ({ name }: { name: string }) => !source.options.lane || name === source.options.lane
@@ -567,6 +561,7 @@ const laneSetOf = async (
       parsed: cache && { entries: cache.plans, used: new Set<string>() },
       gate,
       statuses: cache?.statuses,
+      baseCommit,
       now,
     },
     errors,
@@ -674,7 +669,12 @@ export const loadSnapshot = async (
   const worktrees = join(root, settings.worktreeDirectory)
   const now = Date.now()
   const liveBoard = board.liveMarkdown
-  const laneSet = await laneSetOf(source, { base, board, sprintDirectory, worktrees, cache, gate }, pullRequests, now)
+  const laneSet = await laneSetOf(
+    source,
+    { base, baseCommit, board, sprintDirectory, worktrees, cache, gate },
+    pullRequests,
+    now,
+  )
   const results = await laneResultsOf(laneSet, fallbacks, now, memories)
   const { parsed } = laneSet.sources
   const listedPlans = await readListedPlans(source, base, sprintDirectory, markdown, fallbacks)
@@ -738,6 +738,7 @@ export const loadSnapshot = async (
         pane ? [[pane, signalledTitle(view.summary?.signalled ?? null, shortTitle(view.progress))]] : [],
       ),
     ),
+    panes: Object.fromEntries(results.flatMap(({ view, pane }) => (pane ? [[view.progress.lane.name, pane]] : []))),
     errors: [...laneSet.errors, ...pullRequests.errors, ...(notice ? [notice] : [])],
     watch: reading?.health,
     waiting,

package/src/plans/status-pace.ts

@@ -3,8 +3,11 @@ import type { LaneStatus } from './layout'
 /** What `git status` tells the herd about a worktree. */
 export type BranchStatus = Pick<LaneStatus, 'branch' | 'dirty'>
 
-/** The last `git status` of a worktree, with the stamp of the worktree it was asked at and when (epoch milliseconds). */
-export type KeptStatus = { stamp: string; at: number; status: BranchStatus }
+/** What git tells the herd about a worktree: `git status`, and the commits ahead of the base (`rev-list`). */
+export type WorktreeStatus = Pick<LaneStatus, 'branch' | 'ahead' | 'dirty'>
+
+/** The last git answer for a worktree, with the stamp of the worktree it was asked at and when (epoch milliseconds). */
+export type KeptStatus = { stamp: string; at: number; status: WorktreeStatus }
 
 /** Where and when a status is asked: the worktree, its stamp (`worktreeStamp`) and the time. */
 export type StatusAsk = { worktree: string; stamp: string; now: number }
@@ -35,8 +38,8 @@ export const logMark = (lines: readonly string[] | null): string => {
 export const pacedStatus = async (
   kept: Map<string, KeptStatus>,
   ask: StatusAsk,
-  read: () => Promise<BranchStatus>,
-): Promise<BranchStatus> => {
+  read: () => Promise<WorktreeStatus>,
+): Promise<WorktreeStatus> => {
   const previous = kept.get(ask.worktree)
   if (isFresh(previous, ask)) return previous.status
   const status = await read()

package/src/plans/subagents-read.ts

@@ -2,6 +2,8 @@ import { readdirSync, readFileSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { defaultProjectsDirectory, followTailLines, projectDirectoryOf } from '../context/session-log'
 import { MS_PER_MINUTE } from '../plan-format/clock'
+import { boundedMemo } from '../shared/bounded-memo'
+import { stampOf } from '../shared/stat-cache'
 import { DEFAULT_SKILL_PREFIX } from '../sync/init'
 import { readApprovalRequests } from '../watch/approvals'
 import {
@@ -51,7 +53,7 @@ const directoriesOf = (path: string): string[] => {
 /** How many directories keep their listing: one `subagents` directory per session, a few hundred in a busy project. */
 const LISTED_DIRECTORIES = 2048
 
-const listings = new Map<string, { modifiedAt: number; names: string[] }>()
+const listings = boundedMemo<string, { modifiedAt: number; names: string[] }>(LISTED_DIRECTORIES)
 
 /**
  * The entry names of `path`, listed again only when the directory changed since (a file added or removed moves its
@@ -62,10 +64,7 @@ const namesIn = (path: string): string[] => {
     const modifiedAt = statSync(path).mtimeMs
     const kept = listings.get(path)
     if (kept?.modifiedAt === modifiedAt) return kept.names
-    const names = readdirSync(path)
-    if (listings.size >= LISTED_DIRECTORIES) listings.clear()
-    listings.set(path, { modifiedAt, names })
-    return names
+    return listings.set(path, { modifiedAt, names: readdirSync(path) }).names
   } catch {
     return []
   }
@@ -90,9 +89,24 @@ const logsInSession = (directory: string, now: number): SubagentLog[] =>
     return id ? logOf(directory, name, id, now) : []
   })
 
-/** The `subagents` directory of every session in one project directory. */
-const sessionDirectoriesOf = (project: string): string[] =>
-  directoriesOf(project).map((session) => join(project, session, 'subagents'))
+/**
+ * How long a session's own log may be untouched before its subagents are no longer looked for: a subagent runs while
+ * its session does, and a day is far beyond any subagent's run. Without it, every read checked each log of every past
+ * session (about 2,000 in a busy project), when none of them could be running.
+ */
+export const QUIET_SESSION_MS = 24 * 60 * MS_PER_MINUTE
+
+/** Whether the session's own log was written within `QUIET_SESSION_MS`; a session without a readable log counts as live. */
+const isSessionLive = (project: string, session: string, now: number): boolean => {
+  const stamp = stampOf(join(project, `${session}.jsonl`))
+  return stamp === null || now - stamp.mtimeMs <= QUIET_SESSION_MS
+}
+
+/** The `subagents` directory of every session in one project directory that may still run one. */
+const sessionDirectoriesOf = (project: string, now: number): string[] =>
+  directoriesOf(project)
+    .filter((session) => isSessionLive(project, session, now))
+    .map((session) => join(project, session, 'subagents'))
 
 /**
  * The project directories Claude Code keeps for sessions started in the main checkout `root` and, when
@@ -105,8 +119,10 @@ const projectDirectoriesOf = (projects: string, root: string, worktreeDirectory?
 }
 
 /** The `subagents` directory of every session of the main checkout and its worktrees. */
-const allSessionDirectories = (projects: string, root: string, worktreeDirectory?: string): string[] =>
-  projectDirectoriesOf(projects, root, worktreeDirectory).flatMap((name) => sessionDirectoriesOf(join(projects, name)))
+const allSessionDirectories = (projects: string, root: string, now: number, worktreeDirectory?: string): string[] =>
+  projectDirectoriesOf(projects, root, worktreeDirectory).flatMap((name) =>
+    sessionDirectoriesOf(join(projects, name), now),
+  )
 
 /**
  * The subagents with a recently written log in the sessions started in the main checkout `root` and its worktrees,
@@ -119,7 +135,7 @@ export const readSubagentLogs = (
   now: number,
   worktreeDirectory?: string,
 ): SubagentLog[] =>
-  allSessionDirectories(projects, root, worktreeDirectory).flatMap((directory) => logsInSession(directory, now))
+  allSessionDirectories(projects, root, now, worktreeDirectory).flatMap((directory) => logsInSession(directory, now))
 
 /** The names the gate holds an open request under, as the watcher reads them. */
 const heldNames = (root: string, now: number): Set<string> =>
@@ -160,7 +176,7 @@ export const readSubagentActivitySliced = async (
   now: number = Date.now(),
 ): Promise<Map<string, SubagentActivity>> => {
   const logs: SubagentLog[] = []
-  for (const directory of allSessionDirectories(source.projects, source.root, source.worktreeDirectory)) {
+  for (const directory of allSessionDirectories(source.projects, source.root, now, source.worktreeDirectory)) {
     await pass()
     logs.push(...logsInSession(directory, now))
   }

package/src/plans/supervisor.ts

@@ -2,12 +2,12 @@ import { type ChildProcess, spawn } from 'node:child_process'
 import { watch } from 'node:fs'
 import { dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { TERMINAL_OFF } from '../terminal/lifetime'
 import { pendingKitUpdate, VERSION_POLL_MS } from '../version/installed-version'
 import type { StartedKit } from '../version/started-kit'
 import { STOP_REQUEST, type Stopper, stopperOf } from './child-stop'
 import { HERD_COMMAND } from './herd-command'
 import { CHILD_MARKER, exitCodeOf, isRestartTrigger, nextStep, RESTART_DEBOUNCE_MS } from './restart-decision'
-import { TERMINAL_OFF } from './view'
 
 const FORWARDED_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'] as const