craftar 0.17.4 → 0.18.0

package/README.md

@@ -30,7 +30,12 @@ npx tsx src/cli.ts --help
 ## Quick start: start an empty workspace from a Forge
 
 ```bash
-# Writes craftar.yaml (forge, profile) once it resolves and plans, then runs the first sync.
+# In a terminal, craftar init asks for what the flags do not give:
+# the Forge, the profile, then the recipes and the targets to keep or adjust.
+cd C:/Projects/acme-portal-workspace
+craftar init
+
+# Or pass everything for scripts and CI:
 craftar init --workspace C:/Projects/acme-portal-workspace \
   --forge   C:/Projects/forge \
   --profile acme-portal
@@ -63,7 +68,7 @@ From then on, change a rule in `forge/ingredients/rules/<name>/rule.md`, run `cr
 
 | Command | What it does |
 |---|---|
-| `craftar init --forge <dir\|url> --profile <name> [--ref <ref>] [--targets <a,b>] [--add-recipe <name>]... [--remove-recipe <name>]... [--replace] [--no-sync] [--offline] [--workspace .]` | Starts a workspace: writes a `craftar.yaml` holding `forge` (a directory as the path from the workspace, POSIX; a URL as given), `ref` (a remote Forge only), `profile`, `recipes` (only the lists the recipe flags leave non-empty) and `targets` (only with `--targets`; otherwise the workspace follows the profile's), then runs the first `sync` — which also registers the workspace. The file is written only once the configuration loads (a remote Forge is fetched as `sync` fetches it; `--offline` reads the cache), resolves and plans, and the sync applies that same plan. `--remove-recipe` and `--add-recipe` go through `remove recipe` / `add recipe`'s core (removes first, then adds; `--replace` swaps a slot holder); a call whose every name changes nothing prints its reasons as a `note`. `--workspace` is created when missing. Files already on disk and not in a lock are adopted when equal to the plan and skipped as a `collision` otherwise, never overwritten, with one warning pointing at `craftar import`. `--no-sync` writes `craftar.yaml` only and prints what the first `sync` would do. Refused, with nothing written and no directory created: an existing `craftar.yaml`; a `--workspace` that is a file; credentials in `--forge` (the value is never printed); `--ref` with a directory Forge; an unknown target; a recipe both added and removed, or any refusal of `add recipe` / `remove recipe`; a `craftar.local.yaml` that sets `forge` or `profile`, or a key a given flag would write (`ref`, `recipes`, `targets`) — its value would replace the flag's; a Forge, profile or plan that does not load. |
+| `craftar init [--forge <dir\|url>] [--profile <name>] [--ref <ref>] [--targets <a,b>] [--add-recipe <name>]... [--remove-recipe <name>]... [--replace] [--no-sync] [--offline] [--workspace .]` | Starts a workspace: writes a `craftar.yaml` holding `forge` (a directory as the path from the workspace, POSIX; a URL as given), `ref` (a remote Forge only), `profile`, `recipes` (only the lists the recipe flags leave non-empty) and `targets` (only with `--targets`; otherwise the workspace follows the profile's), then runs the first `sync` — which also registers the workspace. **In a terminal** (stdin and stdout both a TTY), `--forge` and `--profile` are optional: what is missing is asked for — the Forge (offering the one last synced on this machine, from the registry), a remote Forge's ref, the profile (from the Forge's list), then the recipes and the targets the profile gives, to keep or adjust; a flag given is never asked for. One confirmation before anything is written, showing what the first sync would do. Ctrl-C, the end of input, or `no` at the confirmation: nothing written, exit 1 (`init cancelled — nothing written`). The run ends with an `again craftar init …` line: the same run as flags, for CI. Off a terminal (a pipe, CI), a missing flag is refused, exit 1, naming the flag; where the terminal does not report a TTY, the flags are required. With both flags given nothing is asked, in a terminal or not. The file is written only once the configuration loads (a remote Forge is fetched as `sync` fetches it; `--offline` reads the cache), resolves and plans, and the sync applies that same plan. `--remove-recipe` and `--add-recipe` go through `remove recipe` / `add recipe`'s core (removes first, then adds; `--replace` swaps a slot holder); a call whose every name changes nothing prints its reasons as a `note`. `--workspace` is created when missing. Files already on disk and not in a lock are adopted when equal to the plan and skipped as a `collision` otherwise, never overwritten, with one warning pointing at `craftar import`. `--no-sync` writes `craftar.yaml` only and prints what the first `sync` would do. Refused, with nothing written and no directory created: an existing `craftar.yaml`; a `--workspace` that is a file, or under one; credentials in `--forge` (the value is never printed); `--ref` with a directory Forge; an unknown target; a recipe both added and removed, or any refusal of `add recipe` / `remove recipe`; a `craftar.local.yaml` that sets `forge` or `profile`, or a key a given flag would write (`ref`, `recipes`, `targets`) — its value would replace the flag's; a Forge, profile or plan that does not load. |
 | `craftar import --from claude-code --forge <dir> --profile <name> [--workspace .] [--write-config]` | Reads `.claude/{rules,agents,commands,skills,scripts,hooks}`, `.mcp.json` and, when present, `.kiro/steering` (for inclusion modes and hand-written steering). Creates ingredients, recipes (`base`, one `stack-*` per scoped rule, `<profile>-steering`) and a profile, or updates them. An ingredient already in the Forge is reused when the base, **rendered** for this profile (its declared defaults, the profile's `params`, the workspace's `overrides.params`), equals the workspace file; failing that, when a unique, proved assignment of the base's declared `{{keys}}` reproduces it, the values are **inferred** into the profile's `params` (one value per key per run; never a change another ingredient would feel). A base with section markers is rendered with the profile's `sections` and the workspace's `overrides.sections` first; when the workspace file differs from it only inside sections, the unique content that reproduces the file byte for byte is **inferred** into the profile's `sections` (tried after params, never combined with them; the report counts lines and never prints the content). An import that writes a section value, or compares a workspace file against a base holding markers, sets `schema: 2` in `craftar.forge.yaml`. A reused base takes the place its `<name>--<profile>` variant held: the profile moves to the shared recipe when that orders the base there, and an owned recipe gets the base in the variant's slot, so the rule order (and `AGENTS.md`) stays as it was. Anything else becomes a `<name>--<profile>` variant that emits under the original name, with the reason, so the workspace still round-trips while you decide what to unify. A shared recipe is never widened for one client: a profile whose ingredients differ from `base` or a `stack-*` gets its own `<recipe>--<profile>`. An existing profile is merged in place (`params`, `sections`, the recipes import owns, missing `targets`; every other field and comment kept, and an empty `{}` / `[]` it does not change stays on its line), as is a recipe the profile owns; `--write-config` merges an existing `craftar.yaml` (`forge`, `profile`, `targets`). The report adds `rendered` (with `sections <names>` when a section value filled the render), `inferred`, `sectioned`, `param <key>: <old> → <new>`, `section <key> <name>: <old> → <new>`, `forge craftar.forge.yaml edited (schema: 2)` and `profile … created\|edited\|unchanged` lines. It refuses, with the Forge untouched, a Forge that does not load, a profile or recipe or `craftar.yaml` that does not round-trip through the YAML writer, a misplaced profile, a recipe import writes whose file and `name` disagree, a workspace override that does not parse, a literal `{{key}}` the profile would render, changing a recipe or variant another profile uses, a workspace file holding a section marker at column 0 (sync would not reproduce it: indent it), a Forge base with malformed section markers, and a `craftar.forge.yaml` it needs to bump to `schema: 2` that does not round-trip (set it by hand). Ingredients holding a secret-like value (tokens, private keys, high-entropy MCP `env`/`args` values) are rejected and listed by location — the value is never printed. A UTF-16 file with a byte-order mark is decoded for the scan; UTF-16 without one is not detected. An ingredient that would not load back into the Forge (a name that is not slug-like, a non-string MCP `env` value) refuses the import, naming its source; so does an ingredient already in the Forge whose `ingredient.yaml` has an unknown key or a YAML syntax error, naming that file. Every read and check runs before the first write, so an import that fails leaves the Forge untouched and says so. |
 | `craftar status` | With a remote Forge, the header's second line names it — `forge <url> @ <ref \| <branch> (default branch)> <commit>`, plus `· lock <commit>` when the Forge moved since the last sync — and `--json` carries `forge: {kind, source, ref, defaultBranch, commit, lockCommit, fetched}` for every Forge. Classifies every file the Forge would produce: `new`, `update`, `unchanged`, `adopt`, `drift`, `collision`, `orphan`, `orphan-drift`. A `.json` file not yet in `craftar.lock` that parses to the planned value with its keys in the same order (it differs only in whitespace, escapes, number spelling or duplicate keys) is `adopt`, and the first `sync` rewrites it with the planned bytes — by design. For `claude-code`'s `.mcp.json` that is two-space JSON keeping the file's BOM and line endings; Kiro's JSON files become CRLF without a BOM, like every Kiro text file. A different key order is a `collision` — except for integer-like keys, which `JSON.parse` reorders. A locked JSON file reformatted by hand is `drift`, not `adopt`. `--json` for tooling. Exits 1 on malformed section markers and on a section marker in an ingredient the workspace resolves while `craftar.forge.yaml` declares `schema: 1` (or none), naming the Forge file and line, and when a rendered file would still hold a marker line, naming the ingredient, file and rendered line — as do `sync`, `diff`, `explain` and `ls`. Warns about a section value that names no ingredient, or no marker of an ingredient the workspace resolves, and about marker lines in an emitted file not every target renders as text (copied as they are). |
 | `craftar sync` | Renders sections (no rendered body holds a marker; an emitted file not every target renders as text keeps its markers, with a warning), then writes the plan and `craftar.lock` (schema 2: the Forge's source, requested `ref` and commit, the resolved recipes and targets — rewritten only when that content changes). With a remote Forge it fetches first and exits 1 when the fetch fails, `--dry-run` and `--check` included. `--dry-run` shows without writing. `--check` exits 1 when anything is out of sync (CI). `--overwrite-drift` regenerates hand-edited files (explicit, never default). A writing `sync` (not `--dry-run`, not `--check`) also records the workspace in `$CRAFTAR_HOME/registry.json` (see *Workspace registry*); a registry it cannot write is a warning, never a failed `sync`. |
@@ -289,18 +294,26 @@ A writing `sync` records the workspace in `$CRAFTAR_HOME/registry.json` (`~/.cra
 - **`CRAFTAR_NO_REGISTRY`** — read the name as "no registry", the way `NO_COLOR` means "no colour". Set to any non-empty value, it turns the registry off: `sync` neither reads nor writes it, and `craftar workspaces` exits 1. An empty value counts as unset. Set it on CI runners and throwaway checkouts, whose directories would only pile up as `missing`.
 - **A registry that cannot be written** (an unwritable `$CRAFTAR_HOME`, a busy lock after 60 s, a file this craftar cannot read) leaves `sync`'s files, lock and exit code as they would be, and adds one warning. Craftar never overwrites a registry it cannot read: repair or remove it yourself.
 - The registry is per machine: paths are native and absolute, and SSH and HTTPS spellings of one remote are two Forges in it, as they are two cache entries.
+- **`craftar init` reads it for the Forge it offers** when it asks: the Forge of the most recent `sync` on this machine, skipping a directory that is gone. The questions never write it — the first `sync` registers the new workspace as any `sync` does. With `CRAFTAR_NO_REGISTRY` set, or a registry it cannot read, no Forge is offered and the question is asked without a default.
 - **The registry also tells a Forge its workspaces**: `forge impact` and `forge unify` read it (never write it); a workspace synced on CI, another machine or under `CRAFTAR_NO_REGISTRY` is not known to them, which is why `--prune-recipes` says so.
 
 ## Roadmap (from the functional spec)
 
 Phase 0 — foundations (done): schema, import, sync/status/diff/explain, claude-code + kiro + agents-md targets, lock, drift, orphans; `forge variants`, `forge diff` and `forge unify` (`take: param`, `take: section`); sections.
 
-Phase 1 — client profile (in progress). Shipped: the read-only catalogue (`recipes`, `ingredients`, `targets` with the capability matrix); remote Forge (git URL + `ref`, a per-machine cache, the schema 2 lock) and `craftar cache prune`; the workspace registry and `craftar workspaces`; `craftar add recipe` / `remove recipe`; `craftar init` with flags; `craftar doctor`; `craftar forge impact` and `forge unify --prune-recipes`. Next: an interactive `craftar init` (choose the Forge and the profile); cloning a profile's repositories at init; profile-driven integrations (PM tool → MCP, IDP → MCP).
+Phase 1 — client profile (in progress). Shipped: the read-only catalogue (`recipes`, `ingredients`, `targets` with the capability matrix); remote Forge (git URL + `ref`, a per-machine cache, the schema 2 lock) and `craftar cache prune`; the workspace registry and `craftar workspaces`; `craftar add recipe` / `remove recipe`; `craftar init` with flags; `craftar doctor`; `craftar forge impact` and `forge unify --prune-recipes`; an interactive `craftar init` (choose the Forge and the profile). Next: cloning a profile's repositories at init; profile-driven integrations (PM tool → MCP, IDP → MCP).
 
 Later: `service` ingredients with compose fragments (`craftar services up`); `dotnet new` template registration; rulesync bridge for Codex/Kimi/Cursor specifics; `craftar docs validate`; GitHub Action and Azure Pipelines task around `sync --check`; `craftar ui`; `craftar mcp` + Claude Code / Agent Plugin packaging.
 
 ## Upgrading
 
+### to 0.18.0
+
+- **In a terminal, `craftar init` with `--forge` or `--profile` missing asks instead of failing.** Off a terminal (stdin or stdout is not a TTY) it still exits 1 on stderr, but the line changed: commander's `required option '--profile <name>' not specified` became `--profile is required when craftar init does not run in a terminal — pass it, or run craftar init in a terminal to be asked` (and the `--forge` / both forms). A script matching the old text must match the new.
+- **The check moved.** An existing `craftar.yaml`, a `--workspace` that is a file and a bad flag value are now reported before the missing flag.
+- **`craftar init --workspace <dir>` under a path that is a file** is refused with `cannot use <path> as a workspace: it is not a directory` instead of a raw `ENOTDIR` error.
+- **No byte change**: no emitter, `plan`, `status`, `sync` or lock changed. No workspace sees `update`.
+
 ### to 0.17.4
 
 - **A change confined to bytes that are not valid UTF-8 is now seen.** The content hash decoded every file as UTF-8, which folds each invalid byte into the same replacement character, so two files differing only there hashed the same: `sync` reported a raw-copied file (a script or hook outside the text extensions, a binary in a skill directory) `unchanged` after its Forge copy changed and never wrote it, `forge variants` called such a pair identical, and `forge diff` showed no hunk. A file that is not valid UTF-8 is now hashed as its bytes, with line endings and a leading UTF-8 BOM normalized as for any other file; valid UTF-8 hashes exactly as before.

package/dist/cli.js

@@ -6,7 +6,7 @@ import YAML from "yaml";
 import { importClaudeCode } from "./importers/claude-code.js";
 import { classifyForge } from "./core/remote.js";
 import { forget, listWorkspaces, prune, register, registryFile } from "./core/registry.js";
-import { forgeWorkspaces, planAll, nextSync, impactOf, concerned, refineRegistryState } from "./core/impact.js";
+import { forgeWorkspaces, planAll, nextSync, impactOf, concerned, refineRegistryState, countStates, NEXT_SYNC_STATES } from "./core/impact.js";
 import { runDoctor } from "./core/doctor.js";
 import { pruneCache } from "./core/cache.js";
 import { resolveHome } from "./core/home-lock.js";
@@ -22,9 +22,11 @@ import { exists, gitDirty, gitIsRepo, gitUnheld, loadForge } from "./core/forge.
 import { fingerprintDir } from "./core/fingerprint.js";
 import { hunkAt, planFrom, applyPlan, writeUnified, checkRecipeCascade, rewriteRecipes, pruneCandidates, pruneRecipes, note, } from "./core/unify.js";
 import { checkParamWrites, writeParamFile } from "./core/param-writes.js";
-import { planInit } from "./core/init.js";
+import { checkInitFlags, initLine, planInit } from "./core/init.js";
+import { askInit, confirmInit, againLine } from "./core/init-flow.js";
+import { readlineIo } from "./prompt.js";
 import { editRecipesText, planRecipeEdit, recipeDiffLine } from "./core/recipe-edit.js";
-import { localKeys } from "./core/workspace-yaml.js";
+import { localKeys, readLocalFile } from "./core/workspace-yaml.js";
 import { HUNK_CLASSES, INGREDIENT_TYPES, UnifyPlanSchema } from "./schema/index.js";
 process.stdout.on("error", (e) => { if (e.code === "EPIPE")
     process.exit(0); });
@@ -35,7 +37,7 @@ process.stdout.on("error", (e) => { if (e.code === "EPIPE")
  */
 const DIFF_EXIT_CODE_FETCH_MODE = "sync";
 const program = new Command();
-program.name("craftar").description("Craft, sync and convert AI-coding workspace harnesses.").version("0.17.4");
+program.name("craftar").description("Craft, sync and convert AI-coding workspace harnesses.").version("0.18.0");
 /* ---------------------------------------------------------------- import */
 program
     .command("import")
@@ -142,9 +144,9 @@ async function applyAndReport(ws, p, st, lock, opts = {}) {
 /* ---------------------------------------------------------------- init */
 program
     .command("init")
-    .description("Start a workspace from a Forge and a profile: write a craftar.yaml proved to resolve and plan, then run the first sync; refused when craftar.yaml already exists")
-    .requiredOption("--forge <dir|url>", "the Forge: a directory (written relative to the workspace) or a git URL")
-    .requiredOption("--profile <name>", "the client profile in the Forge")
+    .description("Start a workspace from a Forge and a profile: write a craftar.yaml proved to resolve and plan, then run the first sync; in a terminal, asks for the Forge and the profile not given as flags; refused when craftar.yaml already exists")
+    .option("--forge <dir|url>", "the Forge: a directory (written relative to the workspace) or a git URL; asked for in a terminal when omitted")
+    .option("--profile <name>", "the client profile in the Forge; asked for in a terminal when omitted")
     .option("--ref <ref>", "branch, tag or full SHA of a remote Forge")
     .option("--targets <a,b>", "targets to write in craftar.yaml (claude-code, kiro, agents-md); omitted, the workspace follows the profile's")
     .option("--add-recipe <name>", "add a recipe to the profile's (repeatable)", collect, [])
@@ -153,26 +155,98 @@ program
     .option("--no-sync", "write craftar.yaml only, and say what the first sync would do")
     .option("--offline", "use the cached copy of a remote Forge, without fetching", false)
     .option("--workspace <dir>", "workspace root, created when missing", ".")
-    .action(async (o) => {
+    .action(async (o, cmd) => {
     const root = path.resolve(o.workspace);
+    // N1: craftar.yaml already exists
     const n1 = () => fail(`${WORKSPACE_FILE} already exists in ${root} — change recipes with craftar add recipe / remove recipe, or edit it`);
     const file = path.join(root, WORKSPACE_FILE);
     if (await exists(file))
         n1();
-    const st = await fs.stat(root).catch(() => null);
-    if (st && !st.isDirectory())
-        fail(`cannot use ${root} as a workspace: it is not a directory`);
-    const init = await planInit(root, {
+    // N9: --workspace is a file, or any ancestor up to an existing path is a file
+    {
+        let p = root;
+        for (;;) {
+            const st = await fs.stat(p).catch(() => null);
+            if (st) {
+                if (!st.isDirectory())
+                    fail(`cannot use ${p} as a workspace: it is not a directory`);
+                break; // found an existing directory
+            }
+            const parent = path.dirname(p);
+            if (parent === p)
+                break; // reached filesystem root
+            p = parent;
+        }
+    }
+    // Check the flags that were given (N3, N7, N11, N6)
+    checkInitFlags({
         forge: o.forge,
-        profile: o.profile,
         ref: o.ref,
         targets: o.targets === undefined ? undefined : o.targets.split(",").map((t) => t.trim()),
         addRecipes: o.addRecipe,
         removeRecipes: o.removeRecipe,
-        replace: o.replace,
-    }, load(o, "sync"));
+    });
+    // Mode: flags when both given; else interactive when both streams are TTYs; else N2
+    const bothGiven = o.forge !== undefined && o.profile !== undefined;
+    const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+    if (!bothGiven && !isTTY) {
+        // N2: refuse with our message
+        if (o.forge === undefined && o.profile === undefined) {
+            fail("--forge and --profile are required when craftar init does not run in a terminal — pass them, or run craftar init in a terminal to be asked");
+        }
+        else if (o.profile === undefined) {
+            fail("--profile is required when craftar init does not run in a terminal — pass it, or run craftar init in a terminal to be asked");
+        }
+        else {
+            fail("--forge is required when craftar init does not run in a terminal — pass it, or run craftar init in a terminal to be asked");
+        }
+    }
+    // Read the local file once (after N1, N9 and flag checks, before any question or planInit)
+    const local = await readLocalFile(root);
+    let input;
+    let answers = null;
+    if (!bothGiven) {
+        const io = readlineIo(process.stdin, process.stdout, { terminal: true });
+        const result = await askInit(root, {
+            forge: o.forge,
+            profile: o.profile,
+            ref: o.ref,
+            targets: o.targets === undefined ? undefined : o.targets.split(",").map((t) => t.trim()),
+            addRecipes: o.addRecipe,
+            removeRecipes: o.removeRecipe,
+            replace: o.replace,
+        }, local, io, { ...load(o, "sync"), registryOff: registryOff() });
+        if (result.kind === "cancelled")
+            fail("init cancelled — nothing written");
+        input = result.input;
+        answers = result.answers;
+    }
+    else {
+        input = {
+            forge: o.forge,
+            profile: o.profile,
+            ref: o.ref,
+            targets: o.targets === undefined ? undefined : o.targets.split(",").map((t) => t.trim()),
+            addRecipes: o.addRecipe,
+            removeRecipes: o.removeRecipe,
+            replace: o.replace,
+        };
+    }
+    const init = await planInit(root, input, { ...load(o, "sync"), local });
+    if (answers !== null) {
+        const io = readlineIo(process.stdin, process.stdout, { terminal: true });
+        const confirm = await confirmInit(init, root, io, { sync: o.sync });
+        if (confirm === "cancelled")
+            fail("init cancelled — nothing written");
+    }
     const { ws, plan: p } = init;
-    // Every refusal is above: only now does the directory, and craftar.yaml, come to exist (§13 items 1, 9).
+    const workspaceGiven = cmd.getOptionValueSource("workspace") === "cli";
+    const again = () => {
+        if (answers !== null) {
+            console.log(againLine(answers, { workspace: workspaceGiven ? o.workspace : undefined, sync: o.sync, offline: o.offline }));
+        }
+    };
+    // Every refusal is above: only now does the directory, and craftar.yaml, come to exist
     await fs.mkdir(root, { recursive: true });
     try {
         await fs.writeFile(file, init.text, { flag: "wx" });
@@ -182,21 +256,22 @@ program
             n1();
         throw e;
     }
-    const from = { flag: "", local: ` (from ${LOCAL_FILE})`, profile: " (from the profile)" }[init.targetsFrom];
     console.log(pc.bold(`craftar init — wrote ${WORKSPACE_FILE} in ${root}`));
-    console.log(`  forge ${ws.config.forge} · profile ${ws.config.profile} · recipes ${p.resolution.recipes.join(" → ")} · targets ${p.resolution.targets.join(", ")}${from}`);
+    console.log(`  ${initLine(init)}`);
     for (const n of init.notes)
         console.log(`  note ${n}`);
     if (!o.sync) {
         console.log(nextSyncLine(init.statuses));
         for (const w of p.warnings)
             console.log(`  ${pc.yellow("warn")} ${w}`);
+        again();
         return;
     }
     const r = await applyAndReport(ws, p, init.statuses, init.lock);
     const collisions = r.skipped.filter((s) => s.state === "collision").length;
     if (collisions)
         console.log(`  ${pc.yellow("warn")} ${collisions} file(s) already in the workspace differ from the Forge and were left as they are — to bring them into the Forge, run craftar import`);
+    again();
 });
 /* ---------------------------------------------------------------- sync */
 program
@@ -276,14 +351,13 @@ program
         process.exitCode = 1;
 });
 /* ---------------------------------------------------------------- add / remove recipe */
-/** The states `next sync:` counts, in `FileState` declaration order (spec 22 §14 item 6); a new state does not compile until it is placed here. */
-const NEXT_SYNC = { new: true, update: true, drift: true, adopt: true, collision: true, orphan: true, "orphan-drift": true };
-const NEXT_SYNC_STATES = Object.keys(NEXT_SYNC);
-/** Spec 22's line: what the next sync would do, over `NEXT_SYNC_STATES` (also `init --no-sync`, spec 23 §4.4). */
+/**
+ * Spec 22's line: what the next sync would do (also `init --no-sync`, spec 23 §4.4).
+ * Uses `countStates` from `src/core/impact.ts`; a new `FileState` does not compile until it is
+ * placed in `FILE_STATE_ORDER_MAP` there.
+ */
 function nextSyncLine(st) {
-    const counts = NEXT_SYNC_STATES.map((k) => [k, st.filter((s) => s.state === k).length])
-        .filter(([, n]) => n > 0)
-        .map(([k, n]) => `${n} ${k}`);
+    const counts = countStates(st).map(([k, n]) => `${n} ${k}`);
     return `next sync: ${counts.length ? `${counts.join(", ")} — run \`craftar sync\`` : "nothing to sync"}`;
 }
 function recipeCommand(op) {