jackherd 1.5.0 → 1.6.1

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.6.1
+
+- **The README's guard section is split.** The head says the coordinator asks before every commit, push and merge, and "Guarded commands and self-merge" is split into What is guarded, Self-merge, Merging without checks and Limits. Points 4 and 7 of "What the coordinator does" are lists. The behaviour is unchanged.
+- **Dates and times in a record are read from the clock.** The `orchestrate` skill now says in § 4 that a date or time written into a plan, the board or a history entry comes from `date`, run in the same turn, never from the conversation or a guess; the self-merge note, the closing note and the hand-over note in § 5, § 7 and § 8 point to it.
+
+## 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

@@ -15,7 +15,7 @@ you lose track of who waits on you. Jack:
 
 - 📄 **Keeps the plan in your repository.** Your agent writes it as Markdown, phases with a model each, and ticks it off as it builds.
 - ⚡ **Herds the lanes.** Each lane works in its own git worktree, so sessions never share a checkout.
-- ❓ **Brings you only the decisions.** A coordinating session answers what the plan settles, vets review feedback on its pull requests, asks you the rest as a choice, and asks you before every commit and push.
+- ❓ **Brings you only the decisions.** A coordinating session answers what the plan settles, vets review feedback on its pull requests, asks you the rest as a choice, and asks you before every commit, push and merge.
 - 💬 **Barks when something moves.** One live view of every lane: state, progress, pull request, checks, with the preview link and new feedback as badges; `/follow` brings in tickets, issues and status pages outside GitHub.
 - 🧠 **Watches the context.** It measures each agent session's fill and, before it is full, offers a fresh chat that takes over the state.
 
@@ -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.
 
@@ -497,10 +497,17 @@ Lanes ask Jack, not you: the coordinator checks their questions against the plan
 1. **Reads the board.** The `## Lanes` table names each lane, its port, the plan and phases it works on, what it starts after, and the model. It is the only place that says which lane runs which phase. The coordinator adds a row itself when a lane starts without one.
 2. **Starts ready lanes.** A phase is ready when its starts-after entry and the plan's dependencies are met and its `Writes` set and serial markers collide with no running lane; shared paths run one after the other, migrations strictly in order. For each lane it creates a worktree from the base branch, copies the untracked files every worktree needs, installs dependencies, starts the agent on the board's model, checks the banner shows that model, opens a plan pane beside it, and sends the lane prompt: plan, phases, the paths it may write, its port.
 3. **Runs dev servers.** A lane whose phase changes something a user sees gets its dev server in a pane of its own when the lane starts, never in the lane's shell.
-4. **Vets questions.** A lane never opens a dialog. It ends its turn with a text block: the question, the options, its recommendation, the evidence at `file:line`. The coordinator checks the premises against the code and the plan, answers what the plan or a rule already settles, and brings only the open decisions to you, each as a clickable choice. A question in a lane's report is closed in the same turn, in the lane or with you. A draft you review (a README, a page) goes in rounds: you pick the remarks, the lane changes it, you see it again, and the push waits for your approval. Your decision goes into the plan or the board in the same turn, with the date, so it is visible in the plan view and survives the chat.
+4. **Vets questions.** A lane never opens a dialog; it ends its turn with a text block. The coordinator checks the premises against the code and the plan and brings the open decisions to you, each as a clickable choice.
+   - The block holds the question, the options, the lane's recommendation and the evidence at `file:line`.
+   - A question in a lane's report is closed in the same turn, in the lane or with you.
+   - A draft you review (a README, a page) goes in rounds: you pick the remarks, the lane changes it, you see it again, and the push waits for your approval.
+   - Your decision goes into the plan or the board in the same turn, with the date, so it is visible in the plan view and survives the chat. The date and time come from `date`, never from the chat or a guess.
 5. **Reviews results.** When a lane is `done` or `idle`, it checks the diff against the lane's `Writes` set and that checks are quoted with numbers, not claimed. Then it starts the lane's next ready phase or names the reason to wait.
 6. **Asks once per PR.** A lane works uncommitted until its PR is ready. The coordinator then asks you once, with the diff summary, the checks with numbers, open points and the commit message; for a visible change it first walks the changed path in the browser. That approval covers the commits, the push and the PR. The question has three options: you merge, you approve and let the coordinator merge once the checks are green ([self-merge](#user-content-guarded-commands-and-self-merge)), or you change something first.
-7. **Keeps the merge order.** Merge order is the board's, and the documentation PR of a fresh plan merges first. Afterwards the lanes rebase as after any merge, and the coordinator removes the copies of the plan files in the main checkout that equal the merged ones, so the next update of the checkout does not stop on them. After each merge the remaining lanes fetch and rebase on the base branch and re-run their checks; a lock-file conflict is never resolved by hand. Each lane gets its next phase or a named reason to wait.
+7. **Keeps the merge order.** Merges follow the board's order, the documentation PR of a fresh plan first. After each merge:
+   - the remaining lanes fetch and rebase on the base branch and re-run their checks; a lock-file conflict is never resolved by hand.
+   - the coordinator removes the copies of the plan files in the main checkout that equal the merged ones, so the next update of the checkout does not stop on them.
+   - each lane gets its next phase or a named reason to wait.
 8. **Closes lanes.** After a lane's last merge and your agreement, it ends the agent, proves the worktree holds nothing unmerged, removes the worktree and the branch, and notes the end in the board.
 
 #### What happens on its own, and what waits for you
@@ -516,7 +523,11 @@ Who merges follows the project's own rules: by default you, unless the project s
 
 #### Guarded commands and self-merge
 
-A merge or a release is the step nobody takes back. In a project install the `merge-guard` hook asks you before `gh pr merge` and `gh workflow run` (the usual production release) run: it recognises them when the command spells them out: behind options before the verb (`gh -R x pr merge`), a chain (`a && gh pr merge 12`), a wrapper (also one it does not know, such as `mise exec -- gh pr merge 12`, as any command whose words contain the guarded words in this order), `sh -c` and `eval`, and shows the dialog even in auto mode. A quoted text that names the words, such as a commit message, passes, and so does everything else; the hook prints nothing unless it asks.
+A merge or a release is the step nobody takes back.
+
+##### What is guarded
+
+In a project install the `merge-guard` hook asks you before `gh pr merge` and `gh workflow run` (the usual production release) run. It recognises them when the command spells them out: behind options before the verb (`gh -R x pr merge`), a chain (`a && gh pr merge 12`), a wrapper, known or not (any command whose words contain the guarded words in this order, such as `mise exec -- gh pr merge 12`), `sh -c` and `eval`. It shows the dialog even in auto mode. A quoted text that names the words, such as a commit message, passes, and so does everything else; the hook prints nothing unless it asks.
 
 ```json
 {
@@ -531,7 +542,15 @@ A merge or a release is the step nobody takes back. In a project install the `me
 - `guard.selfMerge.offer` (default `true`) lets `/orchestrate` offer "approve, and merge it yourself after green checks" in its PR question. With `false` the question has two options and the hook honours no such answer.
 - `guard.selfMerge.approvalMinutes` (default 180) is how long that answer lets `gh pr merge <number>` pass without a second dialog.
 
-**Merging without checks.** A pull request that only changes documents rarely needs its checks. List the paths in `merge.withoutChecks` (default empty, so every merge waits for the checks as before):
+##### Self-merge
+
+You pick the second option of the PR question. The coordinator commits, pushes and opens the PR, waits for the checks in the background, merges with `gh pr merge <number> --squash --delete-branch` when they are green and tells you in one line; on a red check it does not merge and reports. The project supplement can block the option per approval tier.
+
+The hook does not take the agent's word for your answer. It reads the session's transcript, which Claude Code writes, and looks for a dialog result where you picked that exact option for a question naming one branch. Then it asks GitHub which branch pull request `<number>` carries and lets the merge pass if the two match, the PR is open and not from a fork, and the command is exactly the plain form: `gh pr merge <number>` with `--squash`, `--merge`, `--rebase` and `--delete-branch` as the only flags, run on its own in the directory you work in (no `-R`, no `--admin`, no chain, no wrapper). `gh workflow run` and every other guarded command ask every time. The approval covers the branch, not the commits you saw, for the configured minutes.
+
+##### Merging without checks
+
+A pull request that only changes documents rarely needs its checks. List the paths in `merge.withoutChecks` (default empty, so every merge waits for the checks as before):
 
 ```json
 {
@@ -539,13 +558,23 @@ A merge or a release is the step nobody takes back. In a project install the `me
 }
 ```
 
-A pattern is made of path words with `*` and `**`: no `..`, not absolute, no braces or negation, and at least one whole path segment without a wildcard, so `docs/**/*.md` is fine and `**`, `**/*.md` and `**/*.*` are refused. Keep the folder in the pattern: a `.md` file elsewhere can be an agent instruction (`CLAUDE.md`, a skill) that ships with a package and deserves its checks. With the list set, `/orchestrate` lists a pull request's files with `gh pr diff <number> --name-only` before it waits for checks and merges at once when every file matches. The merge guard checks the same itself: for a plain `gh pr merge <number>` it asks GitHub for the pull request and then for its files in that repository (`gh api …/pulls/<number>/files`, which also names the old path of a renamed file) and does not ask you when the pull request is open, from this repository, GitHub lists as many files as the pull request changes (fewer than 3000) and every one matches a pattern. This works without a self-merge answer, also when `guard.selfMerge.offer` is `false`. No file, one file outside, a count that differs, a failed `gh` call or a pattern list it cannot read means it asks as before. Limit: a push between its look and the merge is not seen.
+A pattern is made of path words with `*` and `**`: no `..`, not absolute, no braces or negation, and at least one whole path segment without a wildcard, so `docs/**/*.md` is fine and `**`, `**/*.md` and `**/*.*` are refused. Keep the folder in the pattern: a `.md` file elsewhere can be an agent instruction (`CLAUDE.md`, a skill) that ships with a package and deserves its checks.
+
+With the list set, `/orchestrate` lists a pull request's files with `gh pr diff <number> --name-only` before it waits for checks and merges at once when every file matches.
+
+The merge guard checks the same itself: for a plain `gh pr merge <number>` it asks GitHub for the pull request and then for its files in that repository (`gh api …/pulls/<number>/files`, which also names the old path of a renamed file). It does not ask you when the pull request is open, from this repository, GitHub lists as many files as the pull request changes (fewer than 3000) and every one matches a pattern. This works without a self-merge answer, also when `guard.selfMerge.offer` is `false`. No file, one file outside, a count that differs, a failed `gh` call or a pattern list it cannot read means it asks as before.
+
+##### Limits
+
+The hook reads the command as written, so it does not see what a command runs behind its back: a script file or a project script (`bash ./release.sh`, `./release.sh`, `bun run release`, `make release`) that calls `gh workflow run`, a shell alias or function, `gh alias` and git aliases, text that is encoded or assembled at run time, and a wrapper that spells the words differently. Add the script runners you use to `guard.commands`, or protect the repository itself.
 
-**What self-merge does.** You pick the second option of the PR question. The coordinator commits, pushes and opens the PR, waits for the checks in the background, merges with `gh pr merge <number> --squash --delete-branch` when they are green and tells you in one line; on a red check it does not merge and reports. The project supplement can block the option per approval tier.
+The agent runs with your account, so it can also edit a transcript, drop the hook from `.claude/settings.json` or merge through `gh api`. The guard stops a merge or a release by mistake, by a misread instruction or a mistyped command; it does not stop an agent that sets out to get around it. For that, use branch protection and required reviews on the repository.
 
-**What the hook checks.** It does not take the agent's word for your answer. It reads the session's transcript, which Claude Code writes, and looks for a dialog result where you picked that exact option for a question naming one branch. Then it asks GitHub which branch pull request `<number>` carries and lets the merge pass if the two match, the PR is open and not from a fork, and the command is exactly the plain form: `gh pr merge <number>` with `--squash`, `--merge`, `--rebase` and `--delete-branch` as the only flags, run on its own in the directory you work in (no `-R`, no `--admin`, no chain, no wrapper). `gh workflow run` and every other guarded command ask every time.
+- The merge-without-checks look is a snapshot: a push between its look and the merge is not seen.
+- A global install ships no hook, so there the skill text alone asks you.
+- If Bun cannot start (a process out of file descriptors, say), the hook cannot run and every Bash call is blocked, on purpose: a guard that cannot run does not wave commands through.
 
-**Its limit.** The hook reads the command as written, so it does not see what a command runs behind its back: a script file or a project script (`bash ./release.sh`, `./release.sh`, `bun run release`, `make release`) that calls `gh workflow run`, a shell alias or function, `gh alias` and git aliases, text that is encoded or assembled at run time, and a wrapper that spells the words differently. Add the script runners you use to `guard.commands`, or protect the repository itself. The agent runs with your account, so it can also edit a transcript, drop the hook from `.claude/settings.json` or merge through `gh api`. The guard stops a merge or a release by mistake, by a misread instruction or a mistyped command; it does not stop an agent that sets out to get around it. For that, use branch protection and required reviews on the repository. The approval covers the branch, not the commits you saw, for the configured minutes. A global install ships no hook, so there the skill text alone asks you. If Bun cannot start (a process out of file descriptors, say), the hook cannot run and every Bash call is blocked, on purpose: a guard that cannot run does not wave commands through.
+##### Dialogs inside a lane
 
 A permission dialog inside a lane the coordinator confirms itself only for the commit and push of the lane's own branch under its PR approval, and for the fetch, rebase and lock-file steps after a merge, always with the one-time option. Every other dialog goes to you.
 
@@ -933,7 +962,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 +1106,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 +1125,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.1"
 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.1}"
 
 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
@@ -384,7 +388,8 @@ Dim text in the input line is Claude Code's suggestion, not typed input; check w
 **A decision of the user goes into the file at once.** Whatever the user decides about a plan or the
 board (a phase dropped or postponed, the order changed, an approval with its scope, the answer to an
 open question) you write into the plan or the board in the same turn, with the date and
-"User". The plans view reads only these files, so a decision that lives in your memory or hand-over
+"User". **A date or time in a record is read, never estimated:** run `date` in the same turn and write
+what it prints, never a time taken from the conversation or guessed; an agent has no clock. The plans view reads only these files, so a decision that lives in your memory or hand-over
 note is invisible to the user. Where it goes:
 
 - **A lane runs for the plan:** the plan file in that lane's worktree. The view reads it there live;
@@ -519,8 +524,8 @@ included, goes to the user.
 When the user picked `"{{kit.guard.selfMergeLabel}}"` for a PR:
 
 1. Commit, push and open the PR as in step 4. Enter in the board's `{{kit.heading.history}}` that the
-   user approved this PR with self-merge (time, lane, PR number), so the approval has a record outside
-   the chat.
+   user approved this PR with self-merge (time, lane, PR number; the time as § 4 reads it), so the
+   approval has a record outside the chat.
 2. **Merging without checks.** The paths a PR may carry to be merged without waiting for checks are
    `{{kit.merge.withoutChecks}}` (`merge.withoutChecks` in the config; `none` means every merge waits).
    Unless `none`, list the PR's files with `gh pr diff <n> --name-only` and compare each one with the
@@ -584,7 +589,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 (the date as § 4 reads it), 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.
 
@@ -615,7 +622,7 @@ fill of each lane shows in the plans view and comes from the session log
   no value: tell the user in one line and never read it as `ok`. On `coordinator warn` or above, hand yourself over to a fresh chat, at a
   quiet moment (no merge or rebase half done):
   1. **Prepare.** Record your hand-over where the project supplement says, by default in the
-     board's `{{kit.heading.history}}`: the state of every lane, what waits on the user, the next
+     board's `{{kit.heading.history}}` (dated as § 4 reads it): the state of every lane, what waits on the user, the next
      step, the traps. It holds the hand-over only: a decision of the user that is not yet in a plan or
      the board belongs there first (§ 4), not into the note. Write the prompt for the new chat to `.claude/handover/coordinator.md`: what to
      read first, then the steps in order. It is read, not typed, so it may be long.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jackherd",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "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