@miroshnik/elves 2026.1020.0 → 2026.1022.0

package/AGENTS.md

@@ -15,7 +15,7 @@ repositories, no colleagues or clients — in files, git history or issues;
 examples are made up. **A skill is `SKILL.md` + `scripts/`** in TypeScript
 under Bun (Agent Skills; README, "Repository layout"); repository specifics
 — local configuration. **Budgets** (standard `canon-size`): this file ≤
-3,000 words, a `SKILL.md` ≤ 2,500, a skill description ≤ 1,024 characters.
+3,000 words, `SKILL.md` ≤ 2,500, a description ≤ 1,024 characters.
 Here — what always applies and where to go; reference — a skill's
 `reference.md` or `--help`, `docs/`.
 
@@ -31,7 +31,7 @@ a release is the owner's step (`elves release`), I cut one only when asked.
   briefly what changed (it lists the skipped releases) and re-read what was
   updated: it applies, not what loaded at the start.
 - **The project is behind** (or git ignores flow files) — `update` in the
-  task's branch: the package version, a few lines.
+  task's branch: the package version.
 - **The project keeps a copy of the flow** — the move is a task of its own,
   one per project (`check` prints its `github task new`): I recommend it and
   ask whether to queue it.
@@ -118,14 +118,15 @@ done. The session can be closed.` · `All done, but there are questions: …` ·
   regression and a fix for a green PR are the same task. A new epic — the
   question «run the dispatcher on epic #M?», without In progress.
 - **A dispatcher** — "do all tasks of epic #M", "fix all High bugs", a "yes"
-  — any session, its task stays; one started for it — in the project folder,
-  not a worktree: executors start from `main`. `github task queue` prints
-  executors' prompts; an executor — a background subagent in its worktree or
-  a cloud session: at most 3 subagents and 5 cloud sessions at once, the
-  owner's number replaces either; failed — a task comment, no restart; an
-  executor session whose task closed — the dispatcher archives it in an auto
-  project, not one still working in the background or awaiting the owner's
-  answer; outside auto the owner closes it.
+  (scope, not merges outside auto) — any session, its task stays; one started
+  for it — in the project folder, not a worktree: executors start from `main`.
+  `github task queue` prints executors' prompts; an executor — a background
+  subagent (own worktree) or a cloud session: at most 3 subagents and 5 cloud
+  sessions at once, the owner's number replaces either; failed — a task
+  comment, no restart; an executor session whose task closed — the dispatcher
+  archives it in an auto project, not one still working in the background or
+  awaiting the owner's answer; outside auto the owner closes it. A batch
+  project — `github batch release`.
 - **The session is named `#<number> <task title>`** (without a task — by
   meaning, no number) as soon as the task is clear (no tool — ask the user):
   `est` links the session to the task by it.
@@ -167,8 +168,8 @@ and worktrees") — otherwise there is no actual.
 ### Epic refresh on task close
 
 Once a task is merged, **a subagent with a fresh context** brings the open
-tasks of its epic in line with what shipped — not the session at peak
-context: `github task actualize <N>` does the mechanics and prints its prompt,
+tasks of its epic in line with what shipped: `github task actualize <N>`
+does the mechanics and prints its prompt,
 in the same turn as `ci-wait merged <PR>` in the background; after both —
 `github task close`. The last line of the answer ("Language"): merged,
 deployed, branch removed, epic refreshed, no questions — "all done, can be
@@ -197,11 +198,12 @@ it.
   rebase and `--force-with-lease` — only on a textual conflict or my own
   changes. **Before merging — `github pr premerge`:** `main` moved after the
   PR's CI — fast checks on the merge with it; red — I fix the root cause;
-  `main` red by itself (exit code 3) — no merge and no fix in the PR: one bug
+  `main` red by itself (code 3) — no merge and no fix in the PR: one bug
   for it, I wait for it to close.
 - A merge that deploys — I wait for the deploy on the merge SHA (`ci-wait`)
-  **before `github task close`**. Others' branches, stacks and unmerged work
-  I don't touch.
+  **before `github task close`**; a batch's — its release's CI, deploy,
+  refresh.
+  Others' branches, stacks and unmerged work I don't touch.
 - Mechanics — the `github` skill, "Git, PRs and merging — mechanics";
   waiting for checks and deploys — `docs/pr-checks.md`.
 
@@ -283,8 +285,8 @@ skill (`canon.md`, `checks.md`).
   skill) at `<service>.<N>.<project>.localhost`, not on a host port; others'
   stacks and busy ports I don't touch — `docs/parallel-checkouts.md`.
 - **A subagent gets a unit of ~50 turns** (one decision's folder, one file,
-  one spec), not a 200-turn zone: with the same ≈ 100k-token preamble its
-  price is quadratic in turns. The assignment has the task
+  one spec), not a 200-turn zone: its price is quadratic in turns. The
+  assignment has the task
   number after the word for "task" or at the start, the epic after the word
   for "epic" ("Language") — so `est` links its work. **Fewer turns:** a file
   in one full read, independent tool calls in one turn.

package/README.md

@@ -178,7 +178,7 @@ An agent's sandbox (Claude Code's Bash) doesn't let bunx write its cache `~/.bun
 
 `install` in a project asks in the terminal whether the agent should do tasks entirely by itself — answer the task's questions by recommendation, commit, push, fix CI and merge its own PR on green checks (default — no); without a terminal — `install --auto` or `--no-auto`, without the flag the previous answer stays. `check` names the mode. With auto, `install` prints a hint for Claude Code: the app rejects a merge without human review in this mode too, and the session merges its own PR by itself only with the `Bash(gh pr merge *)` rule in `permissions.allow` of `~/.claude/settings.json` — the owner adds it, `install` doesn't change the machine's permission settings.
 
-`install` also asks for the **project language** the agent works in: dialog, tasks, prompts, documents; the flow itself is written in English. It is stored in `.agents/elves.json` as `language` — a BCP 47 code (`ru`, `en`, `pt-BR`), `en` by default; an install of a previous version without the field counts as `ru`. Without a terminal — `install --lang <code>`, without the flag the previous language stays; `update` keeps it, `check` and the hook name it. The flow isn't installed into an Elves clone — `install` writes only these two settings there.
+`install` also asks for the **project language** the agent works in: dialog, tasks, prompts, documents; the flow itself is written in English. It is stored in `.agents/elves.json` as `language` — a BCP 47 code (`ru`, `en`, `pt-BR`), `en` by default; an install of a previous version without the field counts as `ru`. Without a terminal — `install --lang <code>`, without the flag the previous language stays; `update` keeps it, `check` and the hook name it. The flow isn't installed into an Elves clone — `install` writes only its manifest there: these two settings, `env` and `batch` carried over as in a project.
 
 <details>
 <summary><b>What goes where</b></summary>
@@ -186,7 +186,7 @@ An agent's sandbox (Claude Code's Bash) doesn't let bunx write its cache `~/.bun
 **Into a project** — thin: no copy of the flow, its agents get the canon and the skills from the machine. Committed with the project:
 
 - `@miroshnik/elves` in `devDependencies` of `package.json` — the exact version of the release, the project's package manager updates its lockfile: the harness and the skills' scripts at the project's version for its tests and CI, colleagues and the cloud session ("The package in a project" below); a project without `package.json` has nothing to pin.
-- `.agents/elves.json` — `auto` — whether the agent runs a task entirely by itself, without a "yes" for commit, push and merge, `language` — the project language, and `env` — the task stack settings of `task-env`.
+- `.agents/elves.json` — `auto` — whether the agent runs a task entirely by itself, without a "yes" for commit, push and merge, `language` — the project language, `env` — the task stack settings of `task-env`, and `batch` — whether a dispatcher merges its tasks into a batch branch instead of `main` (`github task queue`).
 - `.agents/slot.sh` — the machine queue's shim the `package.json` checks source (`slot` below).
 - A block at the top of the project's `AGENTS.md` linking to the canon on the machine, `~/.agents/elves/AGENTS.md` — for the agents that read the project's file.
 - The cloud session's `SessionStart` hook in `.claude/settings.json` (your own settings and hooks stay): in a Claude Code cloud session (`CLAUDE_CODE_REMOTE=true`) it installs a fresh Bun and the flow onto the session's machine and runs `check --hook`, outside the cloud it exits at once — no setup script in the environment is needed (`docs/cloud-sessions.md`).
@@ -258,9 +258,9 @@ Skills are installed onto the machine with the flow (`install -g`); the agent pi
 
 ### [`github`](skills/github/SKILL.md) — project and tasks by the canon
 
-Checks and fixes the GitHub project and the default-branch rule, creates a task with all its fields in one command, shows a task with its epic, blockers, PR checks and open questions in one output and puts an answer at a question, before merging checks the PR's merge with a fresh `main` if it moved after CI, after merging does the epic refresh's mechanics and prints the subagent's prompt, and closes the task in one call — `est` actual, Done, epic and milestone, the task's Compose stacks and its merged branches removed — sets decision labels from the PR diff, names the wait a resumed session restarts for its task, and gives a dispatcher its queue — the ready tasks of an epic or a filter in order, each with the prompt of its executor, a background subagent.
+Checks and fixes the GitHub project and the default-branch rule, creates a task with all its fields in one command, shows a task with its epic, blockers, PR checks and open questions in one output and puts an answer at a question, before merging checks the PR's merge with a fresh `main` if it moved after CI, after merging does the epic refresh's mechanics and prints the subagent's prompt, and closes the task in one call — `est` actual, Done, epic and milestone, the task's Compose stacks and its merged branches removed — sets decision labels from the PR diff, names the wait a resumed session restarts for its task, and gives a dispatcher its queue — the ready tasks of an epic or a filter in order, each with the prompt of its executor, a background subagent; in a batch project the executors merge into the dispatcher's batch branch, and it reaches `main` by one release PR — one full CI run and one deploy.
 
-`github project check` · `github project fix` · `github task new | show | answer | status | drop | actualize | close | resume | queue` · `github pr labels | premerge`
+`github project check` · `github project fix` · `github task new | show | answer | status | drop | actualize | close | resume | queue` · `github batch release` · `github pr labels | premerge`
 
 ### [`est`](skills/est/SKILL.md) — estimates from actuals
 

package/bin/ai-dev.ts

@@ -2,6 +2,9 @@
  * The installer under its name before the rename (#544) — `bin/elves.ts` itself: `update -g` of a release before the
  * rename pulls a `--link` clone and runs `<clone>/bin/ai-dev.ts install -g --link` with the clone's code, and this file
  * keeps that run working — the links, the SessionStart hook and the clone's origin come from the updated clone. Not a
- * command of the package (`bin` in package.json has only `elves`).
+ * command of the package (`bin` in package.json has only `elves`). `bin/elves.ts` runs its command line only as the
+ * entry point — here it is called.
  */
-import "./elves.ts";
+import { main } from "./elves.ts";
+
+process.exitCode = await main(process.argv.slice(2));

package/bin/elves.ts

@@ -42,23 +42,25 @@
  * in a project — only `auto`: whether the agent runs a task entirely by itself — answers to questions by
  * recommendation, commit, push, fixing CI and merging its own PR on green checks (AGENTS.md, "What I do without asking
  * and what needs a yes"), `language` — the language the agent works in in the project: dialog, tasks, prompts,
- * documents (AGENTS.md, "Language"; the flow is written in English), and `env` — the task stack settings of the
- * task-env skill. `install` in a project sets auto and language — by a question in the terminal or by
+ * documents (AGENTS.md, "Language"; the flow is written in English), `env` — the task stack settings of the
+ * task-env skill, and `batch` — the dispatcher's batches (epic #645). `install` in a project sets auto and language — by a question in the terminal or by
  * the flags `--auto` / `--no-auto` and `--lang <code>`; by default auto is "no", the language is `en`, without a
  * terminal and a flag — the previous value, `update` keeps it. An install of a previous version has no `language`
  * field, and the flow before it worked only in Russian: its language is `ru` (`LEGACY_LANGUAGE` of the github skill's
  * language module), `update` writes it. With auto `install` suggests the Claude Code permission rule for the merge
  * (MERGE_HINT) — it doesn't change the machine's settings. The flow isn't installed into an Elves clone (the canon is
- * at its root): `install` writes a single manifest there, with `auto` and `language`.
+ * at its root): `install` writes a single manifest there, with `auto` and `language`, `env` and `batch` carried over as
+ * in a project; `check` there compares nothing but a batch clone's CI (`batchCi`).
  * The project's flow files are committed — the ones the project's git ignores (`.agents/`) the install un-ignores with
  * exceptions in an Elves block at the end of `.gitignore`, `check` reports them as a mismatch (`gitignoreFlow`). A
  * project's compose file `check` holds to the task isolation rules
  * with the task-env skill's command (`composeCheck`): a violation is a mismatch too, `update` doesn't fix it; so is a
  * project with standards or architecture without a `test:spec` script — `check` names the lines (`specScript`); a
- * `test` that runs them a second time next to `test:spec` — an `○` line with `test` without them. The
- * project's checks — the `package.json` scripts `lint`, `typecheck`, `test`, `test:*` — the install wraps in the
- * machine queue, the slot skill (`packageScripts`); if such a script calls turbo and turbo.json doesn't pass the queue
- * variables to tasks, it warns with a ready-made line (`turboEnv`).
+ * `test` that runs them a second time next to `test:spec` — an `○` line with `test` without them; a project with
+ * batches whose CI runs on a PR into a batch branch — a mismatch, `❌` lines (`batchCi`). The project's checks — the
+ * `package.json` scripts `lint`, `typecheck`, `test`, `test:*` — the install wraps in the machine queue, the slot skill
+ * (`packageScripts`); if such a script calls turbo and turbo.json doesn't pass the queue variables to tasks, it warns
+ * with a ready-made line (`turboEnv`).
  *
  * A copy on the machine without `--link` and a project's package version follow Elves releases — tags vYYYY.MM.DD — not
  * main: the bunx package from main is only a launcher — it finds the latest release and restarts from it by SHA
@@ -220,8 +222,8 @@ fixing CI, merge on green checks (auto in .agents/elves.json, default — no); w
 merge — Bash(gh pr merge *) in ~/.claude/settings.json: the owner adds it, install doesn't change the machine's
 settings. --lang <code> — the project language the agent works in: dialog, tasks, prompts, documents (language in
 .agents/elves.json, a BCP 47 code: ru, en, pt-BR); in a terminal — a question, en by default, without the flag and a
-terminal — the previous one. In an Elves clone writes only auto and language, and its cloud hook — with zsh, the flow
-from the clone itself.
+terminal — the previous one. In an Elves clone writes only the manifest — auto and language, env and batch carried
+over as in a project — and its cloud hook — with zsh, the flow from the clone itself.
 -g — onto the machine: the canon in ~/.agents/elves with Claude Code's rules ~/.claude/rules/elves*.md and the global
 rule files of Codex, Gemini CLI, Copilot, OpenCode and Amp linking to it (someone else's file stays), the skills
 (~/.agents/skills, ~/.claude/skills), the SessionStart hook and the elves command in the terminal — in ~/.local/bin or
@@ -239,8 +241,9 @@ Examples:
 elves check --hook
 
 Whether the install is behind, changes nothing: 0 — up to date, 1 — behind, the project's git ignores flow files, its
-compose file breaks task isolation or standards and architecture have no test:spec script, 2 — the check is
-unavailable; the machine's copy and a project's package version are compared with the latest release (from the npm
+compose file breaks task isolation, standards and architecture have no test:spec script or the CI of a project (an
+Elves clone too) with "batch": true runs a workflow on a PR into a batch branch — on.pull_request lets a batch branch in,
+its gate is the checks before a commit and pr premerge (ci.md of the spec skill, «Batches»), 2 — the check is unavailable; the machine's copy and a project's package version are compared with the latest release (from the npm
 package — by restarting from the latest release's package), a --link clone — with origin/main. For a project names the
 mode (auto) and the language, holds the compose file to the task isolation rules (❌ per violation, ○ — not checked: no
 docker compose; the task-env skill), names a test that runs standards and architecture again next to test:spec (○, the
@@ -738,19 +741,16 @@ interface Manifest {
   auto?: boolean;
   language?: string;
   env?: unknown;
+  batch?: unknown;
 }
 
 /**
  * The install's manifest: `.agents/elves.json`, until `update` moves it — the manifest of an earlier release under the
- * flow's former name (FORMER.manifest); missing or broken — empty.
+ * flow's former name (FORMER.manifest); missing or broken — empty. Read by `manifestOf` of the github skill's locale
+ * module — the one reader of the manifest (tests/standards/project-manifest).
  */
 function readManifest(root: string): Manifest {
-  const file = [MANIFEST, FORMER.manifest].map((f) => path.join(root, f)).find((f) => existsSync(f));
-  try {
-    return file ? JSON.parse(readFileSync(file, "utf8")) : {};
-  } catch {
-    return {};
-  }
+  return locale.manifestOf(root).fields as Manifest;
 }
 
 /**
@@ -761,9 +761,9 @@ function readManifest(root: string): Manifest {
  * doesn't compare the SHA and the tag: the install is up to date if what it installs matches (a release that changes
  * only the installer doesn't touch projects). auto and language — the project settings "a task entirely without
  * asking" and the language the agent works in, always written; the machine doesn't have them (undefined). `env` —
- * the project's task stack settings (the task-env skill: HTTP services and their ports): the project writes it, the
- * install carries it over. A dry run doesn't compare them either: editing a field by hand doesn't make the install
- * "behind".
+ * the project's task stack settings (the task-env skill: HTTP services and their ports), `batch` — the dispatcher's
+ * batches (the github skill): the project writes them, the install carries them over. A dry run doesn't compare them
+ * either: editing a field by hand doesn't make the install "behind".
  * The order survives a run cut off midway (an agent's sandbox refuses writes to `.claude/skills`): skills Elves no
  * longer has go while the old manifest still lists them, and the new manifest is written before the copies — a repeat
  * run takes them for the flow's and finishes the install instead of leaving them as someone else's.
@@ -1374,15 +1374,15 @@ const modeLines = (root: string) => [`  tasks: ${autoOf(root) ? "entirely by its
 const CLONE_NOTE = "an Elves clone: the flow isn't installed into it — the canon is at its root";
 
 /**
- * An Elves clone: of the install it gets only the mode and the language, a manifest of two fields, and its cloud hook
- * (`cloudHook`) — the clone carries it in its commit, the install writes the same; the task stack settings (`env`), if
- * the clone has them, are carried over as in a project; the manifest under the former name goes.
+ * An Elves clone: of the install it gets only the manifest — the mode, the language and the fields the project writes
+ * (`env`, `batch`), carried over by the same rule as in a project (`manifestText`) — and its cloud hook (`cloudHook`) —
+ * the clone carries it in its commit, the install writes the same; the manifest under the former name goes.
  */
 function installClone(root: string, auto: boolean, language: string) {
   const file = path.join(root, MANIFEST);
-  const env = readManifest(root).env;
+  const text = manifestText(root, auto, language);
   mkdirSync(path.dirname(file), { recursive: true });
-  writeFileSync(file, JSON.stringify({ auto, language, ...(env === undefined ? {} : { env }) }, null, 2) + "\n");
+  writeFileSync(file, text);
   removeFormer(root, FORMER.manifest);
   note(`${MANIFEST} — auto: ${auto}, language: ${language}; ${CLONE_NOTE}`);
   projectHook(root, true);
@@ -1413,7 +1413,8 @@ const shownPackage = (spec: string | undefined) => (spec === undefined ? `withou
 
 /**
  * A project with a copy of the flow of an earlier release: the canon `.agents/elves/` (under the former name too) or a
- * manifest of a copy — the installed skills, the SHA; a thin project's manifest has only the mode, the language, env.
+ * manifest of a copy — the installed skills, the SHA; a thin project's manifest has only the mode, the language, env
+ * and batch.
  */
 function isCopy(root: string) {
   const m = readManifest(root);
@@ -1457,21 +1458,35 @@ function removeCopy(root: string) {
   if (gone.length) note(`${gone.join(", ")} — removed: ${COPY_NOTE}`);
 }
 
-/** The fields of a project's manifest; the rest are a copy's (`isCopy`). */
-const PROJECT_FIELDS = ["auto", "language", "env"];
+/**
+ * The fields of a project's manifest the project writes itself — the task stack settings (`env`, the task-env skill)
+ * and the dispatcher's batches (`batch`, the github skill's `task queue`, epic #645): the install carries them over.
+ */
+const CARRIED_FIELDS = ["env", "batch"] as const;
+
+/** The fields of a project's manifest: the install's auto and language and the project's own; the rest are a copy's (`isCopy`). */
+const PROJECT_FIELDS: string[] = ["auto", "language", ...CARRIED_FIELDS];
+
+/**
+ * The manifest the install writes — of a thin project and an Elves clone alike (#672): auto and language, the
+ * CARRIED_FIELDS of the current manifest as they are; the fields of a copy go.
+ */
+function manifestText(root: string, auto: boolean, language: string) {
+  const m = readManifest(root);
+  const carried = CARRIED_FIELDS.filter((k) => m[k] !== undefined).map((k) => [k, m[k]]);
+  return JSON.stringify({ auto, language, ...Object.fromEntries(carried) }, null, 2) + "\n";
+}
 
 /**
- * The project's manifest: the mode, the language and the task stack settings (`env`, the task-env skill — the project
- * writes it, the install carries it over); the fields of a copy go, the manifest under the former name moves into it.
- * A dry run doesn't compare the values: auto and language edited by hand don't make the install behind.
+ * The project's manifest (`manifestText`); the manifest under the former name moves into it. A dry run doesn't compare
+ * the values: auto and language edited by hand don't make the install behind.
  */
 function projectManifest(root: string, auto: boolean, language: string) {
   const file = path.join(root, MANIFEST);
-  const m = readManifest(root);
   if (dry) {
-    if (!existsSync(file) || Object.keys(m).some((k) => !PROJECT_FIELDS.includes(k))) change(existsSync(file) ? "~" : "+", file);
+    if (!existsSync(file) || Object.keys(readManifest(root)).some((k) => !PROJECT_FIELDS.includes(k))) change(existsSync(file) ? "~" : "+", file);
   } else {
-    const text = JSON.stringify({ auto, language, ...(m.env === undefined ? {} : { env: m.env }) }, null, 2) + "\n";
+    const text = manifestText(root, auto, language);
     if (!existsSync(file) || readFileSync(file, "utf8") !== text) {
       mkdirSync(path.dirname(file), { recursive: true });
       writeFileSync(file, text);
@@ -1683,10 +1698,10 @@ function rewriteCopyRefs(root: string) {
 }
 
 /**
- * A mention of `.agents` that isn't the thin project's own: the manifest, the shim, `~/.agents` and `$HOME/.agents` of
- * the machine aren't one.
+ * A mention of a path inside `.agents/` (a glob too) that isn't the thin project's own: the directory itself, the
+ * manifest, the shim, `~/.agents` and `$HOME/.agents` of the machine aren't one (#642).
  */
-const COPY_MENTION = /(?<![\w~}-]|~\/|HOME\/|HOME}\/)\.agents(?![\w-])(?!\\?\/(?:elves\\?\.json|slot\\?\.sh)\b)/;
+const COPY_MENTION = /(?<![\w~}-]|~\/|HOME\/|HOME}\/)\.agents\\?\/(?!(?:elves\\?\.json|slot\\?\.sh)\b)[\w*.{]/;
 
 /**
  * What still names `.agents` once the copy is gone: exceptions `.agents/**` in linters, formatters and configs aren't
@@ -1865,7 +1880,7 @@ function inside(dir: string, p: string) {
 function ownCommand(file: string) {
   const st = lstat(file);
   if (st?.isSymbolicLink()) {
-    const to = readlinkSync(file);
+    const to = path.resolve(path.dirname(file), readlinkSync(file));
     return /(?:^|\/)bin\/elves\.ts$/.test(to) && !to.split("/").includes("node_modules");
   }
   if (!st?.isFile() || st.size > 4096) return false;
@@ -1940,7 +1955,8 @@ function installCommand(src: string, home: string, linkMode: boolean) {
     note(`${shown(dst)} — ${COMMAND_NOTE}: ${linkMode ? `→ ${target}` : (/^exec (.*) "\$@"$/m.exec(text)?.[1] ?? "")}`);
   }
   const dirs = pathDirs();
-  const first = dirs.slice(0, dirs.indexOf(dir)).map((d) => path.join(d, COMMAND)).find(runnable);
+  // `node_modules/.bin` in the process's PATH is the package manager's (bunx, npx, a script), not the terminal's (#642)
+  const first = dirs.slice(0, dirs.indexOf(dir)).filter((d) => !/(?:^|\/)node_modules\/\.bin$/.test(d)).map((d) => path.join(d, COMMAND)).find(runnable);
   if (first) say(first, `comes first on PATH: elves runs it, not ${shown(dst)} — remove it or put ${shown(dir)} before ${shown(path.dirname(first))} in PATH`);
 }
 
@@ -2191,6 +2207,95 @@ function specScript(root: string): { lines: string[]; missing: boolean } {
   return { lines: [`${lead}; put in "scripts" — test without them, they don't run twice: ${spec}, ${filtered}`], missing: true };
 }
 
+/** Where a batch project's CI is described: the spec skill on the machine (`install -g`). */
+const BATCHES_DOC = "~/.agents/skills/spec/ci.md, «Batches»";
+/** A batch branch for a workflow's `on.pull_request` filter — the name `task queue` gives (the github skill). */
+const BATCH_SAMPLE = "batch/2026-01-01-1";
+
+/**
+ * Whether a workflow gets a run on a PR into `base`, by its `on:` (tests/standards/pr-workflow-run): `yes`, `no` or
+ * `unknown` — not decidable without the PR's diff and event. `pull_request` as a string, in an array, a key with
+ * filters or null; `pull_request_target` runs in the base, not on the PR's head — `no`. The branch filter goes first: a
+ * base it filters out gets no run whatever the diff. Its patterns — GitHub's filter pattern cheat sheet: in order, `!`
+ * at the start drops what the earlier ones took, a later pattern takes it back; `*` — anything but `/`, `**` — anything,
+ * `?`, `+` and `[…]` — as in a regex; a pattern that isn't one takes nothing. Then a paths filter and `types` without
+ * `synchronize` — `unknown`. What follows from the answer is the reader's: `batchCi` — a `❌` line on `yes` and on
+ * `unknown` into a batch branch (a PR into it starts no workflow). A copy — PR_RUN in skills/ci-wait/scripts/wait-ci.sh
+ * (`ci-wait pr` waits on `yes`): ci-wait and the installer don't import each other (tests/standards/skill-imports),
+ * both answer by one table.
+ */
+export function prRun(on: unknown, base: string): "yes" | "no" | "unknown" {
+  const list = (v: unknown) => [v].flat();
+  const takes = (patterns: unknown[]) => {
+    let taken = false;
+    for (const p of patterns) {
+      if (typeof p !== "string") continue;
+      const negated = p.startsWith("!");
+      let re: RegExp;
+      try {
+        re = new RegExp(`^${(negated ? p.slice(1) : p).replace(/[.^$(){}|\\]/g, "\\$&").replace(/\*\*?/g, (m) => (m === "**" ? ".*" : "[^/]*"))}$`);
+      } catch {
+        continue;
+      }
+      if (re.test(base)) taken = !negated;
+    }
+    return taken;
+  };
+  let filter: unknown;
+  if (typeof on === "string" || Array.isArray(on)) {
+    if (!list(on).includes("pull_request")) return "no";
+    filter = {};
+  } else if (on && typeof on === "object" && Object.hasOwn(on, "pull_request")) {
+    filter = (on as Record<string, unknown>).pull_request ?? {};
+  } else return "no";
+  if (!filter || typeof filter !== "object" || Array.isArray(filter)) return "unknown";
+  const f = filter as Record<string, unknown>;
+  if (Object.hasOwn(f, "branches") ? !takes(list(f.branches)) : Object.hasOwn(f, "branches-ignore") && takes(list(f["branches-ignore"]))) return "no";
+  if (Object.hasOwn(f, "paths") || Object.hasOwn(f, "paths-ignore")) return "unknown";
+  if (Object.hasOwn(f, "types") && !list(f.types).includes("synchronize")) return "unknown";
+  return "yes";
+}
+
+/** A workflow's triggers (`Bun.YAML`); not YAML — null: GitHub doesn't run it. */
+function workflowOf(text: string): { on?: unknown } | null {
+  try {
+    const wf: unknown = Bun.YAML.parse(text);
+    return wf && typeof wf === "object" ? wf : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * A batch project's CI (`"batch": true` in the manifest, epic #645; `batchProject` of the locale module — the same
+ * answer as `task queue`'s), a thin project's and an Elves clone's alike (#672): a PR into the batch branch starts no
+ * workflow (#676) — its gate is the checks the executor
+ * runs before a commit and `pr premerge`, the full CI is the release PR's and `main`'s (`BATCHES_DOC`); a run on every
+ * task PR repeats what the executor ran and holds its slot. A mismatch update doesn't fix, as the compose file and
+ * `test:spec`: a `❌` line per workflow of `.github/workflows/*.y(a)ml` that by `prRun` runs on a PR into a batch
+ * branch — `yes`, or `unknown` (a paths filter, `types` without `synchronize`): it may run, the line says so. `no` —
+ * no line: a branch filter that leaves the batch branch out, push only, `pull_request_target`. A workflow that doesn't
+ * parse runs nothing on GitHub either. Not a batch project — CI isn't read.
+ */
+function batchCi(root: string): { lines: string[]; missing: boolean } {
+  if (!locale.batchProject(root)) return { lines: [], missing: false };
+  const dir = ".github/workflows";
+  let files: string[] = [];
+  try {
+    files = readdirSync(path.join(root, dir)).filter((f) => /\.ya?ml$/.test(f)).sort();
+  } catch {
+    // no workflows — nothing runs on a PR into a batch branch
+  }
+  const lines: string[] = [];
+  for (const f of files) {
+    const run = prRun(workflowOf(readFileSync(path.join(root, dir, f), "utf8"))?.on, BATCH_SAMPLE);
+    if (run === "no") continue;
+    const how = run === "yes" ? "runs" : "may run (by the PR's diff or event)";
+    lines.push(`  ❌ ${dir}/${f}: on.pull_request ${how} on a PR into a batch branch — its gate is the checks before a commit and pr premerge, the full CI is the release's; add branches-ignore: ['batch/**'] (${BATCHES_DOC})`);
+  }
+  return { lines, missing: lines.length > 0 };
+}
+
 /** The check failed: what and why. */
 const unavailable = (global: boolean, e: unknown): Result => ({ code: 2, text: `Elves ${global ? "on the machine" : "in the project"}: check unavailable — ${reason(e)}` });
 
@@ -2290,8 +2395,12 @@ function cloudLines(root: string): string[] {
 function check(global: boolean): Result {
   const { home, root, installed } = target(global);
   const where = global ? "on the machine" : "in the project";
-  // an Elves clone has nothing to compare against, but the session mode is needed in it — as in a project
-  if (!installed && !global && isElvesClone(root)) return { code: 0, text: [`Elves ${where}: not installed — an Elves clone, the canon is at its root`, ...cloudLines(root), ...modeLines(root)].join("\n") };
+  // an Elves clone has nothing to compare against, but the session mode is needed in it — as in a project, and so is
+  // the CI of its batches (#672)
+  if (!installed && !global && isElvesClone(root)) {
+    const batch = batchCi(root);
+    return { code: batch.missing ? 1 : 0, text: [`Elves ${where}: not installed — an Elves clone, the canon is at its root`, ...batch.lines, ...cloudLines(root), ...modeLines(root)].join("\n") };
+  }
   if (!installed) return { code: 0, text: `Elves ${where}: not installed`, absent: true };
   const clone = global ? linkedClone(home) : null;
   if (clone) return checkLink(home, clone);
@@ -2306,10 +2415,12 @@ function check(global: boolean): Result {
   const compose = global ? { lines: [], violations: false } : composeCheck(root);
   // standards without test:spec — a mismatch update doesn't add either
   const spec = global ? { lines: [], missing: false } : specScript(root);
-  const project = [...warnings, ...compose.lines, ...spec.lines, ...(global ? [] : cloudLines(root)), ...mode];
+  // a batch project's CI that runs on a PR into a batch branch — a mismatch update doesn't fix either
+  const batch = global ? { lines: [], missing: false } : batchCi(root);
+  const project = [...warnings, ...compose.lines, ...spec.lines, ...batch.lines, ...(global ? [] : cloudLines(root)), ...mode];
   const stale = changes.filter((c) => c.op !== "❌" && c.op !== "!");
   const ignored = changes.filter((c) => c.op === "❌");
-  if (!stale.length && !ignored.length) return { code: compose.violations || spec.missing ? 1 : 0, compose: compose.violations, spec: spec.missing, text: [`Elves ${where}: up to date (${fresh})`, ...project].join("\n") };
+  if (!stale.length && !ignored.length) return { code: compose.violations || spec.missing || batch.missing ? 1 : 0, compose: compose.violations, spec: spec.missing, text: [`Elves ${where}: up to date (${fresh})`, ...project].join("\n") };
   const m = readManifest(root);
   const fixable = ignored.some((c) => !c.manual);
   const lost = "ignores flow files — they are missing from the commit, other checkouts and the cloud session:";
@@ -3034,7 +3145,12 @@ function takeTag(args: string[]): { tag: string | undefined; rest: string[] } {
   return i < 0 ? { tag: undefined, rest: args } : { tag: args[i], rest: args.filter((_, j) => j !== i) };
 }
 
-async function main(argv: string[]): Promise<number> {
+/**
+ * The command line. It runs only as the entry point (`import.meta.main`, as the skills' scripts): a test imports the
+ * installer for `prRun` (tests/standards/pr-workflow-run); the installer under its path before the rename calls it
+ * itself.
+ */
+export async function main(argv: string[]): Promise<number> {
   const [cmd = "", ...args] = argv;
   // a skill's script — at this package's version, the project's: no launcher, the help is the script's
   if (Object.hasOwn(SCRIPTS, cmd)) return runScript(cmd, args);
@@ -3118,4 +3234,4 @@ async function main(argv: string[]): Promise<number> {
   }
 }
 
-process.exitCode = await main(process.argv.slice(2));
+if (import.meta.main) process.exitCode = await main(process.argv.slice(2));