jackherd 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.6.0
+
+- **Replies address you as you like.** The new setting `responseAddress` (`informal` by default, or `formal`) says whether replies use the familiar or the polite form where the language has both: in German `du` or `Sie`. Set it in `.jackherd/config.json`; `jh sync` writes it into the kit rule `rules/kit/code-style.md`, which every session loads. It follows `responseLanguage`. English has one form, so there the setting only nudges the tone (direct or businesslike). The watcher's and the plans view's own German words use no pronoun and are unchanged.
+- **`jh --version` (and `jh -v`) prints the installed version** and exits 0. The usage text lists it.
+- **Closing a lane marks its rows.** Step 5 of "Close a lane" in the `orchestrate` skill now appends the cleaned-up word (`, abgeräumt <date>` on a German board, `, cleaned up <date>` on an English one) to the name cell of every row of the lane, in the same documentation PR as the history entry. The word follows `planLanguage`. The plans view no longer lists a closed lane without a worktree as `waiting`.
+- **The worktree's dependencies are checked with one command.** When the herdr plugin `zerodice0.worktree-bootstrap` has set up the worktree, the `orchestrate` skill no longer polls for a dependencies directory (some package managers keep a workspace's out of the root, so the poll could keep waiting on an install that was long done). It runs your `commands.install` with the lock file frozen: `bun install --frozen-lockfile`, `pnpm install --frozen-lockfile`, `yarn install --immutable` or `npm ci` (which always reinstalls). Any other install command you set is run exactly as written.
+- **`jh sync` clears the empty directories a prefix change leaves.** When `skillPrefix` changes, the unedited kit files under the old names are removed, and now the directories those removals leave empty go too; an empty directory the run did not touch stays. A directory that still holds a file the kit did not write stays, and `sync` says so (`Kept .claude/skills/<name>: it holds files the kit did not write.`). A symbolic link is not followed, and `sync --check` removes nothing.
+
 ## 1.5.0
 
 - **The plans view lists only the lanes that still have something to do.** Before, every lane without an agent was listed (56 of 61 on one board, nearly all of them finished). Now a lane marked cleaned up, and a lane without a worktree whose named phases are all ticked, are not shown. A lane without a worktree that still has an open phase, or no plan and a "starts after" other than "now", is listed under `· waiting` with what it waits for. A worktree without an agent stays under `· no agent`. The board needs no change. The watcher is unchanged.

package/README.md

@@ -185,7 +185,7 @@ bunx jackherd sync   # later: updates the kit files
 
 `init` writes what it [detected](#user-content-detected-per-repository) into the new config, so the project sees it. It asks whether to enter the [status line](#user-content-status-line) in `.claude/settings.json`; `--yes` or `--no` answer every question without asking.
 
-**Name clashes.** A project that already has a skill or agent of a kit name (`implement`, `plan`, …): `init` names the clash and offers the prefix `jh-`, so the kit's copies sit beside yours and call each other, not yours. Any project can set `skillPrefix` in `.jackherd/config.json`; `sync` then renames, and removes the unprefixed kit files you never edited.
+**Name clashes.** A project that already has a skill or agent of a kit name (`implement`, `plan`, …): `init` names the clash and offers the prefix `jh-`, so the kit's copies sit beside yours and call each other, not yours. Any project can set `skillPrefix` in `.jackherd/config.json`; `sync` then renames, and removes the unprefixed kit files you never edited, with the directories they leave empty. A directory that holds a file of yours stays, and `sync` names it.
 
 **Your edits survive.** `sync` leaves files you have edited alone. When the kit changed one of them too, its version lands beside yours as `<file>.kit-new`: merge it, or take the kit version with `sync --accept <path>`. A kit file you deleted stays deleted. Project-specific additions go into `.claude/project/<skill>.md` (read first by the skill of that name) or a rule beside `.claude/rules/kit/`, so the kit files stay updatable.
 
@@ -933,7 +933,7 @@ Decisions never live only in a hand-over note: they are in the plan or the board
 
 In a repository that ignores `docs/`, plan and board exist only in the main checkout and the plan view reads them there; list the plan in `lanes.copy` so the lane has it to work from and to tick off its own progress.
 
-The herdr plugin `zerodice0.worktree-bootstrap`, when enabled and configured in the main checkout, can copy files and run setup commands for new worktrees; the coordinator checks its result and does the step itself when it is missing.
+The herdr plugin `zerodice0.worktree-bootstrap`, when enabled and configured in the main checkout, can copy files and run setup commands for new worktrees; the coordinator checks its result with the install command and a frozen lock file (`bun install --frozen-lockfile`, `pnpm install --frozen-lockfile`, `yarn install --immutable`, `npm ci`, derived from `commands.install`; an install command of your own runs as written) and does the step itself when it is missing.
 
 </details>
 
@@ -1077,6 +1077,7 @@ At `warn` a lane offers a fresh chat at its next phase boundary, and the watcher
 
 | Command | What it does | Options |
 | ------- | ------------ | ------- |
+| `jh --version` | The installed version, e.g. `1.6.0`; `-v` is the same | none |
 | `jh init` | Creates `.jackherd/config.json` and installs the kit | `--global`: into `~/.claude` and `~/.jackherd`; `--yes`/`--no`: answer all its questions (globally the hook and the status line, in a project the prefix and the status line) and take the default [setup](#user-content-setup-questions); a status line of your own is replaced only by a yes in the dialog |
 | `jh sync` | Updates the kit files; edited files get a `.kit-new` beside them | `--global`; `--accept <path>` takes the kit's version; `--global --if-changed` syncs only after a package update and names a newer npm release once a day |
 | `jh update` | Installs the newest release with the package manager that holds the kit globally, then syncs `~/.claude` and the project with the new code | none; does nothing when the installed version is the latest |
@@ -1095,6 +1096,7 @@ Without a global install, run any of them as `bunx jackherd <command>`.
 | Key | Default | What it decides |
 | --- | --- | --- |
 | `responseLanguage` | `en` | the language the skills speak with you, and the watcher's status words |
+| `responseAddress` | `informal` | `informal` or `formal`: how replies address you where the language has both (German: `du` or `Sie`). `jh sync` writes it once into the kit rule `rules/kit/code-style.md`, which every session loads; it follows `responseLanguage`; the status words of the watcher and the plans view use no pronoun and stay as they are |
 | `planLanguage` | `en` | the language of plans and boards, including their headings |
 | `planDirectory` | `docs/plans` | where plans and boards live |
 | `board.pattern`, `board.file`, `board.term` | `board-*`, `board.md`, `board` | [Boards](#user-content-boards) |

package/dist/{chunk-HQAONP4W.js → chunk-QJSXHHQ3.js}

@@ -4,6 +4,17 @@ var LANGUAGE_NAME = {
   [PLAN_LANGUAGE.en]: "English",
   [PLAN_LANGUAGE.de]: "German"
 };
+var RESPONSE_ADDRESS = { informal: "informal", formal: "formal" };
+var ADDRESS_FORM = {
+  [PLAN_LANGUAGE.en]: {
+    [RESPONSE_ADDRESS.informal]: "the plain, direct \u201Cyou\u201D, without titles",
+    [RESPONSE_ADDRESS.formal]: "a polite, businesslike \u201Cyou\u201D"
+  },
+  [PLAN_LANGUAGE.de]: {
+    [RESPONSE_ADDRESS.informal]: "the familiar \u201Cdu\u201D (du, dir, dein), never \u201CSie\u201D",
+    [RESPONSE_ADDRESS.formal]: "the polite \u201CSie\u201D (Sie, Ihnen, Ihr), never \u201Cdu\u201D"
+  }
+};
 var SELF_MERGE_LABEL = {
   [PLAN_LANGUAGE.en]: "Approve, and merge it yourself after green checks",
   [PLAN_LANGUAGE.de]: "Freigeben, und nach gr\xFCnen Checks selbst mergen"
@@ -90,6 +101,8 @@ var sectionHeading = (language, section) => `## ${PLAN_VOCABULARY[language].sect
 export {
   PLAN_LANGUAGE,
   LANGUAGE_NAME,
+  RESPONSE_ADDRESS,
+  ADDRESS_FORM,
   SELF_MERGE_LABEL,
   isPlanLanguage,
   PLAN_STATUS,

package/dist/config.d.ts

@@ -43,6 +43,10 @@ declare const jackherdConfigSchema: z.ZodObject<{
         de: "de";
         en: "en";
     }>>;
+    responseAddress: z.ZodDefault<z.ZodEnum<{
+        informal: "informal";
+        formal: "formal";
+    }>>;
     planLanguage: z.ZodDefault<z.ZodEnum<{
         de: "de";
         en: "en";

package/dist/config.js

@@ -1,6 +1,7 @@
 import {
-  PLAN_LANGUAGE
-} from "./chunk-HQAONP4W.js";
+  PLAN_LANGUAGE,
+  RESPONSE_ADDRESS
+} from "./chunk-QJSXHHQ3.js";
 
 // src/config/json-schema.ts
 import { z as z3 } from "zod";
@@ -69,6 +70,12 @@ var DERIVED_COMMANDS = {
     lintFiles: "npx @biomejs/biome check --no-errors-on-unmatched"
   }
 };
+var FROZEN_INSTALL = {
+  [DERIVED_COMMANDS.bun.install]: "bun install --frozen-lockfile",
+  [DERIVED_COMMANDS.yarn.install]: "yarn install --immutable",
+  [DERIVED_COMMANDS.pnpm.install]: "pnpm install --frozen-lockfile",
+  [DERIVED_COMMANDS.npm.install]: "npm ci"
+};
 var BUN_COMMANDS = DERIVED_COMMANDS.bun;
 
 // src/check/command-line.ts
@@ -345,6 +352,8 @@ var contextSchema = z2.strictObject({
 var jackherdConfigSchema = z2.strictObject({
   $schema: z2.string().optional(),
   responseLanguage: language.default(PLAN_LANGUAGE.en),
+  /** Whether replies address the user with the familiar or the polite form where the language has both (German: du or Sie). */
+  responseAddress: z2.enum(Object.values(RESPONSE_ADDRESS)).default(RESPONSE_ADDRESS.informal),
   planLanguage: language.default(PLAN_LANGUAGE.en),
   planDirectory: z2.string().min(1).default("docs/plans"),
   /** Where the boards live and what the project calls them. */

package/dist/plan-format.d.ts

@@ -5,6 +5,17 @@ declare const PLAN_LANGUAGE: {
 type PlanLanguage = (typeof PLAN_LANGUAGE)[keyof typeof PLAN_LANGUAGE];
 /** The language's name as a reply or a question says it. */
 declare const LANGUAGE_NAME: Record<PlanLanguage, string>;
+declare const RESPONSE_ADDRESS: {
+    readonly informal: "informal";
+    readonly formal: "formal";
+};
+type ResponseAddress = (typeof RESPONSE_ADDRESS)[keyof typeof RESPONSE_ADDRESS];
+/**
+ * How a skill's reply addresses the user, as the words a kit rule gives the agent. German and the other languages
+ * that tell a familiar from a polite "you" name the pronoun and the possessive; English has one form and only
+ * differs in tone.
+ */
+declare const ADDRESS_FORM: Record<PlanLanguage, Record<ResponseAddress, string>>;
 /**
  * The option of the pull request question that approves the PR and a merge by the coordinator once the checks are
  * green. The merge guard hook matches the user's answer against this exact text, so it is fixed per language and not
@@ -330,4 +341,4 @@ declare const readSprintDocument: (markdown: string, language: PlanLanguage) =>
  */
 declare const readPhaseDependencies: (planMarkdown: string, language: PlanLanguage) => Record<string, string>;
 
-export { type ChecklistItem, type DeferredItem, type DriftFinding, LANGUAGE_NAME, type LaneProgress, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, PHASE_ID_PREFIX, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, type PhaseProgress, type PhaseTally, type PhaseWithoutGate, type PlanHeader, type PlanLanguage, type PlanPhase, type PlanStatus, type PlanStep, type PlanVocabulary, type PlansByHref, type RowWithoutPhase, SELF_MERGE_LABEL, type SprintDocument, type SprintLane, type SprintPlanRow, type SprintPlanTable, type StatusWord, type StepProgress, activeItem, boardRowsWithoutPhase, classifyStatus, countDecisions, currentPhase, currentPhaseOf, deferralTarget, endsPhase, findDrift, hasLanesTable, isCheckboxLine, isOpenCheckboxLine, isPlanLanguage, isReviewGateLine, isTickedUnmerged, keptPhaseIds, laneNameOf, laneProgress, mergedPhasesWithOpenBoxes, misplacedDeferrals, newPhasesWithoutReviewGate, parsePlanPhases, parseSprintLanes, phaseHeading, phaseHeadingPattern, phaseIdsOfCell, phaseIdsOfPlan, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, shortTitle, sprintTitleOf, sumPhases, tallyPhases, withoutRepeats };
+export { ADDRESS_FORM, type ChecklistItem, type DeferredItem, type DriftFinding, LANGUAGE_NAME, type LaneProgress, type MergedPhaseWithOpenBoxes, type MisplacedDeferral, PHASE_ID_PREFIX, PLAN_LANGUAGE, PLAN_STATUS, PLAN_VOCABULARY, type PhaseProgress, type PhaseTally, type PhaseWithoutGate, type PlanHeader, type PlanLanguage, type PlanPhase, type PlanStatus, type PlanStep, type PlanVocabulary, type PlansByHref, RESPONSE_ADDRESS, type ResponseAddress, type RowWithoutPhase, SELF_MERGE_LABEL, type SprintDocument, type SprintLane, type SprintPlanRow, type SprintPlanTable, type StatusWord, type StepProgress, activeItem, boardRowsWithoutPhase, classifyStatus, countDecisions, currentPhase, currentPhaseOf, deferralTarget, endsPhase, findDrift, hasLanesTable, isCheckboxLine, isOpenCheckboxLine, isPlanLanguage, isReviewGateLine, isTickedUnmerged, keptPhaseIds, laneNameOf, laneProgress, mergedPhasesWithOpenBoxes, misplacedDeferrals, newPhasesWithoutReviewGate, parsePlanPhases, parseSprintLanes, phaseHeading, phaseHeadingPattern, phaseIdsOfCell, phaseIdsOfPlan, readPhaseDependencies, readPlanHeader, readSprintDocument, resolvePlanPath, sectionHeading, shortTitle, sprintTitleOf, sumPhases, tallyPhases, withoutRepeats };

package/dist/plan-format.js

@@ -1,14 +1,16 @@
 import {
+  ADDRESS_FORM,
   LANGUAGE_NAME,
   PLAN_LANGUAGE,
   PLAN_STATUS,
   PLAN_VOCABULARY,
+  RESPONSE_ADDRESS,
   SELF_MERGE_LABEL,
   classifyStatus,
   isPlanLanguage,
   phaseHeading,
   sectionHeading
-} from "./chunk-HQAONP4W.js";
+} from "./chunk-QJSXHHQ3.js";
 
 // src/plan-format/terminal-text.ts
 var UNSAFE_RANGES = [
@@ -592,11 +594,13 @@ var readPhaseDependencies = (planMarkdown, language) => {
   return Object.fromEntries(entries);
 };
 export {
+  ADDRESS_FORM,
   LANGUAGE_NAME,
   PHASE_ID_PREFIX,
   PLAN_LANGUAGE,
   PLAN_STATUS,
   PLAN_VOCABULARY,
+  RESPONSE_ADDRESS,
   SELF_MERGE_LABEL,
   activeItem,
   boardRowsWithoutPhase,

package/herdr-plugin/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "crossdelta.jackherd"
 name = "jackherd"
-version = "1.5.0"
+version = "1.6.0"
 min_herdr_version = "0.8.2"
 description = "Show the plans of a board's lanes in a herdr pane"
 platforms = ["linux", "macos"]

package/install.sh

@@ -9,7 +9,7 @@ set -eu
 
 # The default is the version this file ships with. The release bump changes it together with
 # package.json; install.test.ts fails while the two differ. Overridable, but only by a plain release.
-JACKHERD_VERSION="${JACKHERD_VERSION:-1.5.0}"
+JACKHERD_VERSION="${JACKHERD_VERSION:-1.6.0}"
 
 JACKHERD_PACKAGE='jackherd'
 # Test seam: the terminal the wizard asks its questions on.

package/kit/rules/rules/kit/code-style.md

@@ -17,6 +17,7 @@ The formatter and linter config is the authority; these are the conventions it e
 - **All code in English**: file names, identifiers, type and component names, comments. User-facing strings go through the project's i18n system.
 - **Commit messages in English**, subject and body. The subject is a Conventional Commit (`fix(scope): …`); the body explains cause and consequence in prose.
 - **Plans and ADRs** are written in {{kit.planLanguage}}.
+- **Replies to the user** are in {{kit.responseLanguage}}, addressing the user with {{kit.responseAddress}}. That holds for every answer, every question and every report to the user; it does not change what is written into code, commits or plans.
 
 ## Naming
 

package/kit/workflow/skills/orchestrate/SKILL.md

@@ -150,8 +150,12 @@ stay approval-bound (§ 5, § 6).
    - **Plugin in place:** `herdr plugin list` shows `zerodice0.worktree-bootstrap` as `enabled`,
      and the main checkout has `.herdr/worktree-copy.list` (for step 3) or
      `.herdr/worktree-setup.json` (for step 4). Skip the step the plugin's file covers. Before
-     step 5, check the result: `cmp -s` per env file, and the dependencies directory exists in the
-     worktree. Poll that check every 10 seconds for up to 2 minutes; if it still fails, do the step below yourself.
+     step 5, check the result: `cmp -s` per env file, and the dependencies are all there. Run
+     `{{kit.lanes.verifyInstall}}` in the worktree, as a pane command with the `-OK`/`-FAIL` marker of step 4.
+     It ends with an exit code, so there is nothing to poll; with bun, pnpm and yarn it returns quickly when nothing
+     is missing.
+     Never look for a directory such as `node_modules/<package>`: some package managers keep a workspace's
+     dependencies out of the root. If the command fails, do the step below yourself; if that fails too, report it.
    - **Plugin missing, disabled, or its file absent:** do the step as written below.
 
    Copy the untracked files every lane needs (`lanes.copy` in the jackherd config, else what
@@ -584,7 +588,9 @@ After its last PR is merged and the user agreed:
    locked (`git worktree list --porcelain` shows `locked claude session`) needs `git worktree unlock`
    first; check the session has ended.
 4. Delete the local branch; the remote one is usually gone with the merge (`git ls-remote --heads`).
-5. Record the lane's end in the board's `{{kit.heading.history}}`.
+5. Record the lane's end in the board's `{{kit.heading.history}}`, and mark every row of the lane by appending
+   `, {{kit.word.laneClosed}} <date>` to its name cell, in the same documentation PR as the history entry. The plans view lists a lane without a worktree as waiting until its
+   name cell carries that word and its plan has open phases.
 
 Close only lanes you started or the user named.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jackherd",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "keywords": [
     "claude-code",
     "coding-agents",

package/schemas/jackherd.schema.json

@@ -13,6 +13,14 @@
         "en"
       ]
     },
+    "responseAddress": {
+      "default": "informal",
+      "type": "string",
+      "enum": [
+        "informal",
+        "formal"
+      ]
+    },
     "planLanguage": {
       "default": "en",
       "type": "string",

package/src/cli.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 import { pathToFileURL } from 'node:url'
+import { locateKit } from './sync/kit-source'
 import { CLI_NAME } from './version/release'
 
 export type CommandModule = { run: (args: string[]) => Promise<number> | number }
@@ -8,6 +9,7 @@ export type CommandTable = Record<string, () => Promise<CommandModule>>
 
 export type Resolution =
   | { kind: 'run'; name: string; args: string[] }
+  | { kind: 'version' }
   | { kind: 'usage'; exitCode: number; message: string }
 
 /** One line per command; each entry lazily imports the module that exports its `run`. */
@@ -25,14 +27,25 @@ export const COMMANDS: CommandTable = {
 export const resolveCommand = (argv: string[], table: CommandTable): Resolution => {
   const [name, ...args] = argv
   const names = Object.keys(table)
-  const usage = `Usage: ${CLI_NAME} <command> [args]\nCommands: ${names.length > 0 ? names.join(', ') : '(none yet)'}`
+  const usage = `Usage: ${CLI_NAME} <command> [args]\n       ${CLI_NAME} --version\nCommands: ${names.length > 0 ? names.join(', ') : '(none yet)'}`
+  if (name === '--version' || name === '-v') return { kind: 'version' }
   if (!name || name === '--help' || name === '-h') return { kind: 'usage', exitCode: name ? 0 : 1, message: usage }
   if (!names.includes(name)) return { kind: 'usage', exitCode: 1, message: `Unknown command: ${name}\n${usage}` }
   return { kind: 'run', name, args }
 }
 
-export const main = async (argv: string[], table: CommandTable = COMMANDS): Promise<number> => {
+const installedVersion = async (): Promise<string> => (await locateKit()).version
+
+export const main = async (
+  argv: string[],
+  table: CommandTable = COMMANDS,
+  readVersion: () => Promise<string> = installedVersion,
+): Promise<number> => {
   const resolution = resolveCommand(argv, table)
+  if (resolution.kind === 'version') {
+    console.log(await readVersion())
+    return 0
+  }
   if (resolution.kind === 'usage') {
     console.log(resolution.message)
     return resolution.exitCode

package/src/config/detect.ts

@@ -88,6 +88,21 @@ const DERIVED_COMMANDS: Record<PackageManager, DerivedCommands> = {
   },
 }
 
+/** The install command of each manager that stops at the lock file instead of changing it. */
+const FROZEN_INSTALL: Record<string, string> = {
+  [DERIVED_COMMANDS.bun.install]: 'bun install --frozen-lockfile',
+  [DERIVED_COMMANDS.yarn.install]: 'yarn install --immutable',
+  [DERIVED_COMMANDS.pnpm.install]: 'pnpm install --frozen-lockfile',
+  [DERIVED_COMMANDS.npm.install]: 'npm ci',
+}
+
+/**
+ * The check that a worktree's dependencies are all there: the manager's install with the lock file frozen, fast when
+ * nothing is missing, fetching what is, failing when the lock file and `package.json` disagree. An install command the
+ * project set itself is returned as it is, since its flags are not known.
+ */
+export const frozenInstallCommand = (install: string): string => FROZEN_INSTALL[install] ?? install
+
 /** The bun defaults of the schema, so a repository Bun runs and one detection skips agree. */
 export const BUN_COMMANDS = DERIVED_COMMANDS.bun
 

package/src/config/schema.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 import { checkConfigSchema } from '../check/schema'
 import { claudePath, WORKTREES_DIRECTORY } from '../claude/paths'
-import { PLAN_LANGUAGE } from '../vocabulary'
+import { PLAN_LANGUAGE, RESPONSE_ADDRESS } from '../vocabulary'
 import { SOURCE_FIELD } from '../watch/source-fields'
 import { isSourcePath } from '../watch/source-path'
 import { BUN_COMMANDS, DEFAULT_BASE_BRANCH } from './detect'
@@ -257,6 +257,8 @@ const contextSchema = z
 export const jackherdConfigSchema = z.strictObject({
   $schema: z.string().optional(),
   responseLanguage: language.default(PLAN_LANGUAGE.en),
+  /** Whether replies address the user with the familiar or the polite form where the language has both (German: du or Sie). */
+  responseAddress: z.enum(Object.values(RESPONSE_ADDRESS)).default(RESPONSE_ADDRESS.informal),
   planLanguage: language.default(PLAN_LANGUAGE.en),
   planDirectory: z.string().min(1).default('docs/plans'),
   /** Where the boards live and what the project calls them. */

package/src/sync/emptied-directories.ts

@@ -0,0 +1,19 @@
+const ancestorsOf = (path: string): string[] => {
+  const segments = path.split('/').slice(0, -1)
+  return segments.map((_, index) => segments.slice(0, index + 1).join('/'))
+}
+
+const depth = (path: string): number => path.split('/').length
+
+const deepestFirst = (left: string, right: string): number => depth(right) - depth(left) || left.localeCompare(right)
+
+/**
+ * The directories a sync may clean up after it removed `removed`: every directory above those files, deepest first,
+ * except the ones a file in `kept` still lies in. The lock proves these directories were the kit's, since the kit
+ * wrote a file into each of them; whether one is really empty is for the file system to say.
+ */
+export const emptiedDirectories = (removed: readonly string[], kept: readonly string[]): string[] => {
+  const stillUsed = new Set(kept.flatMap(ancestorsOf))
+  const candidates = new Set(removed.flatMap(ancestorsOf))
+  return [...candidates].filter((directory) => !stillUsed.has(directory)).sort(deepestFirst)
+}

package/src/sync/project-fs.ts

@@ -1,6 +1,6 @@
 import { randomBytes } from 'node:crypto'
-import { lstat, mkdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises'
-import { basename, dirname, join, sep } from 'node:path'
+import { lstat, mkdir, readdir, readFile, realpath, rename, rm, rmdir, writeFile } from 'node:fs/promises'
+import { basename, dirname, join, normalize, sep } from 'node:path'
 import { CLAUDE_DIRECTORY } from '../claude/paths'
 import { TOOL_DIRECTORY } from '../config/location'
 import { checksum } from './checksum'
@@ -86,6 +86,32 @@ export const removeFileSafely = async (directory: string, path: string): Promise
   if (state.kind === 'file') await rm(join(directory, path))
 }
 
+export const DIRECTORY_OUTCOME = { removed: 'removed', notEmpty: 'notEmpty', skipped: 'skipped' } as const
+
+export type DirectoryOutcome = (typeof DIRECTORY_OUTCOME)[keyof typeof DIRECTORY_OUTCOME]
+
+/**
+ * Removes a real, empty directory and nothing else: a link, a file or a directory with any entry (a dotfile
+ * included) stays, and so does the directory itself that `path` names as `.`, and `rmdir` itself refuses what turned out not to be empty between the check and the call.
+ */
+export const removeEmptyDirectory = async (directory: string, path: string): Promise<DirectoryOutcome> => {
+  if (normalize(path) === '.') return DIRECTORY_OUTCOME.skipped
+  // `hasPlainAncestors` looks at the directories above a file path, so a child segment stands in for one.
+  if (!(await hasPlainAncestors(directory, `${path}/entry`))) return DIRECTORY_OUTCOME.skipped
+  const target = join(directory, path)
+  const entry = await lstatOrMissing(target)
+  if (!entry?.isDirectory()) return DIRECTORY_OUTCOME.skipped
+  if ((await readdir(target)).length > 0) return DIRECTORY_OUTCOME.notEmpty
+  try {
+    await rmdir(target)
+    return DIRECTORY_OUTCOME.removed
+  } catch (err) {
+    if (typeof err === 'object' && err !== null && 'code' in err && (err.code === 'ENOTEMPTY' || err.code === 'EEXIST'))
+      return DIRECTORY_OUTCOME.notEmpty
+    throw err
+  }
+}
+
 /** Creates the file only if nothing is at the path yet; returns false and writes nothing otherwise. */
 export const createFileExclusively = async (directory: string, path: string, content: string): Promise<boolean> => {
   if ((await readLocalState(directory, path)).kind !== 'missing') return false

package/src/sync/render.ts

@@ -1,5 +1,6 @@
 import type { JackherdConfig } from '../config'
-import { LANGUAGE_NAME, PLAN_VOCABULARY, SELF_MERGE_LABEL } from '../vocabulary'
+import { frozenInstallCommand } from '../config/detect'
+import { ADDRESS_FORM, LANGUAGE_NAME, PLAN_VOCABULARY, SELF_MERGE_LABEL } from '../vocabulary'
 
 const PLACEHOLDER = /\{\{\s*(kit\.[A-Za-z0-9_.-]*)\s*\}\}/g
 
@@ -21,9 +22,10 @@ const prefixed = (prefix: string, values: Record<string, string>): [string, stri
 
 /** Every placeholder a kit file may use, with its value for this project. */
 const placeholderValues = (config: JackherdConfig): Map<string, string> => {
-  const { header, sections, columns, phase } = PLAN_VOCABULARY[config.planLanguage]
+  const { header, sections, columns, phase, laneClosed } = PLAN_VOCABULARY[config.planLanguage]
   return new Map([
     ['kit.responseLanguage', LANGUAGE_NAME[config.responseLanguage]],
+    ['kit.responseAddress', ADDRESS_FORM[config.responseLanguage][config.responseAddress]],
     ['kit.planLanguage', LANGUAGE_NAME[config.planLanguage]],
     ['kit.planDirectory', config.planDirectory],
     ['kit.baseBranch', config.baseBranch],
@@ -32,6 +34,8 @@ const placeholderValues = (config: JackherdConfig): Map<string, string> => {
     ...prefixed('command', config.commands),
     ['kit.lanes.copyCommand', laneCopyCommand(config.lanes.copy)],
     ['kit.lanes.lockFile', config.lanes.lockFile],
+    ['kit.lanes.verifyInstall', frozenInstallCommand(config.commands.install)],
+    ['kit.word.laneClosed', laneClosed],
     ...prefixed('board', config.board),
     ['kit.guard.selfMergeLabel', SELF_MERGE_LABEL[config.responseLanguage]],
     ['kit.guard.selfMerge', config.guard.selfMerge.offer ? 'offered' : 'not offered'],
@@ -46,9 +50,9 @@ export const listPlaceholders = (template: string): string[] =>
 
 /**
  * Fills the kit placeholders from the project config: `{{kit.model.<role>}}`,
- * `{{kit.command.<test|typecheck|lint|format|install|dev>}}`, `{{kit.lanes.<copyCommand|lockFile>}}`,
+ * `{{kit.command.<test|typecheck|lint|format|install|dev>}}`, `{{kit.lanes.<copyCommand|lockFile|verifyInstall>}}`, `{{kit.word.laneClosed}}`,
  * `{{kit.board.<pattern|file|term>}}`, `{{kit.guard.<selfMerge|selfMergeLabel>}}`, `{{kit.merge.withoutChecks}}`, `{{kit.heading.<key>}}` from the plan
- * vocabulary, the two languages, the plan and worktree directory and the base branch. Other
+ * vocabulary, the two languages, `{{kit.responseAddress}}`, the plan and worktree directory and the base branch. Other
  * `{{…}}` text is left alone; an unknown `kit.` placeholder throws rather than reaching a project
  * file unrendered. `overrides` win over the config: a global kit renders what each repository decides as
  * `<name>` (`REPOSITORY_TOKENS`).

package/src/sync/sync.ts

@@ -1,5 +1,5 @@
 import { homedir } from 'node:os'
-import { join } from 'node:path'
+import { basename, dirname, join } from 'node:path'
 import { CLAUDE_DIRECTORY, SETTINGS_FILE } from '../claude/paths'
 import type { JackherdConfig } from '../config'
 import type { RepositoryFacts } from '../config/detect'
@@ -7,19 +7,22 @@ import { CONFIG_FILE, MANIFEST_FILE, TOOL_DIRECTORY } from '../config/location'
 import { readRepositoryFacts } from '../config/repository-facts'
 import { REPOSITORY_TOKENS } from '../config/repository-values'
 import { CLI_NAME } from '../version/release'
+import { emptiedDirectories } from './emptied-directories'
 import { ensureGitignoreLines } from './gitignore'
 import { toGlobalKit, toProjectKit } from './global-kit'
 import type { KitSource } from './kit'
 import { kitNewPath, toolRootPath } from './kit-path'
 import { moveGlobalLegacyFiles, moveProjectLegacyFiles, removeEmptyLegacyDirectories } from './legacy-files'
 import { EMPTY_MANIFEST, type Manifest, parseManifest, serializeManifest } from './manifest'
-import { FILE_MODE, type FileEffect, type FilePlan, planFile, type RenderedFile } from './plan-file'
+import { FILE_MODE, FILE_OUTCOME, type FileEffect, type FilePlan, planFile, type RenderedFile } from './plan-file'
 import { type HooksPlan, planHooks } from './plan-hooks'
 import {
   assertNotHomeDirectory,
   assertOwnDirectoriesInProject,
+  DIRECTORY_OUTCOME,
   readLocalState,
   readRegularFile,
+  removeEmptyDirectory,
   removeFileSafely,
   writeFileSafely,
 } from './project-fs'
@@ -225,6 +228,21 @@ const applyHooks = async (claudeDirectory: string, hooks: HooksPlan): Promise<vo
   if (hooks.kitNew.kind === 'remove') await removeFileSafely(claudeDirectory, SETTINGS_KIT_NEW)
 }
 
+/** Takes away the empty directories the removed kit files left; one that holds anything else stays and is named. Housekeeping only: a directory it cannot remove is a note, never a failed sync. */
+const cleanUpDirectories = async (locate: Locate, plan: SyncPlan): Promise<string[]> => {
+  const removed = plan.files.filter(({ outcome }) => outcome === FILE_OUTCOME.removed).map(({ path }) => path)
+  const notes: string[] = []
+  for (const path of emptiedDirectories(removed, Object.keys(plan.manifest.files))) {
+    // A directory is located through a file below it, the one thing `Locate` knows how to place.
+    const { directory, path: target } = locate(`${path}/entry`)
+    const name = `${basename(directory)}/${dirname(target)}`
+    const outcome = await removeEmptyDirectory(directory, dirname(target)).catch(() => null)
+    if (outcome === null) notes.push(`Could not remove ${name}; remove it by hand if it is empty.`)
+    if (outcome === DIRECTORY_OUTCOME.notEmpty) notes.push(`Kept ${name}: it holds files the kit did not write.`)
+  }
+  return notes
+}
+
 /**
  * The manifest is written last: a run that dies halfway leaves files whose content equals the
  * kit version, which the next run adopts as unchanged instead of mistaking them for local edits.
@@ -232,12 +250,14 @@ const applyHooks = async (claudeDirectory: string, hooks: HooksPlan): Promise<vo
 const applyPlan = async (
   { claudeDirectory, toolDirectory, locate }: Pick<PlanInput, 'claudeDirectory' | 'toolDirectory' | 'locate'>,
   plan: SyncPlan,
-): Promise<void> => {
+): Promise<string[]> => {
   for (const { path, effect } of effectsInOrder(plan.files)) await applyFileEffect(locate, path, effect)
+  const notes = await cleanUpDirectories(locate, plan)
   await applyHooks(claudeDirectory, plan.hooks)
   const manifestText = serializeManifest(plan.manifest)
   if (manifestText !== plan.manifestText)
     await writeFileSafely(toolDirectory, MANIFEST_FILE, manifestText, FILE_MODE.regular)
+  return notes
 }
 
 const syncResultOf = (plan: SyncPlan): SyncResult => ({
@@ -266,11 +286,9 @@ export const syncProjectWithConfig = async (request: SyncRequest): Promise<Confi
     accept: request.accept,
     readHooks: projectHooks(claudeDirectory, request.kit, config),
   })
-  if (!request.check) {
-    await applyPlan(directories, plan)
-    await ensureGitignoreLines(request.projectRoot)
-  }
-  return { result: { ...syncResultOf(plan), notes: [...moved, ...notes] }, config }
+  const keptDirectoryNotes = request.check ? [] : await applyPlan(directories, plan)
+  if (!request.check) await ensureGitignoreLines(request.projectRoot)
+  return { result: { ...syncResultOf(plan), notes: [...moved, ...notes, ...keptDirectoryNotes] }, config }
 }
 
 export const runSync = async (request: SyncRequest): Promise<SyncResult> =>
@@ -302,9 +320,9 @@ export const syncGlobalWithConfig = async (request: GlobalSyncRequest): Promise<
     readHooks: noHooks,
     overrides: REPOSITORY_TOKENS,
   })
-  await applyPlan(directories, plan)
+  const keptDirectoryNotes = await applyPlan(directories, plan)
   await removeEmptyLegacyDirectories(claudeDirectory)
-  return { result: { ...syncResultOf(plan), notes: moved }, config }
+  return { result: { ...syncResultOf(plan), notes: [...moved, ...keptDirectoryNotes] }, config }
 }
 
 export const runGlobalSync = async (request: GlobalSyncRequest): Promise<SyncResult> =>

package/src/vocabulary/index.ts

@@ -8,6 +8,26 @@ export const LANGUAGE_NAME: Record<PlanLanguage, string> = {
   [PLAN_LANGUAGE.de]: 'German',
 }
 
+export const RESPONSE_ADDRESS = { informal: 'informal', formal: 'formal' } as const
+
+export type ResponseAddress = (typeof RESPONSE_ADDRESS)[keyof typeof RESPONSE_ADDRESS]
+
+/**
+ * How a skill's reply addresses the user, as the words a kit rule gives the agent. German and the other languages
+ * that tell a familiar from a polite "you" name the pronoun and the possessive; English has one form and only
+ * differs in tone.
+ */
+export const ADDRESS_FORM: Record<PlanLanguage, Record<ResponseAddress, string>> = {
+  [PLAN_LANGUAGE.en]: {
+    [RESPONSE_ADDRESS.informal]: 'the plain, direct “you”, without titles',
+    [RESPONSE_ADDRESS.formal]: 'a polite, businesslike “you”',
+  },
+  [PLAN_LANGUAGE.de]: {
+    [RESPONSE_ADDRESS.informal]: 'the familiar “du” (du, dir, dein), never “Sie”',
+    [RESPONSE_ADDRESS.formal]: 'the polite “Sie” (Sie, Ihnen, Ihr), never “du”',
+  },
+}
+
 /**
  * The option of the pull request question that approves the PR and a merge by the coordinator once the checks are
  * green. The merge guard hook matches the user's answer against this exact text, so it is fixed per language and not