jackherd 1.7.0 → 1.7.1

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 What changed for people who use jackherd, newest first.
 
+## 1.7.1
+
+- **`jh update` no longer installs the kit into a project.** It synced every project with a `.jackherd/config.json`, including one that holds only settings for the global install, and so wrote kit files, hooks in `.claude/settings.json`, a `.gitignore` line and `.jackherd/lock.json` there unasked. Now it syncs only a project with an install of its own (`.jackherd/lock.json`, or the lock from before the rename); for any other it prints one line that it was not synced and that `jh init` installs the kit there.
+- **`jh sync` refuses a project without an install.** In a directory with a `.jackherd/config.json` but no project install it used to install the kit like `jh init`. Now it exits 2, writes nothing and names `jh init` (installs the kit here) and `jh sync --global` (updates the global kit). `jh sync --check` refuses the same way; `jh init` is unchanged.
+
 ## 1.7.0
 
 - **Tickets show beside their plan.** A `watch.sources` entry with `"ticket": true` marks its entries as tickets, and the herd shows each as a badge in the 📎 line of its lane's plan, right after `📄 Plan`: `📡 T-123 · In Progress`, linked to the ticket. A ticket belongs to the source's `lane`, and to any lane whose name, board row or plan names its id as a whole word, so one source of all your open tickets needs no `lane`. The status comes from the new field `map.status`; without it the badge shows the key alone. A ticket whose last change was reported within a day is amber, and a folded lane then shows `📡 <n>` in amber. At most three per lane, new ones first, then `+<n>`; a link chip with the same URL gives way to the badge. The badges come from the watcher's saved state, which now keeps URL, status and change time of a marked source's entries; without a running watcher there are none, and the header says so. `/follow` asks whether a source holds tickets and finds the path of their status itself, for you to approve with the entry.

package/INSTALL.md

@@ -58,7 +58,7 @@ When `init` creates a new config, it asks:
 | Config | `.jackherd/config.json` | `~/.jackherd/config.json`, used where a repository has none |
 | Update | `jh sync` | `jh update` |
 
-A project config always wins over the global one. Both can exist side by side: in a project with its own kit, the project's skills are the ones in use.
+A project config always wins over the global one. Both can exist side by side: in a project with its own kit, the project's skills are the ones in use. A `.jackherd/config.json` without a project install (no `.jackherd/lock.json`) holds settings for the global install: `jh sync` refuses to run there and names `jh init`, which installs the kit, and `jh sync --global`, which updates the global one; `jh update` leaves the project alone.
 
 ## Project install
 
@@ -137,7 +137,7 @@ The global skills cannot carry one repository's values, so `sync --global` write
 
 ## Updating
 
-`jh update` asks npm for the newest release and, when there is one, installs exactly that version, from your home directory and without install scripts, with the package manager that installed the kit globally (bun, npm, pnpm or yarn, read from where the package lies), then syncs `~/.claude` and, inside a project, the project with the freshly installed code. It prints the old and the new version. A kit that is a project dependency or a source checkout is not a global install, and `update` says so and changes nothing; there, update the dependency and run `jh sync`.
+`jh update` asks npm for the newest release and, when there is one, installs exactly that version, from your home directory and without install scripts, with the package manager that installed the kit globally (bun, npm, pnpm or yarn, read from where the package lies), then syncs `~/.claude` and, inside a project with its own install (`.jackherd/lock.json`), the project with the freshly installed code. A project that has only a `.jackherd/config.json` for the global install is not synced; one line says so, and `jh init` installs the kit there. It prints the old and the new version. A kit that is a project dependency or a source checkout is not a global install, and `update` says so and changes nothing; there, update the dependency and run `jh sync`.
 
 A running herd restarts itself with the new code, and a running `watch` prints `=== kit updated <old> → <new>` and ends, so the coordinator reads its skill again and starts the stream again.
 

package/README.md

@@ -1023,8 +1023,8 @@ At `warn` a lane offers a fresh chat at its next phase boundary, and the watcher
 | ------- | ------------ | ------- |
 | `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](https://unpkg.com/jackherd/INSTALL.md); 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 |
+| `jh sync` | Updates the kit files; edited files get a `.kit-new` beside them; refuses a project that has a config but no install of its own | `--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, when it has its own install, the project with the new code | none; does nothing when the installed version is the latest |
 | `jh config` | The values the current repository decides (`test`, `typecheck`, `lint`, `format`, `install`, `dev`, `lockFile`, `baseBranch`), as set or detected | `<name>`: one bare value |
 | `jh check` | Types, lint and tests of the packages you touched, plus the project's own checks; in changed plans, an open checkbox whose `→ P<n>` is not at the end of the line fails, and so does a phase the change adds with tasks but without a review gate (or a `**No review gate:** <reason>` line); in a changed board, a lane row the change adds or edits whose phases cell names no `P<n>` warns; so does one whose phases cell is longer than 250 characters or records a side order of the user (`also (User …`), which belongs as a task in the plan's phase; a phase of a changed plan without a row in its dependency table warns; in a changed plan, a phase whose tasks are all ticked on `origin/<baseBranch>`, that the change does not tick further and that still has open boxes without `→ P<n>` warns | `--skip-slow`: lint and fast checks only; `--parallel <plan>`: only the groups of phases that can run side by side |
 | `jh herd` | Live view of the board's lanes and plans ([Herd](#user-content-herd-and-context)) | `--once`: one frame and exit; `--lane <name>`: one lane; `--ensure`: bring back the missing herd panes beside the coordinator and each lane, and exit; a board path (default: the newest board) |

package/herdr-plugin/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "crossdelta.jackherd"
 name = "jackherd"
-version = "1.7.0"
+version = "1.7.1"
 min_herdr_version = "0.8.2"
 description = "Show the herd, the state 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.7.0}"
+JACKHERD_VERSION="${JACKHERD_VERSION:-1.7.1}"
 
 JACKHERD_PACKAGE='jackherd'
 # Test seam: the terminal the wizard asks its questions on.

package/package.json

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

package/src/config/legacy-names.ts

@@ -21,6 +21,14 @@ export const PROJECT_LEGACY_FILES: readonly Rename[] = [
   { from: LEGACY_MANIFEST_PATH, to: `${TOOL_DIRECTORY}/${MANIFEST_FILE}` },
 ]
 
+/** The lock files that mark a project install in `root`, the old name counting until 2.0.0 like the old config. */
+export const projectLockCandidates = (root: string): string[] =>
+  [`${TOOL_DIRECTORY}/${MANIFEST_FILE}`, LEGACY_MANIFEST_PATH].map((path) => join(root, path))
+
+/** True when `root` holds a project install. A lock counts when it exists; a broken one is the sync's to report. */
+export const hasProjectInstall = (root: string, exists: (path: string) => boolean): boolean =>
+  projectLockCandidates(root).some(exists)
+
 export const PUBLIC_CONTENT_PATH = `${TOOL_DIRECTORY}/public-content.json`
 
 /** Where the public-content facts lay before the rename: below `XDG_CONFIG_HOME`, else `~/.config`. */

package/src/sync/command.ts

@@ -1,4 +1,7 @@
-import { CLI_NAME } from '../version/release'
+import { existsSync } from 'node:fs'
+import { hasProjectInstall } from '../config/legacy-names'
+import { configCandidates } from '../config/location'
+import { CLI_NAME, PACKAGE_NAME } from '../version/release'
 import {
   type CommandContext,
   defaultContext,
@@ -62,6 +65,16 @@ export const parseSyncArgs = (args: string[]): SyncArgs => {
   return { ok: true, accept, global, ifChanged, check }
 }
 
+/**
+ * True when `root` has a project config but no project install: the config holds settings for the global install,
+ * and only `jh init` may turn it into a project install.
+ */
+const isConfigWithoutInstall = (root: string, exists: (path: string) => boolean): boolean =>
+  configCandidates(root).some(exists) && !hasProjectInstall(root, exists)
+
+const notInstalledLine = (root: string): string =>
+  `${CLI_NAME} sync: ${root} has a ${PACKAGE_NAME} config but no project install, so nothing was synced. \`${CLI_NAME} init\` installs the kit here; \`${CLI_NAME} sync ${GLOBAL_FLAG}\` updates the global kit.`
+
 const syncGlobal = (context: CommandContext, accept: string[]): Promise<number> =>
   runWithKit(context, 'sync', async (kit) => {
     const result = await runGlobalSync({ home: context.home, kit, accept, configHome: context.configHome })
@@ -98,6 +111,8 @@ export const runSyncCommand = async (
   const { accept, global, ifChanged, check: dryRun } = parsed
   if (ifChanged) return syncGlobalIfChanged(context, accept, check)
   if (global) return syncGlobal(context, accept)
+  if (isConfigWithoutInstall(context.projectRoot, existsSync))
+    return usageError(context, notInstalledLine(context.projectRoot))
   return runWithKit(
     context,
     'sync',

package/src/update/command.ts

@@ -1,13 +1,14 @@
 /**
  * `jh update`: installs the newest release with the package manager that holds the kit globally,
- * then syncs `~/.claude` (and the project, when the working directory is inside one) with the new code. It
- * runs only when the user or a session that asked the user starts it; no hook runs it.
+ * then syncs `~/.claude` (and the project, when the working directory is inside one with its own install) with
+ * the new code. It runs only when the user or a session that asked the user starts it; no hook runs it.
  *
  *   jh update
  */
 import { existsSync, realpathSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
+import { hasProjectInstall } from '../config/legacy-names'
 import { findProjectRoot } from '../config/location'
 import { defaultUpdateCheck, lockedVersion } from '../sync/if-changed'
 import { locateKit } from '../sync/kit-source'
@@ -50,6 +51,7 @@ const adaptersFor = async (): Promise<UpdateAdapters> => {
     jhOnPath: () => Bun.which(CLI_NAME) !== null,
     home,
     projectRoot: findProjectRoot(process.cwd(), home, existsSync),
+    hasProjectKit: (root) => hasProjectInstall(root, existsSync),
     log: (line) => console.log(line),
   }
 }

package/src/update/update.ts

@@ -1,4 +1,4 @@
-import { CLI_NAME, isNewerVersion, isRelease } from '../version/release'
+import { CLI_NAME, isNewerVersion, isRelease, PACKAGE_NAME } from '../version/release'
 import { installCommand, LEGACY_PACKAGE_NAME, type PackageManager, removeCommand } from './package-manager'
 
 export const UPDATE_EXIT = { ok: 0, error: 1 } as const
@@ -21,8 +21,13 @@ export type UpdateAdapters = {
   /** Whether a `jh` command is on the path; false when only the `@crossdelta/agent-kit` shell carries this jackherd. Asked before and after the install. */
   jhOnPath: () => boolean
   home: string
-  /** The project the working directory belongs to, or null. */
+  /** The project the working directory belongs to (the nearest directory with a project config), or null. */
   projectRoot: string | null
+  /**
+   * True when `root` holds a project install (a lock of its own); a config alone is settings for the global kit.
+   * The lock's existence counts, not its validity: a broken lock is synced, and the sync names the error.
+   */
+  hasProjectKit: (root: string) => boolean
   log: (line: string) => void
 }
 
@@ -34,10 +39,20 @@ const failed = (log: UpdateAdapters['log'], step: string, command: string): numb
   return UPDATE_EXIT.error
 }
 
+const notInstalledLine = (projectRoot: string): string =>
+  `${projectRoot} has a ${PACKAGE_NAME} config but no project install, so it was not synced; \`${CLI_NAME} init\` installs the kit there.`
+
+/** The project `jh update` syncs: only one with an install of its own, since only `jh init` may create one. */
+const installedProject = (adapters: UpdateAdapters): string | null =>
+  adapters.projectRoot && adapters.hasProjectKit(adapters.projectRoot) ? adapters.projectRoot : null
+
 /** The syncs that bring `~/.claude` and the project to the new files, in the order they run. */
-const syncSteps = async (adapters: UpdateAdapters): Promise<{ argv: string[]; cwd: string }[]> => [
+const syncSteps = async (
+  adapters: UpdateAdapters,
+  project: string | null,
+): Promise<{ argv: string[]; cwd: string }[]> => [
   ...((await adapters.hasGlobalKit()) ? [{ argv: [...adapters.kitCli, 'sync', '--global'], cwd: adapters.home }] : []),
-  ...(adapters.projectRoot ? [{ argv: [...adapters.kitCli, 'sync'], cwd: adapters.projectRoot }] : []),
+  ...(project ? [{ argv: [...adapters.kitCli, 'sync'], cwd: project }] : []),
 ]
 
 /**
@@ -59,6 +74,14 @@ const installAndVerify = async (
   return UPDATE_EXIT.error
 }
 
+/** Runs the syncs with the freshly installed code; the first that fails stops the rest and names its command. */
+const syncAfterInstall = async (adapters: UpdateAdapters, project: string | null): Promise<number> => {
+  for (const { argv, cwd } of await syncSteps(adapters, project)) {
+    if ((await adapters.run(argv, cwd)) !== 0) return failed(adapters.log, 'the sync', argv.join(' '))
+  }
+  return UPDATE_EXIT.ok
+}
+
 const doneLine = (adapters: UpdateAdapters, manager: PackageManager, latest: string, jhWasOnPath: boolean): string => {
   if (jhWasOnPath) return `${CLI_NAME} updated ${adapters.installedVersion} → ${latest}.`
   if (adapters.jhOnPath()) return `${CLI_NAME} ${latest} installed globally.`
@@ -88,10 +111,11 @@ const updateToLatest = async (adapters: UpdateAdapters, manager: PackageManager)
   }
   const installed = await installAndVerify(adapters, manager, latest)
   if (installed !== UPDATE_EXIT.ok) return installed
-  for (const { argv, cwd } of await syncSteps(adapters)) {
-    if ((await adapters.run(argv, cwd)) !== 0) return failed(log, 'the sync', argv.join(' '))
-  }
+  const project = installedProject(adapters)
+  const synced = await syncAfterInstall(adapters, project)
+  if (synced !== UPDATE_EXIT.ok) return synced
   log(doneLine(adapters, manager, latest, jhWasOnPath))
+  if (adapters.projectRoot && !project) log(notInstalledLine(adapters.projectRoot))
   return UPDATE_EXIT.ok
 }
 
@@ -99,8 +123,8 @@ const legacyPackageLine = (manager: PackageManager): string =>
   `${LEGACY_PACKAGE_NAME} is still installed globally; ${CLI_NAME} replaces it. Remove it with: ${removeCommand(manager, LEGACY_PACKAGE_NAME).join(' ')}`
 
 /**
- * Installs the newest release with the manager that holds the kit globally, then syncs `~/.claude` and the
- * project with the freshly installed code; a global package from before the rename is named, not removed.
+ * Installs the newest release with the manager that holds the kit globally, then syncs `~/.claude` and an
+ * installed project with the freshly installed code; a global package from before the rename is named, not removed.
  */
 export const runUpdate = async (adapters: UpdateAdapters): Promise<number> => {
   const { manager, log } = adapters