@miroshnik/elves 2026.1019.0 → 2026.1019.1

package/README.md

@@ -155,7 +155,7 @@ No exaggeration: the spec format isn't the main token cost; what costs more is h
 You need `git` and [Bun](https://bun.sh) ≥ 1.2 — the installer (`bunx`) and the skill scripts run under it; a project's CI on Node adds the `oven-sh/setup-bun` step; the `github`, `est` and `dashboard` skills need [`gh`](https://cli.github.com) with the `project` scope (`gh auth refresh -s project`); `task-env` needs Docker with Compose (Docker Desktop on macOS).
 
 ```bash
-# onto the machine — the canon, skills and the hook for every agent it has; or a global package:
+# onto the machine — the canon, skills and the hook for every agent it has, and the elves command on PATH; or a global package:
 # bun add -g @miroshnik/elves && elves install -g
 bunx @miroshnik/elves install -g
 
@@ -193,7 +193,7 @@ An agent's sandbox (Claude Code's Bash) doesn't let bunx write its cache `~/.bun
 - Updating — `update` bumps the package version: `package.json` and the lockfile, a few lines in the branch of the current task, committed with it. A project with a copy of the flow of an earlier release moves to a thin one in a task of its own, one per project — `check` prints its `task new`, the hook names the canon loaded twice until then: `update` removes the copy, its symlinks and `.gitignore` exceptions, leads imports and CI paths into the copy to the package and lists what else names `.agents`.
 - The manifest, the shim, `AGENTS.md` and `.claude/settings.json`, if the project's git ignores them (`.agents/` or `.claude/` in `.gitignore`), are un-ignored by `install` and `update` with exceptions — an Elves block at the end of `.gitignore`, committed with them; what an exception can't un-ignore (a directory excluded by a personal rule), and anything ignored until `update` runs — `❌` in the output of the install and of `check`.
 
-**Onto the machine** (`-g`) — the canon, the skills and the hook: a thin project keeps no copy of the canon, its agents get it from the machine. `~/.agents/elves/` — `AGENTS.md`, `claude/CLAUDE.md`, `docs/*.md`; Claude Code — symlinks `~/.claude/rules/elves.md` and `elves-claude.md` (loaded in every project without the external-imports dialog), `~/.claude/skills` and the `SessionStart` hook in `~/.claude/settings.json`; the other agents — their global rule file linking to the canon (`~/.codex/AGENTS.md`, `~/.gemini/GEMINI.md`, `~/.copilot/copilot-instructions.md`, `~/.config/opencode/AGENTS.md`, `~/.config/amp/AGENTS.md`; a file of your own stays) and `~/.agents/skills`. A project that still has a copy loads the canon twice until it moves — the hook names it. A Claude Code cloud session gets the same from the project's `SessionStart` hook — `npm i -g bun@latest @miroshnik/elves && elves install -g` (the image's Bun lags behind), then `check --hook`; the machine's hook isn't there (the cloud doesn't read `~/.claude/settings.json`), an environment's setup script with the same command is an optional faster start. In an Elves clone with `--link` the machine's canon is the clone; its `.claude/CLAUDE.md` keeps the root `AGENTS.md` from loading a second time.
+**Onto the machine** (`-g`) — the canon, the skills and the hook: a thin project keeps no copy of the canon, its agents get it from the machine. `~/.agents/elves/` — `AGENTS.md`, `claude/CLAUDE.md`, `docs/*.md`; Claude Code — symlinks `~/.claude/rules/elves.md` and `elves-claude.md` (loaded in every project without the external-imports dialog), `~/.claude/skills` and the `SessionStart` hook in `~/.claude/settings.json`; the other agents — their global rule file linking to the canon (`~/.codex/AGENTS.md`, `~/.gemini/GEMINI.md`, `~/.copilot/copilot-instructions.md`, `~/.config/opencode/AGENTS.md`, `~/.config/amp/AGENTS.md`; a file of your own stays) and `~/.agents/skills`. The `elves` command in the terminal — in `~/.local/bin`, or the first directory of `PATH` inside the home directory you can write to: with `--link` a symlink to the clone's `bin/elves.ts`, otherwise a shim to the machine's release (`bunx @miroshnik/elves@<version>`) that `update -g` rewrites; an `elves` of your own (a script, a global package) stays, and `check -g` names it, a command missing or of another release, an `elves` earlier on `PATH`, and — when `PATH` has no such directory — the command that adds `~/.local/bin`. A project that still has a copy loads the canon twice until it moves — the hook names it. A Claude Code cloud session gets the same from the project's `SessionStart` hook — `npm i -g bun@latest @miroshnik/elves && elves install -g` (the image's Bun lags behind), then `check --hook`; the machine's hook isn't there (the cloud doesn't read `~/.claude/settings.json`), an environment's setup script with the same command is an optional faster start. In an Elves clone with `--link` the machine's canon is the clone; its `.claude/CLAUDE.md` keeps the root `AGENTS.md` from loading a second time.
 
 **Personal configuration** — everything that depends on specific repositories (the registry for `est`, your own model prices, notes) — lives outside the flow, in `~/.config/elves`; another directory — the `ELVES_CONFIG_DIR` variable, read by all skill scripts. `ELVES_PRIVATE=<path>` with `install -g` makes `~/.config/elves` a symlink to a private checkout; with `ELVES_CONFIG_DIR` the symlink isn't needed — the variable points at the checkout itself.
 

package/bin/elves.ts

@@ -6,7 +6,8 @@
  *
  *   bunx @miroshnik/elves install                      — into the project: the git root (or the current directory)
  *   bunx @miroshnik/elves install -g                   — machine-wide: the canon, skills and hook
- *   elves install -g                                   — the same from the npm package (npm i -g @miroshnik/elves)
+ *   elves install -g                                   — the same from the npm package (npm i -g @miroshnik/elves);
+ *                                                        install -g puts the elves command on PATH (`installCommand`)
  *   bun <Elves clone>/bin/elves.ts install -g --link   — from a clone: symlinks to the clone, edits show at once
  *   bunx @miroshnik/elves check [-g]                   — is the install behind: 0 — no, 1 — yes, 2 — can't tell
  *   bunx @miroshnik/elves update [-g]                  — bring the install up to date
@@ -76,7 +77,7 @@
  * proxy name) instead of holding copies. No dependencies, only node: APIs.
  */
 import { execFileSync, spawnSync } from "node:child_process";
-import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, readSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { accessSync, constants as fsConstants, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, readSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { isatty } from "node:tty";
@@ -223,7 +224,10 @@ terminal — the previous one. In an Elves clone writes only auto and language,
 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) and the SessionStart hook; without a terminal too — a cloud session's project hook
+(~/.agents/skills, ~/.claude/skills), the SessionStart hook and the elves command in the terminal — in ~/.local/bin or
+the first directory of PATH inside the home directory that can be written: with --link a symlink to the clone's
+bin/elves.ts, otherwise a shim to the machine's release (bunx ${PACKAGE}@<version>); someone else's elves there stays
+(!), no such directory — no command, check -g names how to add one; without a terminal too — a cloud session's project hook
 or setup script (CLAUDE_CODE_REMOTE=true) gets the canon and skills without the hook: the cloud doesn't read
 ~/.claude/settings.json. From the npm package (npm i -g / bun add -g ${PACKAGE}) — the release of its version, without
 the network. --link — from an Elves clone: symlinks to the clone instead of copies, edits show up immediately.
@@ -242,7 +246,9 @@ mode (auto) and the language, holds the compose file to the task isolation rules
 docker compose; the task-env skill), names a test that runs standards and architecture again next to test:spec (○, the
 ready test without them) and warns (!) if a script in slot calls turbo and turbo.json doesn't pass the queue variables
 to tasks or a line leads into a file of the flow copy that update doesn't rewrite — the file, the line number and its
-text (the exit code stays the same); a thin project behind — update in this session's task (the package version in
+text (the exit code stays the same); for the machine the elves command missing or of another release is falling
+behind, someone else's elves in its place or one earlier on PATH — !, no directory for it — ! with the command that
+adds ~/.local/bin to PATH; a thin project behind — update in this session's task (the package version in
 package.json and the lockfile), a project with a copy of the flow — the move to a thin project in a task of its own: the
 task new command of the github skill, one task per project. For the machine names the task-env proxy of *.localhost
 addresses — running, not running or running
@@ -260,7 +266,7 @@ Examples:
   update: `elves update [-g]
 
 Brings it up to date: a --link clone — git pull --ff-only, the machine's copy — install of the latest release: the
-canon, the skills and the hook; a project — install of the latest release: ${PACKAGE} in package.json and the
+canon, the skills, the hook and the elves shim of that release; a project — install of the latest release: ${PACKAGE} in package.json and the
 lockfile, a few lines in the branch of the current task; a project with a copy of the flow moves to a thin one (install
 --help), by hand after it — a check of the project that knows the queue wrapper by the copy's path (. .agents/slot.sh
 now), AI_DEV_SLOT* in the project's code → ELVES_SLOT*, formatting the shortened imports, git add -A before the first
@@ -1794,6 +1800,150 @@ function agentRules(home: string, has: (dir: string, cmd?: string) => boolean) {
   }
 }
 
+/**
+ * The `elves` command in the terminal (#632): `bunx @miroshnik/elves …` and `bun <clone>/bin/elves.ts …` aren't a
+ * command, and the global package's bin directory (`~/.bun/bin`) may not be on PATH at all — Bun from Homebrew.
+ * Where — `commandDir`; what — with `--link` a symlink to the clone's `bin/elves.ts` (its `sh` shebang works through a
+ * symlink), otherwise a shim to the machine's release through bunx (`commandShim`): the bunx directory is temporary,
+ * and the command matches the canon on the machine — `update -g` rewrites it with the release. Ours (`ownCommand`) is
+ * replaced; someone else's `elves` in that directory — a script of the user's, a global package — stays with a `!`
+ * line, and so does an `elves` earlier on PATH that the shell runs instead. No directory for it — no command: the `!`
+ * line of `check -g` has the command that adds `~/.local/bin` to PATH. Not in a cloud session: there the flow comes
+ * by `npm i -g` (`CLOUD_FLOW`), and its `elves` is the command.
+ */
+const COMMAND = "elves";
+/** The shim's line by which the install knows its own file. */
+const COMMAND_MARK = "# Elves: the machine's elves command";
+/** What a dry run names next to the command's path. */
+const COMMAND_NOTE = "the elves command in the terminal";
+
+/** PATH directories: absolute, in order, without repeats. */
+const pathDirs = () => [...new Set((process.env.PATH ?? "").split(path.delimiter).filter((d) => path.isAbsolute(d)).map((d) => path.resolve(d)))];
+
+/** A directory the install can write into. */
+function writableDir(dir: string) {
+  try {
+    accessSync(dir, fsConstants.W_OK);
+    return statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/** A file the shell runs: a regular file (through symlinks) with the execute bit. */
+function runnable(file: string) {
+  try {
+    accessSync(file, fsConstants.X_OK);
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/** Under dir, dir itself aside — by the path as given or by the real one (macOS /var → /private/var). */
+function inside(dir: string, p: string) {
+  const real = (x: string) => {
+    try {
+      return realpathSync(x);
+    } catch {
+      return x;
+    }
+  };
+  return [
+    [dir, p],
+    [real(dir), real(p)],
+  ].some(([d, x]) => {
+    const rel = path.relative(d!, x!);
+    return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+  });
+}
+
+/**
+ * The install's own command: a symlink to a clone's `bin/elves.ts` — not into node_modules, that is a global package;
+ * a clone gone or moved too — or a file with COMMAND_MARK.
+ */
+function ownCommand(file: string) {
+  const st = lstat(file);
+  if (st?.isSymbolicLink()) {
+    const to = readlinkSync(file);
+    return /(?:^|\/)bin\/elves\.ts$/.test(to) && !to.split("/").includes("node_modules");
+  }
+  if (!st?.isFile() || st.size > 4096) return false;
+  try {
+    return readFileSync(file, "utf8").includes(COMMAND_MARK);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The command's directory: where PATH already has ours; otherwise `~/.local/bin` — if PATH has it (missing — the
+ * install creates it); otherwise the first directory of PATH inside the home directory that can be written — not
+ * outside it: system directories need root, and the install doesn't ask for it. null — no such directory on PATH.
+ */
+function commandDir(home: string): string | null {
+  const dirs = pathDirs();
+  const own = dirs.find((d) => ownCommand(path.join(d, COMMAND)));
+  if (own) return own;
+  const mine = dirs.filter((d) => inside(home, d));
+  const local = path.join(home, ".local/bin");
+  if (mine.includes(local) && (!lstat(local) || writableDir(local))) return local;
+  return mine.find(writableDir) ?? null;
+}
+
+/**
+ * The shim of a machine with a copy: the release it was installed from by its npm package — the bunx package of the
+ * same version as the canon; a release unknown — by the SHA (a clone without `--link`, a package pinned by SHA),
+ * without it — the latest release.
+ */
+function commandShim(src: string) {
+  const version = release ? npmVersion(release) : null;
+  const sha = version ? null : sourceSha(src);
+  const spec = version ? `${PACKAGE}@${version}` : sha ? `github:${SOURCE}#${sha}` : PACKAGE;
+  const what = version ? `release ${release}` : sha ? `Elves ${short(sha)}` : "the latest release";
+  return ["#!/bin/sh", `${COMMAND_MARK} — ${what}; set by \`${RUN} install -g\`, update -g rewrites it`, `exec bunx --silent ${spec} "$@"`, ""].join("\n");
+}
+
+/**
+ * No directory for the command: what the owner runs — `~/.local/bin` into PATH in the shell's profile and the same
+ * install with it on PATH.
+ */
+function pathCommand(src: string, linkMode: boolean) {
+  const shell = path.basename(process.env.SHELL ?? "");
+  const profile = shell === "zsh" ? "~/.zshrc" : shell === "bash" ? "~/.bashrc" : "~/.profile";
+  const again = linkMode ? `bun --no-env-file ${shWord(path.join(src, "bin/elves.ts"))} install -g --link` : `${RUN} update -g`;
+  return `mkdir -p ~/.local/bin && echo 'export PATH="$HOME/.local/bin:$PATH"' >> ${profile} && PATH="$HOME/.local/bin:$PATH" ${again}`;
+}
+
+/** The `elves` command (see COMMAND): a dry run names what it would change and the `!` lines. */
+function installCommand(src: string, home: string, linkMode: boolean) {
+  if (remote()) return;
+  const shown = (p: string) => (inside(home, p) ? `~/${path.relative(home, p)}` : p);
+  const say = (file: string, text: string) => (dry ? void change("!", file, { note: text }) : warn(`${shown(file)} — ${text}`));
+  const dir = commandDir(home);
+  if (!dir) {
+    const text = `${COMMAND_NOTE} isn't installed: PATH has no directory inside the home directory that can be written — add ~/.local/bin: ${pathCommand(src, linkMode)}`;
+    return dry ? void change("!", path.join(home, ".local/bin", COMMAND), { note: text }) : void note(text);
+  }
+  const dst = path.join(dir, COMMAND);
+  const st = lstat(dst);
+  if (st && !ownCommand(dst)) return say(dst, `someone else's elves (a script of the user's, a global package) — left as is; the machine's command goes here once it's removed: ${RUN} update -g`);
+  const target = path.join(src, "bin/elves.ts");
+  const text = linkMode ? linkText(target, dst, home) : commandShim(src);
+  const same = linkMode ? Boolean(st?.isSymbolicLink()) && readlinkSync(dst) === text : Boolean(st?.isFile()) && runnable(dst) && readFileSync(dst, "utf8") === text;
+  if (!same && dry) change(st ? "~" : "+", dst, { note: COMMAND_NOTE });
+  else if (!same) {
+    if (st) rmSync(dst);
+    mkdirSync(dir, { recursive: true });
+    if (linkMode) symlinkSync(text, dst);
+    else writeFileSync(dst, text, { mode: 0o755 });
+    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);
+  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`);
+}
+
 /**
  * The URL of a GitHub origin on the repository's name before the rename (LEGACY_SOURCE, the name is case-insensitive) —
  * the same URL on SOURCE: the form, the credentials, the port and `.git` stay; another repository or host — null.
@@ -1835,8 +1985,8 @@ const remote = () => process.env.CLAUDE_CODE_REMOTE === "true";
 /**
  * The machine (#557): the canon `~/.agents/elves/` — a copy or, with `--link`, a symlink to the clone — with Claude
  * Code's rules `~/.claude/rules/elves*.md` (the same `installRules` and `claudeRules` as in a project: what a previous
- * install left under the flow's former name moves), the other agents' rule files (`agentRules`), skills and the hook.
- * Claude Code is on the machine — `~/.claude`, `claude` on PATH or a cloud session: its project hook (`cloudHook`) or
+ * install left under the flow's former name moves), the other agents' rule files (`agentRules`), skills, the `elves`
+ * command in the terminal (`installCommand`) and the hook. Claude Code is on the machine — `~/.claude`, `claude` on PATH or a cloud session: its project hook (`cloudHook`) or
  * its environment's setup script runs in a fresh home. The cloud doesn't read `~/.claude/settings.json` — no hook there.
  */
 function installGlobal(src: string, linkMode: boolean) {
@@ -1879,6 +2029,8 @@ function installGlobal(src: string, linkMode: boolean) {
       note(`${CONFIG} → ${priv}`);
     }
   }
+  // the last step: an agent's sandbox may refuse a directory of PATH — the canon, the skills and the hook are in place
+  installCommand(src, home, linkMode);
 }
 
 /**

package/dist/github/scripts/github.js

@@ -11,12 +11,14 @@ import path from "node:path";
 import { parseArgs } from "node:util";
 var N = locale_default.names(locale_default.projectLanguage());
 var canonViews = () => [
-  { name: N.views.board, layout: "BOARD_LAYOUT" },
-  { name: N.views.table, layout: "TABLE_LAYOUT" },
+  { name: N.views.board, layout: "BOARD_LAYOUT", columns: ["TITLE", STATUS, "LABELS", "SUB_ISSUES_PROGRESS"] },
+  { name: N.views.table, layout: "TABLE_LAYOUT", columns: ["TITLE", STATUS, "LABELS", "ASSIGNEES", "SUB_ISSUES_PROGRESS", N.fields.estimate], groupBy: STATUS },
   { name: N.views.roadmap, layout: "ROADMAP_LAYOUT" }
 ];
+var BUILTIN_COLUMNS = { TITLE: "Title", ASSIGNEES: "Assignees", LABELS: "Labels", SUB_ISSUES_PROGRESS: "Sub-issues progress" };
 var STATUS = "Status";
 var statusOptions = () => [N.status.backlog, N.status.inProgress, N.status.done];
+var STATUS_COLORS = ["GREEN", "YELLOW", "PURPLE"];
 var numberFields = () => [N.fields.estimate, N.fields.actual, N.fields.tokens, N.fields.cost];
 var issueTypes = () => [N.issueTypes.task, N.issueTypes.bug, N.issueTypes.epic];
 var PRIORITY = "Priority";
@@ -36,6 +38,12 @@ var ISSUE_LABEL_LIMIT = 100;
 var WORKFLOW_ADDED = "Item added to project";
 var WORKFLOW_CLOSED = "Item closed";
 var WORKFLOW_AUTO_ADD = "Auto-add to project";
+var WORKFLOW_MERGED = "Pull request merged";
+var WORKFLOW_AUTO_CLOSE = "Auto-close issue";
+var WORKFLOW_SUB_ISSUES = "Auto-add sub-issues to project";
+var WORKFLOW_ARCHIVE = "Auto-archive items";
+var WORKFLOWS = [WORKFLOW_ADDED, WORKFLOW_CLOSED, WORKFLOW_MERGED, WORKFLOW_AUTO_CLOSE, WORKFLOW_AUTO_ADD, WORKFLOW_SUB_ISSUES, WORKFLOW_ARCHIVE];
+var ARCHIVE_FILTER = "is:issue is:closed updated:<@today-2w";
 var DEFAULT_TEMPLATE = "miroshnik/6";
 var RULESET = "elves";
 var FORMER_RULESET = "ai-dev";
@@ -122,6 +130,8 @@ var Q = {
           id number name layout filter
           sortByFields(first: 5) { nodes { direction field { ... on ProjectV2FieldCommon { name } } } }
           verticalGroupByFields(first: 5) { nodes { ... on ProjectV2FieldCommon { name } } }
+          groupByFields(first: 5) { nodes { ... on ProjectV2FieldCommon { name } } }
+          fields(first: 50) { nodes { ... on ProjectV2FieldCommon { id name dataType } } }
         }
       }
       fields(first: 100) {
@@ -650,7 +660,9 @@ function loadProject(io, id, withItems = true) {
       layout: v.layout,
       filter: v.filter ?? null,
       sortBy: (v.sortByFields?.nodes ?? []).map((s) => s.field?.name).filter(Boolean),
-      columnsBy: (v.verticalGroupByFields?.nodes ?? []).map((f) => f?.name).filter(Boolean)
+      columnsBy: (v.verticalGroupByFields?.nodes ?? []).map((f) => f?.name).filter(Boolean),
+      groupBy: (v.groupByFields?.nodes ?? []).map((f) => f?.name).filter(Boolean),
+      columns: (v.fields?.nodes ?? []).filter((f) => f?.id).map((f) => ({ id: f.id, name: f.name, dataType: f.dataType }))
     })),
     fields: p.fields.nodes.filter((f) => f && f.id).map((f) => ({ id: f.id, name: f.name, dataType: f.dataType, isIssueField: !!f.isIssueField, options: f.options ?? null })),
     workflows: p.workflows.nodes.filter(Boolean),
@@ -692,7 +704,12 @@ function analyze(s) {
   for (const other of s.repo.linked.filter((x) => x.id !== p.id)) {
     link(`another project is linked: ${q(other.title)} (${other.url})`, { kind: "confirm", text: `unlink project ${q(other.title)} from the repository`, mutations: [{ op: "UnlinkProject", input: { projectId: other.id, repositoryId: s.repo.id } }] });
   }
-  const views = add("views", `Views ${canonViews().map((v) => q(v.name)).join(", ")} — the right layout, no filter, no others`);
+  const fieldAlias = fieldAliases();
+  const columnKey = (f) => BUILTIN_FIELDS.has(f.dataType) ? f.dataType : fieldAlias[f.name] ?? f.name;
+  const columnName = (key) => p.fields.find((f) => columnKey(f) === key)?.name ?? BUILTIN_COLUMNS[key] ?? key;
+  const columnFields = (keys) => keys.map((k) => p.fields.find((f) => columnKey(f) === k)).filter((f) => !!f);
+  const configuration = (keys) => ({ visibleFieldIds: columnFields(keys).map((f) => f.id) });
+  const views = add("views", `Views ${canonViews().map((v) => q(v.name)).join(", ")} — the right layout, columns and grouping, no filter, no others`);
   const canonNames = new Set(canonViews().map((v) => v.name));
   const spare = p.views.filter((v) => !canonNames.has(v.name));
   for (const c of canonViews()) {
@@ -703,7 +720,8 @@ function analyze(s) {
         spare.splice(spare.indexOf(cand), 1);
         views(`missing ${q(c.name)}`, guarded(`rename view ${q(cand.name)} → ${q(c.name)}`, { op: "UpdateView", input: { viewId: cand.id, name: c.name } }));
       } else {
-        views(`missing ${q(c.name)}`, api(`create view ${q(c.name)} (${c.layout})`, { op: "CreateView", input: { projectId: p.id, name: c.name, layout: c.layout } }));
+        const input = { projectId: p.id, name: c.name, layout: c.layout, ...c.columns ? { configuration: configuration(c.columns) } : {} };
+        views(`missing ${q(c.name)}`, api(`create view ${q(c.name)} (${c.layout})`, { op: "CreateView", input }));
       }
       continue;
     }
@@ -714,13 +732,26 @@ function analyze(s) {
     if (c.layout === "BOARD_LAYOUT" && v.layout === c.layout && v.columnsBy[0] !== STATUS) {
       views(`${q(c.name)} columns not by Status`, ui(`${q(c.name)}: View options → Column by → Status → Save`, `${p.url}/views/${v.number}`));
     }
+    if (c.columns) {
+      const have = v.columns.map(columnKey);
+      const missing = c.columns.filter((k) => !have.includes(k)).map((k) => q(columnName(k)));
+      const extra = v.columns.filter((f) => !c.columns.includes(columnKey(f))).map((f) => q(f.name));
+      if (missing.length || extra.length) {
+        const why = [missing.length ? `missing ${missing.join(", ")}` : "", extra.length ? `extra ${extra.join(", ")}` : ""].filter(Boolean).join("; ");
+        const set = columnFields(c.columns).map((f) => f.name).join(", ");
+        views(`${q(c.name)} columns: ${why}`, api(`${q(c.name)}: columns ${set}`, { op: "UpdateView", input: { viewId: v.id, configuration: configuration(c.columns) } }));
+      }
+    }
+    if (c.groupBy && v.layout === c.layout && v.groupBy[0] !== c.groupBy) {
+      views(`${q(c.name)} not grouped by ${c.groupBy}`, ui(`${q(c.name)}: View options → Group by → ${c.groupBy} → Save`, `${p.url}/views/${v.number}`));
+    }
   }
   for (const v of spare)
     views(`extra ${q(v.name)}`, guarded(`delete view ${q(v.name)}`, { op: "DeleteView", input: { viewId: v.id } }));
-  const status = add("status", `${STATUS}: ${statusOptions().join(" → ")}`);
+  const status = add("status", `${STATUS}: ${statusOptions().join(" → ")} (${STATUS_COLORS.join(", ")})`);
   const sf = p.fields.find((f) => f.name === STATUS && f.options);
   if (!sf) {
-    status(`no ${STATUS} field`, api(`create field ${STATUS}`, { op: "CreateField", input: { projectId: p.id, dataType: "SINGLE_SELECT", name: STATUS, singleSelectOptions: statusOptions().map((name) => ({ name, color: "GRAY", description: "" })) } }));
+    status(`no ${STATUS} field`, api(`create field ${STATUS}`, { op: "CreateField", input: { projectId: p.id, dataType: "SINGLE_SELECT", name: STATUS, singleSelectOptions: statusOptions().map((name, i) => ({ name, color: STATUS_COLORS[i], description: "" })) } }));
   } else if (sf.options.map((o) => o.name).join(`
 `) !== statusOptions().join(`
 `)) {
@@ -730,15 +761,17 @@ function analyze(s) {
       return i < 0 ? null : left.splice(i, 1)[0];
     };
     const aliases = statusAliases();
-    const next = statusOptions().map((name) => {
+    const next = statusOptions().map((name, i) => {
       const o = take((x) => x.name === name) ?? take((x) => aliases[x.name.toLowerCase()] === name);
-      return o ? { id: o.id, name, color: o.color, description: o.description ?? "" } : { name, color: "GRAY", description: "" };
+      return o ? { id: o.id, name, color: STATUS_COLORS[i], description: o.description ?? "" } : { name, color: STATUS_COLORS[i], description: "" };
     });
     const drop = left.length ? `; delete ${left.map((o) => q(o.name)).join(", ")}` : "";
     status(`options: ${sf.options.map((o) => o.name).join(", ") || "none"}`, guarded(`${STATUS}: ${statusOptions().join(", ")} (rename the existing ones keeping the id${drop})`, { op: "UpdateField", input: { fieldId: sf.id, singleSelectOptions: next } }));
+  } else if (sf.options.some((o, i) => o.color !== STATUS_COLORS[i])) {
+    const next = sf.options.map((o, i) => ({ id: o.id, name: o.name, color: STATUS_COLORS[i], description: o.description ?? "" }));
+    status(`colors: ${sf.options.map((o) => `${o.name} ${o.color}`).join(", ")}`, api(`${STATUS}: colors ${STATUS_COLORS.join(", ")} (keeping the id)`, { op: "UpdateField", input: { fieldId: sf.id, singleSelectOptions: next } }));
   }
   const fields = add("fields", `Fields ${numberFields().map(q).join(", ")} (Number), no other custom ones`);
-  const fieldAlias = fieldAliases();
   const renamed = new Set;
   for (const name of numberFields()) {
     const f = p.fields.find((x) => x.name === name);
@@ -804,13 +837,17 @@ function analyze(s) {
       types(`extra ${q(x.name)}`, { kind: "confirm", text: `disable type ${q(x.name)}`, url, mutations: [{ op: "UpdateIssueType", input: { issueTypeId: x.id, isEnabled: false } }] });
     }
   }
-  const wf = add("workflows", `Workflows ${[WORKFLOW_ADDED, WORKFLOW_CLOSED, WORKFLOW_AUTO_ADD].map(q).join(", ")} are on`);
+  const wf = add("workflows", `Workflows ${WORKFLOWS.map(q).join(", ")} are on`);
   const how = {
     [WORKFLOW_ADDED]: `Edit → Set value → ${STATUS}: ${N.status.backlog}`,
     [WORKFLOW_CLOSED]: `Edit → Set value → ${STATUS}: ${N.status.done}`,
-    [WORKFLOW_AUTO_ADD]: `Edit → repository ${s.repo.name}, filter is:issue is:open (Enter)`
+    [WORKFLOW_MERGED]: `Edit → Set value → ${STATUS}: ${N.status.done}`,
+    [WORKFLOW_AUTO_CLOSE]: `Edit → ${STATUS}: ${N.status.done}`,
+    [WORKFLOW_AUTO_ADD]: `Edit → repository ${s.repo.name}, filter is:issue is:open (Enter)`,
+    [WORKFLOW_SUB_ISSUES]: "Edit",
+    [WORKFLOW_ARCHIVE]: `Edit → filter ${ARCHIVE_FILTER} (Enter)`
   };
-  for (const name of [WORKFLOW_ADDED, WORKFLOW_CLOSED, WORKFLOW_AUTO_ADD]) {
+  for (const name of WORKFLOWS) {
     const w = p.workflows.find((x) => x.name === name);
     if (w?.enabled)
       continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miroshnik/elves",
-  "version": "2026.1019.0",
+  "version": "2026.1019.1",
   "type": "module",
   "description": "Elves — a development flow with AI agents: shared rules and skills for any agent; install — bunx @miroshnik/elves install -g; the installer and skill scripts — TypeScript under Bun, tests — bun test in tests/",
   "repository": {
@@ -71,5 +71,5 @@
     "eslint-plugin-boundaries": "^7.2.0",
     "knip": "^6.41.0"
   },
-  "gitHead": "42576112e74dfdc383f64b0edb5e08a24ff4afa2"
+  "gitHead": "672760816ee853bd6c6cedf7bd917a123ee0fb41"
 }

package/skills/github/reference.md

@@ -97,9 +97,15 @@ Every repository has **exactly one** GitHub Project linked to the repo
 per epic/area (an area = an epic inside the shared project). All tasks are
 added to the project right on creation (`github task new`). Required:
 
-- **Three views**, with exactly these names: `Board` (BOARD_LAYOUT, columns
-  by `Status`), `Table` (TABLE_LAYOUT), `Roadmap` (ROADMAP_LAYOUT).
-- **The `Status` field** with options `Backlog` → `In progress` → `Done`.
+- **Three views**, with exactly these names, as in the template:
+  - `Board` (BOARD_LAYOUT, columns by `Status`) — cards show Title, Status,
+    Labels, Sub-issues progress;
+  - `Table` (TABLE_LAYOUT, grouped by `Status`) — columns Title, Status,
+    Labels, Assignees, Sub-issues progress, «Estimate, h»;
+  - `Roadmap` (ROADMAP_LAYOUT).
+- **The `Status` field** with options `Backlog` → `In progress` → `Done`,
+  colored `GREEN`, `YELLOW`, `PURPLE` (a new GitHub project's colors);
+  option descriptions are the project's own.
   I change the status **myself, immediately**, without waiting to be asked
   (`github task status <N> <status>`):
   - a new task — I set Backlog on creation;
@@ -118,12 +124,15 @@ added to the project right on creation (`github task new`). Required:
   (those closed as not planned don't count — they are no longer in the
   project).
   Safety net — the project's built-in workflows "Item added to project" →
-  Backlog, "Item closed" → Done and "Auto-add to project" (new open issues of
-  the repository get into the project by themselves): the status gets set
-  even if there is no one to set it (a cloud session, another agent, closing
-  from the GitHub UI). The agent sets the status anyway; a task closed as not
-  planned it removes from the project — otherwise the workflow puts it into
-  Done.
+  Backlog, "Item closed" and "Pull request merged" → Done, "Auto-close issue"
+  (Done → the issue is closed), "Auto-add to project" (new open issues of
+  the repository get into the project by themselves) and "Auto-add sub-issues
+  to project": the status gets set even if there is no one to set it (a cloud
+  session, another agent, closing from the GitHub UI). The agent sets the
+  status anyway; a task closed as not planned it removes from the project —
+  otherwise the workflow puts it into Done. "Auto-archive items" (`is:issue
+  is:closed updated:<@today-2w`) takes a task closed and untouched for two
+  weeks off the board and the table.
 - **The `Estimate, h` field** (Number) — the agent's active hours
   (`AGENTS.md`, section "Estimate and actual — the `est` skill"). Set **only
   by `github task new`** (the `est` script inside) — from analogs with
@@ -149,8 +158,11 @@ added to the project right on creation (`github task new`). Required:
   unblocked. A personal account has no issue fields — no priority is kept.
   `github task new` sets it (`--priority`, `Medium` by default).
 
-Nothing extra: there are no other fields (Iteration, Readiness…) or views
-until they are added here. Readiness — the status and *blocked by*; stages —
+Nothing extra: there are no other fields (Iteration, Readiness…), views or
+columns until they are added here. What the public API doesn't read — the
+slice by a field, the sub-issue hierarchy, column widths, the project's
+description and README — isn't in the canon: a copy of the template carries
+it, nothing checks it. Readiness — the status and *blocked by*; stages —
 milestones (the `Milestone` field).
 
 The project — the `github` skill: `project check` once per session before
@@ -313,16 +325,23 @@ description is rewritten.
 
 1. The project is linked to the repository, it is the only one, its title =
    the repository name.
-2. Views `Board` (BOARD, columns by `Status`), `Table` (TABLE), `Roadmap`
-   (ROADMAP), filters empty, no others.
-3. `Status`: `Backlog` → `In progress` → `Done`.
+2. Views `Board` (BOARD, columns by `Status`), `Table` (TABLE, grouped by
+   `Status`), `Roadmap` (ROADMAP), filters empty, no others; the columns of
+   `Board` and `Table` — the canon's set (a built-in field by its type, the
+   rest by name), `fix` sets them in the template's order. The roadmap's
+   columns aren't compared: the API gives it the default ones.
+3. `Status`: `Backlog` → `In progress` → `Done`, colors `GREEN`, `YELLOW`,
+   `PURPLE`; descriptions aren't compared.
 4. Fields «Estimate, h», «Actual, h», «Tokens, M», «Cost, $» (Number), no
    custom fields beyond the canon.
 5. Organization only: `Priority` — the organization's issue field, connected,
    `Table` and `Board` are sorted by it; issue types — exactly «Task»,
    «Bug», «Epic». A personal account has none — a `➖` line.
-6. Workflows "Item added to project" (→ Backlog), "Item closed" (→ Done),
-   "Auto-add to project" (`is:issue is:open`) are on.
+6. The template's workflows are on: "Item added to project" (→ Backlog),
+   "Item closed" and "Pull request merged" (→ Done), "Auto-close issue",
+   "Auto-add to project" (`is:issue is:open`), "Auto-add sub-issues to
+   project", "Auto-archive items" (`is:issue is:closed updated:<@today-2w`).
+   Others aren't checked.
 7. Closed tasks — in Done; those closed without being done (not planned,
    duplicate) — outside the project.
 8. The repository's open tasks — in the project, each has a `Status`.
@@ -379,7 +398,8 @@ description is rewritten.
 ### fix: who does what
 
 - **API — the script itself:** linking, a template copy or a new project,
-  missing views and fields, view layout, removing a filter, `Status` options,
+  missing views and fields, view layout and columns, removing a filter,
+  `Status` options and colors,
   the `Priority` issue field, task statuses, adding open tasks, removing tasks
   closed without being done from the project, decision labels (creation,
   color), the default-branch ruleset (creation, editing its own), merge
@@ -409,14 +429,19 @@ description is rewritten.
   deleted (options were replaced without ids): pick it again.
   - "Item added to project": trigger `issue, pull request` (default), Set
     value → `Status: Backlog`.
-  - "Item closed": Set value → `Status: Done`.
+  - "Item closed", "Pull request merged": Set value → `Status: Done`.
+  - "Auto-close issue": `Status: Done` → close the issue.
   - "Auto-add to project": the repository — this project's, filter
     `is:issue is:open`, Enter — the "See N existing items" counter should
     update. Without `is:open` an updated closed task (a not planned one too)
     comes back into the project. Auto-add doesn't add already existing tasks —
     `fix` adds them.
-- **Sorting by Priority, board columns:** the view → the `View` button on the
-  right → `Sort by: Priority` / `Column by: Status` → `Save view` → the dialog
+  - "Auto-add sub-issues to project": nothing to set — Save and turn on.
+  - "Auto-archive items": filter `is:issue is:closed updated:<@today-2w`,
+    Enter.
+- **Sorting by Priority, board columns, table grouping:** the view → the
+  `View` button on the right → `Sort by: Priority` / `Column by: Status` /
+  `Group by: Status` → `Save view` → the dialog
   "Save display options for …?" → `Save`. Escape closes the dialog without
   saving: the sorting stays only in the URL (`?sortedBy…`), and the tab's
   unsaved marker lies — `check` verifies the result.
@@ -435,8 +460,9 @@ description is rewritten.
   Done and leaves a step to check the target in the UI.
 - **`Status` options are renamed keeping the same id**
   (`updateProjectV2Field`, `singleSelectOptions[].id`): task values and the
-  "Item closed" target are kept. Replacing options without ids gives new ids —
-  task statuses vanish, "Item closed" sets the deleted `Done`.
+  "Item closed" target are kept, recoloring too. Replacing options without
+  ids gives new ids — task statuses vanish, "Item closed" sets the deleted
+  `Done`.
 - **The template** — the elves project (`miroshnik/6`): everything the API
   lacks is configured there once. A copy (`copyProjectV2`) carries over views
   with their settings, fields and configured workflows, except auto-add; it
@@ -444,12 +470,16 @@ description is rewritten.
   is unavailable (someone else's account) or `--template none` — the project is
   created from scratch (`createProjectV2`) and brought up via the API:
   `Todo / In Progress / Done` → the canon with the same ids, `View 1` →
-  `Table`, the rest is created.
+  `Table`, the rest is created; the table's grouping is a UI step.
 - **The view filter is empty:** `iteration:@current` without an Iteration field
   silently hides tasks from the board.
 - **`Priority` is the organization's issue field** (`isIssueField`), not a
   project field of the same name. The API reads the sorting (`sortByFields`)
-  but doesn't set it; the board grouping too (`verticalGroupByFields`).
+  but doesn't set it; the board grouping and the table grouping too
+  (`verticalGroupByFields`, `groupByFields`).
+- **A view's columns are set** (`updateProjectV2View`,
+  `configuration.visibleFieldIds` in order) and read (`fields` of the view; a
+  roadmap without configured columns gives the default ones).
 - **A project that has been used** — it has tasks.
 
 ## Task and PR commands — details

package/skills/github/scripts/github.ts

@@ -57,13 +57,27 @@ type Any = any;
  */
 let N: Names = locale.names(locale.projectLanguage());
 
-const canonViews = () => [
-  { name: N.views.board, layout: "BOARD_LAYOUT" },
-  { name: N.views.table, layout: "TABLE_LAYOUT" },
+/**
+ * Views as in the template: columns by `columnKey` in the template's order, the table grouped by Status. The roadmap's
+ * columns aren't compared: the API gives it the default ones, it has no configured columns.
+ */
+interface CanonView {
+  name: string;
+  layout: string;
+  columns?: string[];
+  groupBy?: string;
+}
+const canonViews = (): CanonView[] => [
+  { name: N.views.board, layout: "BOARD_LAYOUT", columns: ["TITLE", STATUS, "LABELS", "SUB_ISSUES_PROGRESS"] },
+  { name: N.views.table, layout: "TABLE_LAYOUT", columns: ["TITLE", STATUS, "LABELS", "ASSIGNEES", "SUB_ISSUES_PROGRESS", N.fields.estimate], groupBy: STATUS },
   { name: N.views.roadmap, layout: "ROADMAP_LAYOUT" },
 ];
+/** A built-in column's name when the project has no such field yet (a column key is its type). */
+const BUILTIN_COLUMNS: Record<string, string> = { TITLE: "Title", ASSIGNEES: "Assignees", LABELS: "Labels", SUB_ISSUES_PROGRESS: "Sub-issues progress" };
 export const STATUS = "Status";
 const statusOptions = () => [N.status.backlog, N.status.inProgress, N.status.done];
+/** The template's colors of the Status options, in order — GitHub's colors of a new project's Todo / In Progress / Done. */
+const STATUS_COLORS = ["GREEN", "YELLOW", "PURPLE"];
 const numberFields = () => [N.fields.estimate, N.fields.actual, N.fields.tokens, N.fields.cost];
 const issueTypes = () => [N.issueTypes.task, N.issueTypes.bug, N.issueTypes.epic];
 export const PRIORITY = "Priority";
@@ -98,6 +112,14 @@ const ISSUE_LABEL_LIMIT = 100;
 export const WORKFLOW_ADDED = "Item added to project";
 export const WORKFLOW_CLOSED = "Item closed";
 export const WORKFLOW_AUTO_ADD = "Auto-add to project";
+const WORKFLOW_MERGED = "Pull request merged";
+const WORKFLOW_AUTO_CLOSE = "Auto-close issue";
+const WORKFLOW_SUB_ISSUES = "Auto-add sub-issues to project";
+const WORKFLOW_ARCHIVE = "Auto-archive items";
+/** The template's workflows, all on. */
+const WORKFLOWS = [WORKFLOW_ADDED, WORKFLOW_CLOSED, WORKFLOW_MERGED, WORKFLOW_AUTO_CLOSE, WORKFLOW_AUTO_ADD, WORKFLOW_SUB_ISSUES, WORKFLOW_ARCHIVE];
+/** The template's auto-archive filter: a task closed and untouched for two weeks leaves the board and the table. */
+const ARCHIVE_FILTER = "is:issue is:closed updated:<@today-2w";
 /** The template: a new project is its copy (views, fields, configured workflows except auto-add). */
 export const DEFAULT_TEMPLATE = "miroshnik/6";
 /**
@@ -203,6 +225,9 @@ interface View {
   filter: string | null;
   sortBy: string[];
   columnsBy: string[];
+  groupBy: string[];
+  /** The visible fields (`fields` of the view). */
+  columns: { id: string; name: string; dataType: string }[];
 }
 interface Option {
   id: string;
@@ -388,6 +413,8 @@ export const Q = {
           id number name layout filter
           sortByFields(first: 5) { nodes { direction field { ... on ProjectV2FieldCommon { name } } } }
           verticalGroupByFields(first: 5) { nodes { ... on ProjectV2FieldCommon { name } } }
+          groupByFields(first: 5) { nodes { ... on ProjectV2FieldCommon { name } } }
+          fields(first: 50) { nodes { ... on ProjectV2FieldCommon { id name dataType } } }
         }
       }
       fields(first: 100) {
@@ -1014,6 +1041,8 @@ function loadProject(io: Io, id: string, withItems = true): Project {
       filter: v.filter ?? null,
       sortBy: (v.sortByFields?.nodes ?? []).map((s: Any) => s.field?.name).filter(Boolean),
       columnsBy: (v.verticalGroupByFields?.nodes ?? []).map((f: Any) => f?.name).filter(Boolean),
+      groupBy: (v.groupByFields?.nodes ?? []).map((f: Any) => f?.name).filter(Boolean),
+      columns: (v.fields?.nodes ?? []).filter((f: Any) => f?.id).map((f: Any) => ({ id: f.id, name: f.name, dataType: f.dataType })),
     })),
     fields: p.fields.nodes
       .filter((f: Any) => f && f.id)
@@ -1066,8 +1095,17 @@ export function analyze(s: State): Check[] {
     link(`another project is linked: ${q(other.title)} (${other.url})`, { kind: "confirm", text: `unlink project ${q(other.title)} from the repository`, mutations: [{ op: "UnlinkProject", input: { projectId: other.id, repositoryId: s.repo.id } }] });
   }
 
+  // Columns: a built-in field by its type, the rest by name; a numeric field in another dictionary language is the same
+  // column — the Fields item renames it keeping the id.
+  const fieldAlias = fieldAliases();
+  const columnKey = (f: { name: string; dataType: string }) => (BUILTIN_FIELDS.has(f.dataType) ? f.dataType : (fieldAlias[f.name] ?? f.name));
+  const columnName = (key: string) => p.fields.find((f) => columnKey(f) === key)?.name ?? BUILTIN_COLUMNS[key] ?? key;
+  // a field the project doesn't have yet is skipped: the step's text changes when it appears, and the next round sets it
+  const columnFields = (keys: string[]) => keys.map((k) => p.fields.find((f) => columnKey(f) === k)).filter((f): f is Field => !!f);
+  const configuration = (keys: string[]) => ({ visibleFieldIds: columnFields(keys).map((f) => f.id) });
+
   // Views: by name; missing — rename an extra one of the same layout or create one; extra ones — delete.
-  const views = add("views", `Views ${canonViews().map((v) => q(v.name)).join(", ")} — the right layout, no filter, no others`);
+  const views = add("views", `Views ${canonViews().map((v) => q(v.name)).join(", ")} — the right layout, columns and grouping, no filter, no others`);
   const canonNames = new Set<string>(canonViews().map((v) => v.name));
   const spare = p.views.filter((v) => !canonNames.has(v.name));
   for (const c of canonViews()) {
@@ -1078,7 +1116,8 @@ export function analyze(s: State): Check[] {
         spare.splice(spare.indexOf(cand), 1);
         views(`missing ${q(c.name)}`, guarded(`rename view ${q(cand.name)} → ${q(c.name)}`, { op: "UpdateView", input: { viewId: cand.id, name: c.name } }));
       } else {
-        views(`missing ${q(c.name)}`, api(`create view ${q(c.name)} (${c.layout})`, { op: "CreateView", input: { projectId: p.id, name: c.name, layout: c.layout } }));
+        const input = { projectId: p.id, name: c.name, layout: c.layout, ...(c.columns ? { configuration: configuration(c.columns) } : {}) };
+        views(`missing ${q(c.name)}`, api(`create view ${q(c.name)} (${c.layout})`, { op: "CreateView", input }));
       }
       continue;
     }
@@ -1087,14 +1126,29 @@ export function analyze(s: State): Check[] {
     if (c.layout === "BOARD_LAYOUT" && v.layout === c.layout && v.columnsBy[0] !== STATUS) {
       views(`${q(c.name)} columns not by Status`, ui(`${q(c.name)}: View options → Column by → Status → Save`, `${p.url}/views/${v.number}`));
     }
+    if (c.columns) {
+      const have = v.columns.map(columnKey);
+      const missing = c.columns.filter((k) => !have.includes(k)).map((k) => q(columnName(k)));
+      const extra = v.columns.filter((f) => !c.columns!.includes(columnKey(f))).map((f) => q(f.name));
+      if (missing.length || extra.length) {
+        const why = [missing.length ? `missing ${missing.join(", ")}` : "", extra.length ? `extra ${extra.join(", ")}` : ""].filter(Boolean).join("; ");
+        const set = columnFields(c.columns).map((f) => f.name).join(", ");
+        views(`${q(c.name)} columns: ${why}`, api(`${q(c.name)}: columns ${set}`, { op: "UpdateView", input: { viewId: v.id, configuration: configuration(c.columns) } }));
+      }
+    }
+    // the API reads the grouping but doesn't set it
+    if (c.groupBy && v.layout === c.layout && v.groupBy[0] !== c.groupBy) {
+      views(`${q(c.name)} not grouped by ${c.groupBy}`, ui(`${q(c.name)}: View options → Group by → ${c.groupBy} → Save`, `${p.url}/views/${v.number}`));
+    }
   }
   for (const v of spare) views(`extra ${q(v.name)}`, guarded(`delete view ${q(v.name)}`, { op: "DeleteView", input: { viewId: v.id } }));
 
-  // Status: options by name or by a known English name — with the same id; missing ones — new.
-  const status = add("status", `${STATUS}: ${statusOptions().join(" → ")}`);
+  // Status: options by name or by a known English name — with the same id; missing ones — new; colors — the template's,
+  // descriptions are the project's own.
+  const status = add("status", `${STATUS}: ${statusOptions().join(" → ")} (${STATUS_COLORS.join(", ")})`);
   const sf = p.fields.find((f) => f.name === STATUS && f.options);
   if (!sf) {
-    status(`no ${STATUS} field`, api(`create field ${STATUS}`, { op: "CreateField", input: { projectId: p.id, dataType: "SINGLE_SELECT", name: STATUS, singleSelectOptions: statusOptions().map((name) => ({ name, color: "GRAY", description: "" })) } }));
+    status(`no ${STATUS} field`, api(`create field ${STATUS}`, { op: "CreateField", input: { projectId: p.id, dataType: "SINGLE_SELECT", name: STATUS, singleSelectOptions: statusOptions().map((name, i) => ({ name, color: STATUS_COLORS[i], description: "" })) } }));
   } else if (sf.options!.map((o) => o.name).join("\n") !== statusOptions().join("\n")) {
     const left = [...sf.options!];
     const take = (pred: (o: Option) => boolean) => {
@@ -1102,18 +1156,21 @@ export function analyze(s: State): Check[] {
       return i < 0 ? null : left.splice(i, 1)[0]!;
     };
     const aliases = statusAliases();
-    const next = statusOptions().map((name) => {
+    const next = statusOptions().map((name, i) => {
       const o = take((x) => x.name === name) ?? take((x) => aliases[x.name.toLowerCase()] === name);
-      return o ? { id: o.id, name, color: o.color, description: o.description ?? "" } : { name, color: "GRAY", description: "" };
+      return o ? { id: o.id, name, color: STATUS_COLORS[i]!, description: o.description ?? "" } : { name, color: STATUS_COLORS[i]!, description: "" };
     });
     const drop = left.length ? `; delete ${left.map((o) => q(o.name)).join(", ")}` : "";
     status(`options: ${sf.options!.map((o) => o.name).join(", ") || "none"}`, guarded(`${STATUS}: ${statusOptions().join(", ")} (rename the existing ones keeping the id${drop})`, { op: "UpdateField", input: { fieldId: sf.id, singleSelectOptions: next } }));
+  } else if (sf.options!.some((o, i) => o.color !== STATUS_COLORS[i])) {
+    // recoloring keeps the ids — the tasks' values and the workflows' targets, no confirmation needed
+    const next = sf.options!.map((o, i) => ({ id: o.id, name: o.name, color: STATUS_COLORS[i]!, description: o.description ?? "" }));
+    status(`colors: ${sf.options!.map((o) => `${o.name} ${o.color}`).join(", ")}`, api(`${STATUS}: colors ${STATUS_COLORS.join(", ")} (keeping the id)`, { op: "UpdateField", input: { fieldId: sf.id, singleSelectOptions: next } }));
   }
 
   // Fields: four numeric ones; a field in another dictionary language is renamed with the same id (the tasks' values are
   // kept); no custom fields beyond the canon; in an organization Priority is an issue field.
   const fields = add("fields", `Fields ${numberFields().map(q).join(", ")} (Number), no other custom ones`);
-  const fieldAlias = fieldAliases();
   const renamed = new Set<Field>();
   for (const name of numberFields()) {
     const f = p.fields.find((x) => x.name === name);
@@ -1177,14 +1234,18 @@ export function analyze(s: State): Check[] {
   }
 
   // Workflows: the API doesn't turn them on or show the target — only the UI. An unconfigured one isn't in the list.
-  const wf = add("workflows", `Workflows ${[WORKFLOW_ADDED, WORKFLOW_CLOSED, WORKFLOW_AUTO_ADD].map(q).join(", ")} are on`);
+  const wf = add("workflows", `Workflows ${WORKFLOWS.map(q).join(", ")} are on`);
   const how: Record<string, string> = {
     [WORKFLOW_ADDED]: `Edit → Set value → ${STATUS}: ${N.status.backlog}`,
     [WORKFLOW_CLOSED]: `Edit → Set value → ${STATUS}: ${N.status.done}`,
+    [WORKFLOW_MERGED]: `Edit → Set value → ${STATUS}: ${N.status.done}`,
+    [WORKFLOW_AUTO_CLOSE]: `Edit → ${STATUS}: ${N.status.done}`,
     // is:open — otherwise an updated closed task (not planned too) comes back into the project
     [WORKFLOW_AUTO_ADD]: `Edit → repository ${s.repo.name}, filter is:issue is:open (Enter)`,
+    [WORKFLOW_SUB_ISSUES]: "Edit",
+    [WORKFLOW_ARCHIVE]: `Edit → filter ${ARCHIVE_FILTER} (Enter)`,
   };
-  for (const name of [WORKFLOW_ADDED, WORKFLOW_CLOSED, WORKFLOW_AUTO_ADD]) {
+  for (const name of WORKFLOWS) {
     const w = p.workflows.find((x) => x.name === name);
     if (w?.enabled) continue;
     // an unconfigured workflow isn't in the API — a link to the list, it's in the menu on the left there