jackherd 1.26.1 → 1.26.2

package/src/watch/command.ts

@@ -56,6 +56,7 @@ import { ensurePlanPanes } from '../plans/ensure-panes'
 import { errorText } from '../plans/error-text'
 import { baseReaderOf, mainCheckout, worktreeNames, worktreeRoot } from '../plans/git'
 import { discoverLanes, isUnchanged, laneSetChange } from '../plans/lane-discovery'
+import { type PlacedLanes, placeLanes } from '../plans/lane-worktrees'
 import { readerOncePerRef } from '../plans/plan-heads'
 import { readQuestionRecords } from '../plans/questions-read'
 import { closeSentRecords, readSentRecords } from '../plans/sent-files-read'
@@ -172,6 +173,7 @@ import { branchOf, fetchBaseWhenMoved, fetchPlanHeadsWhenMoved, readMainCheckout
 import { type LaneStalledEvent, laneStalledEvents, STALLED_HEARTBEATS, type StallState } from './lane-stalled'
 import {
   advanceBaseline,
+  agentPlacesOf,
   armBaseline,
   baselineWithNewAgents,
   departedLanes,
@@ -302,6 +304,7 @@ type Watch = {
   boardNotice: string | null
   options: WatchOptions
   files: Files
+  /** Set at the start and again at every poll, once the lanes are placed by where their agents run (`placeLanes`). */
   settings: PlansSettings
   /** `watch.deploy`, `feedback`, `previews` and `checks` as read at the start; the loop reads them from `Watching.live`. */
   live: LiveValues
@@ -1158,13 +1161,16 @@ const readSprintLanes = (watch: Watch): SprintLane[] | null => {
 const sprintLaneNames = (watch: Watch, previous: string[]): string[] =>
   readSprintLanes(watch)?.map((lane) => lane.name) ?? previous
 
-const lanesFor = (watch: Watch, agents: readonly HerdrAgent[], sprintLanes: readonly string[]): string[] =>
-  watch.options.lanes ??
-  discoverLanes({
-    worktrees: worktreeNames(join(watch.root, watch.settings.worktreeDirectory)),
-    agentNames: agentNamesOf(agents),
-    sprintLanes,
-  })
+/** Places the lanes by where their agents run (`placeLanes`), named lanes included; the caller takes up `settings` into `watch.settings`. */
+const placeLanesOf = (watch: Watch, agents: readonly HerdrAgent[], sprintLanes: readonly string[]): PlacedLanes =>
+  placeLanes(watch.root, watch.settings, agentPlacesOf(agents), [...sprintLanes, ...(watch.options.lanes ?? [])])
+
+const lanesFor = (
+  watch: Watch,
+  agents: readonly HerdrAgent[],
+  sprintLanes: readonly string[],
+  worktrees: readonly string[],
+): string[] => watch.options.lanes ?? discoverLanes({ worktrees, agentNames: agentNamesOf(agents), sprintLanes })
 
 /** Prints the `lane <name> not watched` lines that are new since the last poll; named lanes are never discovered, so they have none. */
 const reportMisplaced = (watch: Watch, watching: Watching) => {
@@ -1203,7 +1209,9 @@ const keepBackendPane = async (watch: Watch, watching: Watching) => {
 const followLaneSet = (watch: Watch, watching: Watching): string[] => {
   if (watch.options.lanes !== null) return []
   watching.sprintLanes = sprintLaneNames(watch, watching.sprintLanes)
-  const lanes = lanesFor(watch, watching.agents, watching.sprintLanes)
+  const placed = placeLanesOf(watch, watching.agents, watching.sprintLanes)
+  watch.settings = placed.settings
+  const lanes = lanesFor(watch, watching.agents, watching.sprintLanes, placed.worktrees)
   const change = laneSetChange(watching.lanes, lanes)
   if (isUnchanged(change)) return []
   watching.departed = [...watching.departed, ...departedLanes(change.removed, watching.baseline, watching.current)]
@@ -1333,6 +1341,7 @@ const noTaskSignalEventsOf = (
     const signalled = signalledLanes(watching.lanes, {
       root: watch.root,
       worktreeDirectory: watch.settings.worktreeDirectory,
+      laneWorktrees: watch.settings.laneWorktrees,
       now,
     })
     const counts = currentPhaseCountsOf(progress)
@@ -1400,23 +1409,25 @@ const waitingObsoleteEventsOf = (
   if (!watch.inMainCheckout) return []
   try {
     const worktreeDirectory = join(watch.root, watch.settings.worktreeDirectory)
+    const { laneWorktrees } = watch.settings
     if (!existsSync(worktreeDirectory)) return []
     const sends = readSentRecords(watch.root)
     const questions = readQuestionRecords(watch.root)
     const boardText = readBoardText(watch)
     const board = boardText === null ? null : openWaitingItems(boardText, watch.settings.boardLanguage)
     const { missing, gone } = laneAbsenceOf(
-      waitingLanesOf({ sends, questions, board, worktreeDirectory }),
-      new Set(worktreeNames(worktreeDirectory)),
+      waitingLanesOf({ sends, questions, board, worktreeDirectory, laneWorktrees }),
+      new Set([...worktreeNames(worktreeDirectory), ...Object.keys(laneWorktrees)]),
       watching.waitingMissingLanes,
     )
-    const closings = closeObsoleteSends(watch.root, obsoleteSendsOf(sends, worktreeDirectory, gone), now)
+    const closings = closeObsoleteSends(watch.root, obsoleteSendsOf(sends, worktreeDirectory, gone, laneWorktrees), now)
     const closed = new Set(closings.map(({ id }) => id))
     const { events, state } = obsoleteProposalEvents(watching.waitingProposals, {
       sends: sends.filter(({ id }) => !closed.has(id)),
       questions,
       board,
       worktreeDirectory,
+      laneWorktrees,
       gone,
       ...proposalContextOf(watching),
     })
@@ -1477,10 +1488,10 @@ const subagentCountsOf = (watch: Watch, now: number): Record<string, number> =>
   try {
     const worktreeDirectory = join(watch.root, watch.settings.worktreeDirectory)
     const running = readRunningSubagents(
-      subagentSourceOf(watch.root, worktreeDirectory, watch.settings.skillPrefix),
+      subagentSourceOf(watch.root, worktreeDirectory, watch.settings.skillPrefix, watch.settings.laneWorktrees),
       now,
     )
-    return runningSubagentCountsOf(running, worktreeDirectory)
+    return runningSubagentCountsOf(running, worktreeDirectory, watch.settings.laneWorktrees)
   } catch {
     return {}
   }
@@ -1719,7 +1730,9 @@ const watchLanes = async (watch: Watch): Promise<boolean> => {
   const state = await readState(watch.files)
   const agents = listAgents()
   const sprintLanes = watch.options.lanes ? [] : sprintLaneNames(watch, [])
-  const lanes = lanesFor(watch, agents, sprintLanes)
+  const placed = placeLanesOf(watch, agents, sprintLanes)
+  watch.settings = placed.settings
+  const lanes = lanesFor(watch, agents, sprintLanes, placed.worktrees)
   const armed = toSnapshot(agents, lanes)
   const arm = armNotice(state.armed, lanes, armed, takeOver, relative(watch.root, watch.sprintFile))
   if (arm.line !== null)
@@ -1742,6 +1755,7 @@ const watchLanes = async (watch: Watch): Promise<boolean> => {
       process.env.HERDR_PANE_ID,
     ),
     laneModels: laneModelColumnsOf(watching.laneModelReadings),
+    laneWorktrees: { ...watch.settings.laneWorktrees },
   })
   resumeRecord.follow(armed, Date.now(), observed())
   process.on('SIGTERM', () => {

package/src/watch/obsolete-proposals.ts

@@ -4,7 +4,7 @@ import type { WaitingItem } from '../plan-format/waiting'
 import { CLOSE_REASON, closeReasonOf } from '../plans/close-reason'
 import { type QuestionRecord, questionTextOf } from '../plans/question-records'
 import { type SentFileRecord, sentLaneOf, sentTextOf } from '../plans/sent-files'
-import { laneDirectoryOf } from '../plans/unlisted-lanes'
+import { type LaneWorktrees, laneOfCwd } from '../plans/unlisted-lanes'
 import { isRecord } from '../shared/is-record'
 import { PLAN_LANGUAGE, type PlanLanguage } from '../vocabulary'
 import { latestPullRequestOf, PULL_REQUEST_STATE, type WatchedPullRequest } from './pull-requests'
@@ -33,6 +33,8 @@ export type ProposalInput = {
   /** Lane → branch, as the watcher keeps it after a lane was closed. */
   laneBranches: Readonly<Record<string, string>>
   worktreeDirectory: string
+  /** The lanes placed in worktrees of another name (`PlansSettings.laneWorktrees`). */
+  laneWorktrees?: LaneWorktrees
   /** The lanes whose directory was missing in two heartbeats in a row (`laneAbsenceOf`). */
   gone: ReadonlySet<string>
   /** The lanes known to have existed; a board row naming a lane that never had a worktree proposes nothing. */
@@ -64,13 +66,13 @@ export const textReferencesOf = (text: string): TextReferences => ({
 
 /** The lanes the open points name: a send's lane, a question's lane by its directory, a board row's lanes in its text. */
 export const waitingLanesOf = (
-  input: Pick<ProposalInput, 'sends' | 'questions' | 'board' | 'worktreeDirectory'>,
+  input: Pick<ProposalInput, 'sends' | 'questions' | 'board' | 'worktreeDirectory' | 'laneWorktrees'>,
 ): string[] => [
   ...input.sends.flatMap((record) =>
-    record.closedAt === null ? (sentLaneOf(record, input.worktreeDirectory) ?? []) : [],
+    record.closedAt === null ? (sentLaneOf(record, input.worktreeDirectory, input.laneWorktrees) ?? []) : [],
   ),
   ...input.questions.flatMap((record) =>
-    record.closedAt === null ? (laneDirectoryOf(record.cwd, input.worktreeDirectory) ?? []) : [],
+    record.closedAt === null ? (laneOfCwd(record.cwd, input.worktreeDirectory, input.laneWorktrees) ?? []) : [],
   ),
   ...(input.board ?? []).flatMap((row) => textReferencesOf(rowText(row)).lanes),
 ]
@@ -87,7 +89,7 @@ const laneRemovedReason = (lane: string): string => closeReasonOf(CLOSE_REASON.l
 
 const sendProposals = (input: ProposalInput): Proposal[] =>
   input.sends.flatMap((record) => {
-    const lane = sentLaneOf(record, input.worktreeDirectory)
+    const lane = sentLaneOf(record, input.worktreeDirectory, input.laneWorktrees)
     const branch = lane === null ? undefined : input.laneBranches[lane]
     const pullRequest = branch === undefined ? null : latestPullRequestOf(input.pullRequests ?? [], branch)
     return record.closedAt === null && pullRequest !== null && hasEnded(pullRequest)
@@ -96,7 +98,7 @@ const sendProposals = (input: ProposalInput): Proposal[] =>
   })
 
 const questionReasons = (record: QuestionRecord, input: ProposalInput): string[] => {
-  const lane = laneDirectoryOf(record.cwd, input.worktreeDirectory)
+  const lane = laneOfCwd(record.cwd, input.worktreeDirectory, input.laneWorktrees)
   const superseded = record.supersededBy ? [`${SUPERSEDED}: ${record.supersededBy.question}`] : []
   const ended = typeof record.sessionEndedAt === 'number' ? [SESSION_ENDED] : []
   return [...superseded, ...ended, ...(lane !== null && input.gone.has(lane) ? [laneRemovedReason(lane)] : [])]

package/src/watch/obsolete-records.ts

@@ -1,6 +1,7 @@
 import { terminalSafe } from '../plan-format/terminal-text'
 import { CLOSE_REASON, closeReasonOf } from '../plans/close-reason'
 import { latestPerFile, type SentFileRecord, sentLaneOf } from '../plans/sent-files'
+import type { LaneWorktrees } from '../plans/unlisted-lanes'
 
 export const WAITING_CLOSED_EVENT = 'waiting closed'
 
@@ -49,9 +50,10 @@ export const obsoleteSendsOf = (
   records: readonly SentFileRecord[],
   worktreeDirectory: string,
   gone: ReadonlySet<string>,
+  placed: LaneWorktrees = {},
 ): Closing[] => {
   const open = records.flatMap((record) => {
-    const lane = sentLaneOf(record, worktreeDirectory)
+    const lane = sentLaneOf(record, worktreeDirectory, placed)
     return record.closedAt === null ? [{ id: record.id, lane }] : []
   })
   const openIds = new Set(open.map(({ id }) => id))

package/src/watch/running-subagents.ts

@@ -1,15 +1,16 @@
 import type { RunningSubagent } from '../plans/subagents'
-import { laneDirectoryOf } from '../plans/unlisted-lanes'
+import { type LaneWorktrees, laneOfCwd } from '../plans/unlisted-lanes'
 import { type LaneNotes, type PhaseCount, progressNotes } from './heartbeat-progress'
 
 /** The running subagents of each worktree below `worktreeDirectory`, by lane name; one that works elsewhere is left out. */
 export const runningSubagentCountsOf = (
   running: readonly Pick<RunningSubagent, 'cwd'>[],
   worktreeDirectory: string,
+  placed: LaneWorktrees = {},
 ): Record<string, number> => {
   const counts: Record<string, number> = {}
   for (const { cwd } of running) {
-    const lane = cwd === null ? null : laneDirectoryOf(cwd, worktreeDirectory)
+    const lane = cwd === null ? null : laneOfCwd(cwd, worktreeDirectory, placed)
     if (lane !== null) counts[lane] = (counts[lane] ?? 0) + 1
   }
   return counts

package/src/watch/task-signal-read.ts

@@ -2,12 +2,15 @@ import { join } from 'node:path'
 import { defaultProjectsDirectory } from '../context/session-log'
 import { laneOfDirectory } from '../plans/active-tasks'
 import { readAllSignals } from '../plans/signals-read'
+import type { LaneWorktrees } from '../plans/unlisted-lanes'
 
 export type SignalSources = {
   /** The main checkout, which holds `.jackherd/tasks/`. */
   root: string
   /** The lanes' worktree directory, relative to `root`. */
   worktreeDirectory: string
+  /** The lanes placed in worktrees of another name (`PlansSettings.laneWorktrees`). */
+  laneWorktrees?: LaneWorktrees
   now: number
   /** Where Claude Code keeps its session logs; the user's by default. */
   projectsDirectory?: string
@@ -24,6 +27,6 @@ export const signalledLanes = (lanes: readonly string[], sources: SignalSources)
     { projects: sources.projectsDirectory ?? defaultProjectsDirectory(), root: sources.root, worktrees },
     sources.now,
   )
-  const signalled = new Set(signals.flatMap(({ cwd }) => laneOfDirectory(cwd, worktrees) ?? []))
+  const signalled = new Set(signals.flatMap(({ cwd }) => laneOfDirectory(cwd, worktrees, sources.laneWorktrees) ?? []))
   return new Set(lanes.filter((lane) => signalled.has(lane)))
 }

package/src/watch/unlinked-artifacts-read.ts

@@ -35,7 +35,9 @@ export const readUnlinkedArtifactEvents = (
   const ids = new Set(artifacts.map(({ id }) => id))
   const worktrees = join(root, settings.worktreeDirectory)
   const lanes = new Set(
-    records.filter(({ id }) => ids.has(id)).flatMap((record) => sentLaneOf(record, worktrees) ?? []),
+    records
+      .filter(({ id }) => ids.has(id))
+      .flatMap((record) => sentLaneOf(record, worktrees, settings.laneWorktrees) ?? []),
   )
   const checkouts = [root, ...[...lanes].map((lane) => worktreeOf(root, settings, lane))]
   const texts = checkouts.flatMap((checkout) => markdownTextsUnder(join(checkout, settings.planDirectory)))