jackherd 1.7.1 → 1.8.0

package/src/config/context-shares.ts

@@ -0,0 +1,130 @@
+import { isDeepStrictEqual } from 'node:util'
+import { DEFAULT_CONTEXT_WINDOW } from './schema'
+
+/** A config with its context shares in tokens, and a line for each block that changed. */
+export type SharesInTokens = { raw: unknown; notes: string[] }
+
+type JsonObject = Record<string, unknown>
+
+type Pair = { share: string; tokens: string }
+
+/** A share turned into tokens, and a share dropped because its token value is already set. */
+type Conversion = Pair & { value: number; result: number }
+type Drop = Pair & { value: number; kept: unknown }
+
+type ConvertedBlock = { block: JsonObject; converted: Conversion[]; dropped: Drop[] }
+
+const PAIRS: readonly Pair[] = [
+  { share: 'warnAt', tokens: 'warnTokens' },
+  { share: 'alertAt', tokens: 'alertTokens' },
+]
+
+const ROUNDING = 1_000
+
+const SHARE_ENTRY = new RegExp(`"(${PAIRS.map(({ share }) => share).join('|')})"(\\s*:\\s*)(0?\\.\\d+|0)`, 'g')
+
+const isRecord = (value: unknown): value is JsonObject =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+
+const isShare = (value: unknown): value is number => typeof value === 'number' && value > 0 && value < 1
+
+const sizes = (value: unknown): number[] =>
+  isRecord(value) ? Object.values(value).filter((size): size is number => typeof size === 'number' && size > 0) : []
+
+/** The window a share was most likely read against: the largest the config names, the default one included. */
+const windowOf = (context: JsonObject): number => {
+  const fallback = typeof context.defaultWindow === 'number' ? context.defaultWindow : DEFAULT_CONTEXT_WINDOW
+  return Math.max(fallback, ...sizes(context.windows))
+}
+
+const shareInTokens = (share: number, window: number): number => Math.round((share * window) / ROUNDING) * ROUNDING
+
+const hasShares = (block: JsonObject): boolean => PAIRS.some(({ share }) => isShare(block[share]))
+
+/** One block with its shares in tokens, and what changed; null when it has no share. */
+const convertBlock = (block: JsonObject, window: number): ConvertedBlock | null => {
+  if (!hasShares(block)) return null
+  const next: JsonObject = {}
+  const converted: Conversion[] = []
+  const dropped: Drop[] = []
+  for (const [key, value] of Object.entries(block)) {
+    const pair = PAIRS.find(({ share }) => share === key)
+    if (!pair || !isShare(value)) {
+      next[key] = value
+      continue
+    }
+    if (block[pair.tokens] !== undefined) {
+      dropped.push({ ...pair, value, kept: block[pair.tokens] })
+      continue
+    }
+    const result = shareInTokens(value, window)
+    next[pair.tokens] = result
+    converted.push({ ...pair, value, result })
+  }
+  return { block: next, converted, dropped }
+}
+
+/** The words for what changed in a block: `plans.context: warnAt 0.5 is now warnTokens 100000 (share of a … window).` */
+const blockNote = (label: string, window: number, { converted, dropped }: ConvertedBlock): string => {
+  const conversions = converted.map(
+    ({ share, value, tokens, result }, index) => `${share} ${value} ${index === 0 ? 'is now ' : ''}${tokens} ${result}`,
+  )
+  const drops = dropped.map(({ share, value, tokens, kept }) => `${share} ${value} dropped, ${tokens} ${kept} is set`)
+  const parts = [
+    ...(conversions.length > 0 ? [`${conversions.join(', ')} (share of a ${window} window)`] : []),
+    ...drops,
+  ]
+  return `${label}: ${parts.join('; ')}.`
+}
+
+/**
+ * Before the thresholds were tokens, `plans.context` and its `coordinator` gave them as a share of the window
+ * (`warnAt`, `alertAt`); this turns such a config into tokens, so it never breaks in silence.
+ * `raw` with the shares of `plans.context` and `plans.context.coordinator` in tokens of the largest window the
+ * config names, rounded to whole thousands, and a line per block that changed. A token value already set wins
+ * over the share beside it. Anything else, a share out of range included, stays as it is for the schema to judge.
+ */
+export const contextSharesInTokens = (raw: unknown): SharesInTokens => {
+  if (!isRecord(raw) || !isRecord(raw.plans) || !isRecord(raw.plans.context)) return { raw, notes: [] }
+  const context = raw.plans.context
+  const window = windowOf(context)
+  const coordinator = isRecord(context.coordinator) ? convertBlock(context.coordinator, window) : null
+  const lane = convertBlock(context, window)
+  if (!lane && !coordinator) return { raw, notes: [] }
+  const nextContext = { ...(lane?.block ?? context), ...(coordinator ? { coordinator: coordinator.block } : {}) }
+  const next = { ...raw, plans: { ...raw.plans, context: nextContext } }
+  const notes = [
+    lane && blockNote('plans.context', window, lane),
+    coordinator && blockNote('plans.context.coordinator', window, coordinator),
+  ]
+  return { raw: next, notes: notes.filter((note): note is string => !!note) }
+}
+
+/** The text with every `"warnAt": <share>` and `"alertAt": <share>` renamed and in tokens, in place. */
+const replacedInPlace = (text: string, window: number): string =>
+  text.replace(SHARE_ENTRY, (_match, key: string, separator: string, value: string) => {
+    const tokensKey = PAIRS.find(({ share }) => share === key)?.tokens ?? key
+    return `"${tokensKey}"${separator}${shareInTokens(Number(value), window)}`
+  })
+
+const parsesAs = (text: string, expected: unknown): boolean => {
+  try {
+    return isDeepStrictEqual(JSON.parse(text), expected)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * A config file's text with its shares in tokens (see `contextSharesInTokens`). The keys are replaced in place, so
+ * the rest of the file stays byte for byte; when the result would not read as the converted values (a share beside
+ * a token value, the key inside a string), the file is written anew from them.
+ */
+export const contextSharesTextInTokens = (text: string): { text: string; notes: string[] } => {
+  const raw: unknown = JSON.parse(text)
+  const { raw: converted, notes } = contextSharesInTokens(raw)
+  if (notes.length === 0) return { text, notes }
+  const context = (raw as { plans: { context: JsonObject } }).plans.context
+  const inPlace = replacedInPlace(text, windowOf(context))
+  return { text: parsesAs(inPlace, converted) ? inPlace : `${JSON.stringify(converted, null, 2)}\n`, notes }
+}

package/src/config/read-config.ts

@@ -1,5 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
+import { CLI_NAME } from '../version/release'
+import { contextSharesInTokens } from './context-shares'
 import { type RepositoryFacts, withDetected } from './detect'
 import { legacyConfigNote } from './legacy-names'
 import { globalConfigPath, locateConfigFile, PROJECT_CONFIG_PATH } from './location'
@@ -9,13 +11,19 @@ import { type JackherdConfig, parseConfigFile } from './schema'
 /** A config with the values detection filled in, and a line for each value the repository did not decide. */
 export type ResolvedConfig = { config: JackherdConfig; notes: string[] }
 
+/** The line for context thresholds read as tokens from a file that still gives them as a share. */
+const sharesNote = (path: string, notes: readonly string[]): string[] =>
+  notes.length > 0 ? [`${path} gives context thresholds as a share; \`${CLI_NAME} sync\` writes them as tokens.`] : []
+
 /**
- * Parses a config file's raw JSON, filling what it leaves out from the repository (see `withDetected`); an invalid
- * file throws with its path and the issues in words.
+ * Parses a config file's raw JSON, filling what it leaves out from the repository (see `withDetected`) and reading
+ * context thresholds still given as a share in tokens (see `contextSharesInTokens`); an invalid file throws with its
+ * path and the issues in words.
  */
 const resolveConfig = (raw: unknown, facts: RepositoryFacts, path: string): ResolvedConfig => {
-  const detected = withDetected(raw ?? {}, facts)
-  return { config: parseConfigFile(detected.raw, path), notes: detected.notes }
+  const shares = contextSharesInTokens(raw ?? {})
+  const detected = withDetected(shares.raw, facts)
+  return { config: parseConfigFile(detected.raw, path), notes: [...sharesNote(path, shares.notes), ...detected.notes] }
 }
 
 /**

package/src/config/schema.ts

@@ -45,7 +45,10 @@ const modelId = z
 
 const command = z.string().min(1)
 
-const share = z.number().gt(0).lt(1)
+const tokenCount = z.number().int().positive()
+
+/** The window `plans.context.defaultWindow` assumes when the config leaves it out. */
+export const DEFAULT_CONTEXT_WINDOW = 200_000
 
 /** A file below the main checkout, written into shell commands: relative, never leaving it, never an option, no quote or control character. */
 const laneCopyPath = z.string().regex(
@@ -54,9 +57,10 @@ const laneCopyPath = z.string().regex(
   'a relative path inside the checkout: no leading / or -, no .. segment, no quote or control character',
 )
 
-const warnBelowAlert = ({ warnAt, alertAt }: { warnAt: number; alertAt: number }): boolean => warnAt < alertAt
+const warnBelowAlert = ({ warnTokens, alertTokens }: { warnTokens: number; alertTokens: number }): boolean =>
+  warnTokens < alertTokens
 
-const WARN_BELOW_ALERT = { message: 'warnAt must be below alertAt', path: ['warnAt'] }
+const WARN_BELOW_ALERT = { message: 'warnTokens must be below alertTokens', path: ['warnTokens'] }
 
 /** The lock file, written unquoted into git commands: a plain relative path, never an option. */
 const lockFilePath = z
@@ -70,8 +74,8 @@ const lockFilePath = z
 const branchName = z
   .string()
   .regex(
-    /^(?![-/.])(?!.*(?:\.\.|\/\/|@\{|\.lock(?:\/|$)))[A-Za-z0-9._/-]+(?<![./])$/,
-    'a branch name such as main: no leading - / or ., no .. and no spaces',
+    /^(?!HEAD$)(?![-/.])(?!.*(?:\.\.|\/\/|@\{|\.lock(?:\/|$)))[A-Za-z0-9._/-]+(?<![./])$/,
+    'a branch name such as main: not HEAD, no leading - / or ., no .. and no spaces',
   )
 
 /** A workflow file name as `gh run list --workflow` takes it: no path, no option, a YAML file. */
@@ -223,10 +227,10 @@ const hasUniqueNames = (sources: readonly { name: string }[]): boolean =>
 
 const coordinatorSchema = z
   .strictObject({
-    /** Share of the coordinator's context window from which the watcher reports `coordinator warn`. */
-    warnAt: share.default(0.5),
-    /** Share of the coordinator's context window from which the watcher reports `coordinator alert`. */
-    alertAt: share.default(0.7),
+    /** Tokens in the coordinator's context from which the watcher reports `coordinator warn`. */
+    warnTokens: tokenCount.default(200_000),
+    /** Tokens in the coordinator's context from which the watcher reports `coordinator alert`. */
+    alertTokens: tokenCount.default(300_000),
   })
   .refine(warnBelowAlert, WARN_BELOW_ALERT)
 
@@ -253,10 +257,38 @@ const checkFreePattern = z
     'a pattern with a whole path segment that is no wildcard, such as docs/**/*.md',
   )
 
+/**
+ * A path pattern that always asks before a merge under a plan approval: plain path words with wildcards, relative, no
+ * empty, `.` or `..` segment (GitHub lists no file with one, so such a pattern would never ask). Broad on purpose (`.github/**`, `**`), since a pattern here only ever adds a question; braces,
+ * classes and negation stay out, so the hook, which has no schema library, reads exactly what this accepts.
+ */
+const alwaysAskPattern = z
+  .string()
+  .regex(/^[A-Za-z0-9_.*/-]+$/, 'path words with * and ** only, such as .github/** or apps/*/src/**')
+  .refine(
+    (pattern) => pattern.split('/').every((segment) => segment !== '' && segment !== '.' && segment !== '..'),
+    'a relative path that stays inside the repository, without an empty or . segment',
+  )
+
+/**
+ * The name of a check as GitHub lists it for a commit (a job name such as `test` or `build (ubuntu, 22)`, or a status
+ * context such as `ci/legacy`): a visible character, no control character, at most 200 characters.
+ */
+const checkName = z
+  .string()
+  .max(200)
+  .refine(
+    (name) =>
+      name.trim() !== '' &&
+      ![...name].some((character) => character.charCodeAt(0) < 0x20 || character.charCodeAt(0) === 0x7f),
+    'a check name as GitHub lists it, such as test',
+  )
+
 const mergeSchema = z.strictObject({
   /**
    * Paths of pull requests that are merged without waiting for checks: when every file of the pull request matches one
-   * of them, `/orchestrate` merges at once and the merge guard does not ask. Empty means every merge waits for checks.
+   * of them, `/orchestrate` merges at once and the merge guard does not ask, for a merge bound to the head commit with
+   * `--match-head-commit`. Empty means every merge waits for checks.
    */
   withoutChecks: z.array(checkFreePattern).default([]),
 })
@@ -264,9 +296,10 @@ const mergeSchema = z.strictObject({
 const guardSchema = z.strictObject({
   /**
    * The commands the merge guard hook asks the user about before they run, also behind options before the verb, a chain,
-   * a wrapper or `sh -c`. An empty list switches the guard off.
+   * a wrapper or `sh -c`. `gh api` asks only for a write to a merge, a file, a dispatch, a rerun or a ref. An empty list switches the
+   * guard off.
    */
-  commands: z.array(guardedCommand).default(['gh pr merge', 'gh workflow run']),
+  commands: z.array(guardedCommand).default(['gh pr merge', 'gh workflow run', 'gh run rerun', 'gh api']),
   selfMerge: z
     .strictObject({
       /** Whether `/orchestrate` offers "merge it yourself after green checks" in the pull request question; off also stops the hook honouring such an answer. */
@@ -281,6 +314,25 @@ const guardSchema = z.strictObject({
       waitMinutes: z.number().int().min(1).max(9).default(8),
     })
     .prefault({}),
+  planApproval: z
+    .strictObject({
+      /**
+       * Paths that always ask, on top of the ones jackherd brings (`.github/**`, `**\/migrations/**`, `**\/.env*`,
+       * `.claude/**`, `.jackherd/**`, `bunfig.toml`, `**\/CLAUDE.md`, `**\/AGENTS.md`, `.agents/**`, `.mcp.json`,
+       * `.husky/**`, `lefthook.yml`, the lockfiles of bun, npm, pnpm and yarn, `**\/.npmrc`, `**\/CODEOWNERS`, every
+       * package.json, and the CHANGELOG.md of every package without `"private": true`):
+       * a pull request that changes one is never merged on a plan approval alone. They add to that list, never replace
+       * it; an invalid entry turns plan approval off, so every merge asks.
+       */
+      exceptPaths: z.array(alwaysAskPattern).default([]),
+      /**
+       * Checks that must be among the head commit's and green before a plan approval lets a merge pass, by their names
+       * on GitHub. Unset, the merge needs at least one check and every one green; set, also each of these. Either way
+       * GitHub must be able to merge it and the head must contain the base branch.
+       */
+      requiredChecks: z.array(checkName).optional(),
+    })
+    .prefault({}),
 })
 
 const hintsSchema = z.strictObject({
@@ -290,15 +342,18 @@ const hintsSchema = z.strictObject({
 
 const contextSchema = z
   .strictObject({
-    /** Share of the context window from which a lane's fill shows yellow and `/implement` offers a new chat. */
-    warnAt: share.default(0.6),
-    /** Share of the context window from which a lane's fill shows red. */
-    alertAt: share.default(0.8),
-    /** Context window in tokens by full model ID; the log does not say which window a session ran with. */
-    windows: z.record(modelId, z.number().int().positive()).default({}),
+    /** Tokens in a lane's context from which its fill shows yellow and `/implement` offers a new chat. */
+    warnTokens: tokenCount.default(250_000),
+    /** Tokens in a lane's context from which its fill shows red and the lane hands over at the next phase boundary. */
+    alertTokens: tokenCount.default(350_000),
+    /**
+     * Context window in tokens by full model ID, only the upper bound of the share a view shows (the thresholds are
+     * tokens); the log does not say which window a session ran with.
+     */
+    windows: z.record(modelId, tokenCount).default({}),
     /** The window assumed for a model not listed in `windows`. */
-    defaultWindow: z.number().int().positive().default(200_000),
-    /** The coordinator's own thresholds, used by `jh context --coordinator`; the lanes keep `warnAt` and `alertAt`. */
+    defaultWindow: tokenCount.default(DEFAULT_CONTEXT_WINDOW),
+    /** The coordinator's own thresholds, used by `jh context --coordinator`; the lanes keep `warnTokens` and `alertTokens`. */
     coordinator: coordinatorSchema.prefault({}),
   })
   .refine(warnBelowAlert, WARN_BELOW_ALERT)

package/src/context/auto-compact.ts

@@ -0,0 +1,68 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+/**
+ * Claude Code's auto-compact window: how full the context may get before it compacts. Set by
+ * `CLAUDE_CODE_AUTO_COMPACT_WINDOW` (a plain token count, ahead of everything else), by `--autocompact` for one
+ * launch (not readable here), or in a settings file as `modelSettings.<model>.autoCompactWindow` or
+ * `autoCompactWindow`, a token count or `auto`.
+ */
+export const AUTO_COMPACT_ENV = 'CLAUDE_CODE_AUTO_COMPACT_WINDOW'
+
+/** The settings files of a project and of the user, highest precedence first; managed settings stay out. */
+const PROJECT_SETTINGS = ['.claude/settings.local.json', '.claude/settings.json']
+
+const USER_SETTINGS = 'settings.json'
+
+const AUTO = 'auto'
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+
+const isTokenCount = (value: unknown): value is number =>
+  typeof value === 'number' && Number.isInteger(value) && value > 0
+
+/** A file's window for `model`: a count, `auto` (the window tuned for the model), or undefined when it sets none. */
+const windowIn = (settings: unknown, model: string): number | typeof AUTO | undefined => {
+  if (!isRecord(settings)) return undefined
+  const perModel = isRecord(settings.modelSettings) ? settings.modelSettings[model] : undefined
+  const candidates = [isRecord(perModel) ? perModel.autoCompactWindow : undefined, settings.autoCompactWindow]
+  return candidates.find((value): value is number | typeof AUTO => isTokenCount(value) || value === AUTO)
+}
+
+/**
+ * The auto-compact window a session of `model` runs with, from the variable or else the first of `settings`
+ * (highest precedence first) that sets one; null when none does or the first that does says `auto`.
+ */
+export const autoCompactWindow = (
+  model: string,
+  env: string | undefined,
+  settings: readonly unknown[],
+): number | null => {
+  if (env && /^\d+$/.test(env) && Number(env) > 0) return Number(env)
+  for (const file of settings) {
+    const window = windowIn(file, model)
+    if (window !== undefined) return window === AUTO ? null : window
+  }
+  return null
+}
+
+/** One line when Claude Code would compact before the context reaches `alertTokens`; null otherwise. */
+export const compactsBeforeAlertNote = (window: number | null, alertTokens: number): string | null =>
+  window !== null && window <= alertTokens
+    ? `auto-compact window ${window} is not above alertTokens ${alertTokens}: Claude Code compacts before the hand-over`
+    : null
+
+const readJson = (path: string): unknown[] => {
+  try {
+    return [JSON.parse(readFileSync(path, 'utf8'))]
+  } catch {
+    return []
+  }
+}
+
+/** The settings of `projectRoot` and of the user's Claude directory, highest precedence first; unreadable ones left out. */
+export const readClaudeSettings = (projectRoot: string, userDirectory: string): unknown[] => [
+  ...PROJECT_SETTINGS.flatMap((path) => readJson(join(projectRoot, path))),
+  ...readJson(join(userDirectory, USER_SETTINGS)),
+]

package/src/context/command.ts

@@ -1,17 +1,68 @@
-import { basename } from 'node:path'
+import { homedir } from 'node:os'
+import { basename, join } from 'node:path'
+import { CLAUDE_DIRECTORY } from '../claude/paths'
 import { mainCheckout, worktreeRoot } from '../plans/git'
-import { readSettings } from '../plans/settings'
-import { laneStatusSourceFor } from '../terminal'
-import { defaultCoordinatorName } from './coordinator-name'
-import { coordinatorSettings, parseContextOptions } from './options'
-import { contextReport, noValueNote, unnamedPaneNote } from './report'
+import { type PlansSettings, readSettings } from '../plans/settings'
+import { type LaneAgent, laneStatusSourceFor } from '../terminal'
+import { AUTO_COMPACT_ENV, autoCompactWindow, compactsBeforeAlertNote, readClaudeSettings } from './auto-compact'
+import { resolveCoordinatorName } from './coordinator-name'
+import { type ContextOptions, coordinatorSettings, parseContextOptions } from './options'
+import { type ContextReport, contextReport, noValueNote, unnamedPaneNote } from './report'
 import { agentLog } from './session-log'
 
+type ResolvedAgents = { lane: string; named: LaneAgent[]; agents: LaneAgent[] }
+
+/**
+ * The line when the session's auto-compact window is not above the alert threshold, read from the settings of
+ * `projectRoot` and the user. `env` is the session's auto-compact variable, known only for the session the command
+ * runs in, since another agent's environment is not readable.
+ */
+const autoCompactNote = (
+  report: ContextReport | null,
+  alertTokens: number,
+  projectRoot: string,
+  env: string | undefined,
+): string | null => {
+  if (!report) return null
+  const settings = readClaudeSettings(projectRoot, join(homedir(), CLAUDE_DIRECTORY))
+  return compactsBeforeAlertNote(autoCompactWindow(report.model, env, settings), alertTokens)
+}
+
+/**
+ * The lane the command reports on and the agents to look for it in. With `--coordinator` and no agent of that name,
+ * the pane the command runs in is adopted under it.
+ */
+const resolveAgents = (
+  options: ContextOptions,
+  settings: PlansSettings,
+  root: string,
+  worktree: string,
+): ResolvedAgents => {
+  const source = laneStatusSourceFor(settings.adapter)
+  const named = source.listAgents()
+  const coordinatorName = resolveCoordinatorName(
+    basename(root),
+    named.map((agent) => agent.name),
+  )
+  const lane = options.lane ?? (options.coordinator ? coordinatorName : basename(worktree))
+  const pane = process.env.HERDR_PANE_ID
+  const adopt =
+    options.coordinator && pane && !named.some((agent) => agent.name === lane) ? { pane, name: lane } : undefined
+  return { lane, named, agents: adopt ? source.listAgents(adopt) : named }
+}
+
+const printNotes = ({ lane, named, agents }: ResolvedAgents, report: ContextReport | null): void => {
+  if (agents.length > named.length) console.error(unnamedPaneNote(lane))
+  if (report === null) console.error(noValueNote(agents, lane))
+}
+
 /**
  * `jh context [<name>] [--coordinator]`: prints how full the context of an agent is as one line of JSON
  * (`tokens`, `window`, `share`, `model`, `level`), or `null` when there is no value. The name defaults to the
- * worktree the command runs in, with `--coordinator` to `orchestrator-<repository>`. `--coordinator` also takes
+ * worktree the command runs in, with `--coordinator` to `jack-<repository>`, or to `orchestrator-<repository>` while an
+ * agent still carries that old name. `--coordinator` also takes
  * the level from the coordinator's thresholds (`plans.context.coordinator`). Reads the session log, never writes it.
+ * One more line on stderr when Claude Code's auto-compact window is not above the alert threshold.
  */
 export const run = async (args: string[]): Promise<number> => {
   try {
@@ -19,18 +70,18 @@ export const run = async (args: string[]): Promise<number> => {
     const root = mainCheckout(process.cwd())
     const worktree = worktreeRoot(process.cwd())
     const settings = readSettings([worktree, root])
-    const lane = options.lane ?? (options.coordinator ? defaultCoordinatorName(basename(root)) : basename(worktree))
+    const resolved = resolveAgents(options, settings, root, worktree)
     const context = options.coordinator ? coordinatorSettings(settings.context) : settings.context
-    const source = laneStatusSourceFor(settings.adapter)
-    const named = source.listAgents()
-    const pane = process.env.HERDR_PANE_ID
-    const adopt =
-      options.coordinator && pane && !named.some((agent) => agent.name === lane) ? { pane, name: lane } : undefined
-    const agents = adopt ? source.listAgents(adopt) : named
-    const report = contextReport(agents, lane, agentLog, context)
+    const report = contextReport(resolved.agents, resolved.lane, agentLog, context)
     console.log(JSON.stringify(report))
-    if (agents.length > named.length) console.error(unnamedPaneNote(lane))
-    if (report === null) console.error(noValueNote(agents, lane))
+    printNotes(resolved, report)
+    const compactNote = autoCompactNote(
+      report,
+      context.alertTokens,
+      options.coordinator ? root : worktree,
+      options.lane ? undefined : process.env[AUTO_COMPACT_ENV],
+    )
+    if (compactNote) console.error(compactNote)
     return 0
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error))

package/src/context/coordinator-name.ts

@@ -1,16 +1,34 @@
-const PREFIX = 'orchestrator'
+/** The prefix of the coordinator's herdr name, and the one it had before, kept as an alias for running sessions. */
+export const COORDINATOR_NAME_PREFIX = { current: 'jack', legacy: 'orchestrator' } as const
+
+type CoordinatorNamePrefix = (typeof COORDINATOR_NAME_PREFIX)[keyof typeof COORDINATOR_NAME_PREFIX]
+
 const MAX_LENGTH = 32
 
-/**
- * The herdr name a coordinator takes when none is given: `orchestrator-<repository>`. herdr names are unique
- * across all workspaces, so two repositories cannot both run a coordinator called `orchestrator`. The name
- * fits `[a-z][a-z0-9_-]{0,31}`; a repository name that leaves nothing usable gives plain `orchestrator`.
- */
-export const defaultCoordinatorName = (repository: string): string => {
+const nameWith = (prefix: CoordinatorNamePrefix, repository: string): string => {
   const slug = repository
     .toLowerCase()
     .replace(/[^a-z0-9_-]+/g, '-')
     .replace(/^-+|-+$/g, '')
-  if (!slug) return PREFIX
-  return `${PREFIX}-${slug}`.slice(0, MAX_LENGTH).replace(/-+$/, '')
+  if (!slug) return prefix
+  return `${prefix}-${slug}`.slice(0, MAX_LENGTH).replace(/-+$/, '')
+}
+
+/**
+ * The herdr name a coordinator takes when none is given: `jack-<repository>`. herdr names are unique across all
+ * workspaces, so two repositories cannot both run a coordinator called `jack`. The name fits
+ * `[a-z][a-z0-9_-]{0,31}`; a repository name that leaves nothing usable gives plain `jack`.
+ */
+export const defaultCoordinatorName = (repository: string): string =>
+  nameWith(COORDINATOR_NAME_PREFIX.current, repository)
+
+/**
+ * The coordinator's name among the agents' `names`: `jack-<repository>`, else the old `orchestrator-<repository>` of a
+ * session started before the rename, else `jack-<repository>` for none. The new name wins over the old one: a new
+ * start always takes it, so an agent carrying it is the newer coordinator, and the old one is a leftover.
+ */
+export const resolveCoordinatorName = (repository: string, names: readonly string[]): string => {
+  const current = defaultCoordinatorName(repository)
+  const legacy = nameWith(COORDINATOR_NAME_PREFIX.legacy, repository)
+  return names.includes(current) || !names.includes(legacy) ? current : legacy
 }

package/src/context/index.ts

@@ -6,5 +6,4 @@ export {
   type ContextThresholds,
   contextLabel,
   contextLevel,
-  contextReading,
 } from './level'

package/src/context/level.ts

@@ -2,21 +2,28 @@ export const CONTEXT_LEVEL = { ok: 'ok', warn: 'warn', alert: 'alert' } as const
 
 export type ContextLevel = (typeof CONTEXT_LEVEL)[keyof typeof CONTEXT_LEVEL]
 
-export type ContextThresholds = { warnAt: number; alertAt: number }
+/** Thresholds in tokens in the context, whatever the window. */
+export type ContextThresholds = { warnTokens: number; alertTokens: number }
 
-/** A fill as a view shows it: the share of the window and which threshold it has passed. */
+/** A fill as a view shows it: the share of the window and which threshold its tokens have passed. */
 export type ContextReading = { share: number; level: ContextLevel }
 
-/** `ok` below `warnAt`, `warn` from there, `alert` from `alertAt` on. */
-export const contextLevel = (share: number, { warnAt, alertAt }: ContextThresholds): ContextLevel => {
-  if (share >= alertAt) return CONTEXT_LEVEL.alert
-  return share >= warnAt ? CONTEXT_LEVEL.warn : CONTEXT_LEVEL.ok
-}
+/** The highest share of the window a threshold may stand at, so a small window still hands over before it is full. */
+export const WARN_SHARE_CAP = 0.6
+export const ALERT_SHARE_CAP = 0.85
 
-export const contextReading = (share: number, thresholds: ContextThresholds): ContextReading => ({
-  share,
-  level: contextLevel(share, thresholds),
-})
+/**
+ * `ok` below `warnTokens`, `warn` from there, `alert` from `alertTokens` on. With a `window`, each threshold stops at
+ * 60 % or 85 % of it.
+ */
+export const contextLevel = (
+  tokens: number,
+  { warnTokens, alertTokens }: ContextThresholds,
+  window = Number.POSITIVE_INFINITY,
+): ContextLevel => {
+  if (tokens >= Math.min(alertTokens, window * ALERT_SHARE_CAP)) return CONTEXT_LEVEL.alert
+  return tokens >= Math.min(warnTokens, window * WARN_SHARE_CAP) ? CONTEXT_LEVEL.warn : CONTEXT_LEVEL.ok
+}
 
 /** `62 %` */
 export const contextLabel = (share: number): string => `${Math.round(share * 100)} %`

package/src/context/report.ts

@@ -4,17 +4,20 @@ import { type ContextLevel, type ContextThresholds, contextLevel } from './level
 
 export type ContextReport = ContextFill & { level: ContextLevel }
 
+/** What a report reads its fill against: the windows and the thresholds. */
+export type ReportSettings = ContextWindows & ContextThresholds
+
 export type AgentLogReader = (agent: Pick<LaneAgent, 'session' | 'cwd'>) => string[] | null
 
 /** The fill of one agent with its level; null without an agent, a log or an answer in it. */
 export const contextOfAgent = (
   agent: Pick<LaneAgent, 'session' | 'cwd'> | undefined,
   readLog: AgentLogReader,
-  settings: ContextWindows & ContextThresholds,
+  settings: ReportSettings,
 ): ContextReport | null => {
   const lines = agent ? readLog(agent) : null
   const fill = lines && contextFill(lines, settings)
-  return fill ? { ...fill, level: contextLevel(fill.share, settings) } : null
+  return fill ? { ...fill, level: contextLevel(fill.tokens, settings, fill.window) } : null
 }
 
 /**
@@ -25,7 +28,7 @@ export const contextReport = (
   agents: readonly LaneAgent[],
   lane: string,
   readLog: AgentLogReader,
-  settings: ContextWindows & ContextThresholds,
+  settings: ReportSettings,
 ): ContextReport | null =>
   contextOfAgent(
     agents.find((agent) => agent.name === lane),