speccle 0.15.0 → 0.16.0

package/README.md

@@ -4,7 +4,7 @@ The deterministic tooling the skills invoke — one bin:
 
 ```
 speccle init            # record repo facts + vendor the skills into .claude/skills/
-speccle doctor          # report staleness across the CLI, skills, and strength stack
+speccle doctor          # report staleness across the CLI, skills, CI driver, and strength stack
 speccle update          # refresh the vendored skills; print the CLI + stack fix commands
 speccle lint            # enforce the convention over a repo's specs
 speccle claims          # join criteria to the test names that claim them
@@ -20,9 +20,10 @@ speccle strength init   # provision the strength stack into a target
 
 - `init` / `doctor` / `update` — the setup and staleness surface: `init` records the
   repo's test facts in `.speccle/config.json` and vendors the skills into
-  `.claude/skills/`; `doctor` reports whether those skills and the strength stack still
-  match this CLI; `update` refreshes the skills forward and prints the CLI + stack fix
-  commands. See [Install](https://github.com/matthewalton/speccle/blob/main/README.md#install)
+  `.claude/skills/`; `doctor` reports whether those skills, the CI driver's pinned
+  version, and the strength stack still match this CLI; `update` refreshes the skills
+  forward and prints the CLI + stack fix commands. See
+  [Install](https://github.com/matthewalton/speccle/blob/main/README.md#install)
   and [Updating](https://github.com/matthewalton/speccle/blob/main/README.md#updating).
 - `lint` — enforce the [convention](https://github.com/matthewalton/speccle/blob/main/docs/convention.md) over a repo's specs.
 - `claims` — join every criterion to the test names carrying its id, statically. No
@@ -89,6 +90,21 @@ test no string name, the criterion id takes its identifier-safe spelling:
 `func test_CHECKOUT_1_taxRounds()` claims `CHECKOUT-1`. Reports always render the
 bracketed form.
 
+With no `--dialect`, the dialect comes from `.speccle/config.json`, resolved **per spec
+folder** — so a mixed-language tree is joined in one pass, each slice under its own dialect
+(the config's longest matching `overrides` path wins). `--dialect` forces one dialect across
+every folder instead. The report names every dialect in play, and each feature the one its
+folder joined under:
+
+```
+ios/ladder/SPEC.md  (swift)
+  LADDER-1  1 test name  A rung raises the climber by one
+web/basket/SPEC.md  (ts-vitest)
+  BASKET-1  1 test name  When an item is added, its line quantity increments by exactly 1
+
+swift, ts-vitest — 2 spec files, 2 criteria, 2 claimed, clean
+```
+
 Names are read statically, so a name built dynamically shows up as unclaimed — the
 failure mode is a false alarm, never a silent pass. `--json` emits the typed
 `ClaimsReport` (see [`src/claims.ts`](src/claims.ts)). Exit codes: `0` every criterion
@@ -198,6 +214,11 @@ edits this file, and a malformed one is a hard error rather than a silently-igno
 a quietly dropped signal is exactly the invisible reduction of supervision the score exists to
 prevent.
 
+Whether a changed file is production source or a test is a per-path question, and
+`spec-silent-change` answers it from `.speccle/config.json`, resolved **at each changed file's
+own path** — so in a mixed tree an `ios/` slice's `PlayerTests.swift` reads as a test even
+where the repo defaults to `ts-vitest`. `--dialect` forces one dialect across every path instead.
+
 `--base` moves both the change set and the criterion baseline to the merge base. That pairing
 is load-bearing: on a branch, HEAD already contains the change, so diffing a changed `SPEC.md`
 against HEAD would compare it with itself and no criterion would ever read as retired or
@@ -375,6 +396,12 @@ that wrote it. Nothing else is vendored: the driver ships in this tarball and th
 fetches it from npm, so the code doing the reviewing never comes from the branch under
 review. Re-running moves the pin, which is how a repo updates the driver.
 
+`doctor` reports that pin as its `driver` row, so a workflow left behind on an old version
+shows up as stale rather than sitting there unnoticed; a repo that never opted in reads
+`not installed` and is not a failure. `update` moves the pin **only when the workflow is
+already there** — it will not scaffold one, because opting a repo into a driver that spends
+a metered key per run has to be deliberate.
+
 ```sh
 speccle review run --pr <number> [path] [--repo <owner/name>] [--base <ref>]
                                         [--force] [--model <id>] [--dry-run] [--json]
@@ -425,9 +452,16 @@ instead of a hand-assembled config recipe. In one run it:
   `features/**/*.ts`; override with `--mutate`, repeatable);
 - writes a `vitest.config.ts` with the istanbul provider and `json-summary` reporter.
 
-Init also warns (best-effort, via `~/.claude/settings.json`) when the target vendors
-the speccle skills project-level in `.claude/skills/` while a user-level speccle plugin
-is still enabled — two copies of every skill would load.
+It also reports a `speccle-oracle` devDependency as **superseded** — the name this CLI
+published under before 0.11.0. A repo provisioned back then keeps that package beside the
+current one, exposing a stale binary in `node_modules/.bin/`. Init names the removal
+command and stops there: your `package.json` is yours to change.
+
+Both init commands warn (best-effort, via `~/.claude/settings.json`) when the target
+vendors the speccle skills project-level in `.claude/skills/` while a user-level speccle
+plugin is still enabled — two copies of every skill would load. `speccle init` is the run
+that vendors them, so it warns too rather than leaving the discovery to a `strength init`
+a contract-only user may never run.
 
 An existing Stryker or vitest/vite config is **kept, never overwritten** — init reports
 it and names the fields it must carry itself. The command is idempotent: re-running

package/dist/changeset.js

@@ -1,6 +1,6 @@
-import { spawnSync } from "node:child_process";
 import { readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
+import { gitStdout } from "./git.js";
 /** The changed files a predicate matches — by path glob, then by content when `contains` is set. */
 export async function matching(predicate, changed, read) {
     const pattern = globToRegExp(predicate.path);
@@ -38,7 +38,7 @@ export function gitChangeSet(root) {
     // --untracked-files=all lists new files individually; the default collapses a wholly
     // untracked directory to its name, hiding the files that must be seen.
     const args = ["status", "--porcelain", "--untracked-files=all"];
-    const stdout = git(root, args);
+    const stdout = gitStdout(root, args);
     if (stdout === undefined) {
         throw new Error("could not read a change set from git — run this inside a git repository");
     }
@@ -59,23 +59,18 @@ export function gitChangeSet(root) {
  * left it are not attributed to this change; that is the set a pull request shows.
  */
 export function gitRangeChangeSet(root, base) {
-    const mergeBase = git(root, ["merge-base", base, "HEAD"])?.trim();
+    const mergeBase = gitStdout(root, ["merge-base", base, "HEAD"])?.trim();
     if (mergeBase === undefined || mergeBase === "") {
         // The likeliest cause in CI by far: a shallow checkout that fetched no shared history.
         throw new Error(`no merge base between "${base}" and HEAD — fetch enough history for the two to share a commit`);
     }
     // A rename reports its destination path only, matching the working tree's "old -> new".
-    const stdout = git(root, ["diff", "--name-only", mergeBase, "HEAD"]);
+    const stdout = gitStdout(root, ["diff", "--name-only", mergeBase, "HEAD"]);
     if (stdout === undefined)
         throw new Error(`could not diff "${base}" against HEAD`);
     const changed = stdout.split("\n").filter((line) => line !== "");
     return { changed: [...new Set(changed)], baseline: mergeBase };
 }
-/** Git's stdout, or undefined when the command could not run or failed. */
-function git(root, args) {
-    const result = spawnSync("git", args, { cwd: root, encoding: "utf8" });
-    return result.error === undefined && result.status === 0 ? result.stdout : undefined;
-}
 /** Validates a predicate's shape, naming the offending file — a silently broken predicate is worse than none. */
 export function assertPredicate(predicate, key, file) {
     if (predicate === undefined)

package/dist/claims.js

@@ -1,6 +1,6 @@
 import { readFile, stat } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
-import { readConfig } from "./config.js";
+import { readConfig, resolveFacts } from "./config.js";
 import { DEFAULT_DIALECT, resolveDialect } from "./dialects.js";
 import { discoverSpecs, discoverTests } from "./discover.js";
 import { compareCriterionIds, parseSpec, readClaimedIds } from "./spec.js";
@@ -8,10 +8,13 @@ export async function claims(target, options = {}) {
     const root = resolve(target);
     if (!(await isDirectory(root)))
         throw new Error(`path not found: ${target}`);
-    // An explicit --dialect wins outright; otherwise `.speccle/config.json` is the source
-    // of truth, falling back to the default only when the repo has recorded nothing.
-    const declared = options.dialect ?? (await readConfig(root))?.dialect;
-    const dialect = resolveDialect(declared ?? DEFAULT_DIALECT);
+    // An explicit --dialect wins outright, everywhere; otherwise `.speccle/config.json` is the
+    // source of truth, and its per-path overrides let one pass join a mixed-language tree under
+    // each folder's own dialect (ADR-0040). The default applies only to a repo with no config.
+    const forced = options.dialect === undefined ? undefined : resolveDialect(options.dialect);
+    const config = forced === undefined ? await readConfig(root) : undefined;
+    const dialectAt = (folder) => forced ??
+        resolveDialect(config === undefined ? DEFAULT_DIALECT : resolveFacts(config, folder).dialect);
     const specFiles = await discoverSpecs(root);
     const specs = await Promise.all(specFiles.map(async (file) => parseSpec(await readFile(join(root, file), "utf8"), file)));
     const criteria = new Map();
@@ -25,18 +28,23 @@ export async function claims(target, options = {}) {
     // A slice's tests live in its own folder: only test files under a spec's folder
     // count, so unrelated tooling tests can never claim (or phantom-claim) a criterion.
     const folders = [...new Set(specFiles.map((file) => dirname(file)))];
-    const found = new Set();
-    for (const folder of folders) {
+    const folderDialects = new Map(folders.map((folder) => [folder, dialectAt(folder)]));
+    // Nested spec folders can each discover the same test file, under different dialects. The
+    // deepest folder's dialect reads it — the same most-specific-path rule the config resolves
+    // an override under, so walking the folders shortest-first lets the deepest one win.
+    const fileDialects = new Map();
+    for (const folder of [...folders].sort((a, b) => a.length - b.length)) {
+        const folderDialect = folderDialects.get(folder);
         const abs = folder === "." ? root : join(root, folder);
-        for (const file of await discoverTests(abs, dialect)) {
-            found.add(folder === "." ? file : `${folder}/${file}`);
+        for (const file of await discoverTests(abs, folderDialect)) {
+            fileDialects.set(folder === "." ? file : `${folder}/${file}`, folderDialect);
         }
     }
-    const testFiles = [...found].sort();
+    const testFiles = [...fileDialects.keys()].sort();
     const claimsById = new Map();
     for (const file of testFiles) {
         const source = await readFile(join(root, file), "utf8");
-        for (const { name, spelling } of dialect.readTestNames(source)) {
+        for (const { name, spelling } of fileDialects.get(file).readTestNames(source)) {
             for (const id of readClaimedIds(name, spelling)) {
                 const entry = claimsById.get(id) ?? [];
                 entry.push({ file, name });
@@ -47,6 +55,7 @@ export async function claims(target, options = {}) {
     const features = specs.map((spec) => ({
         key: spec.key?.raw,
         spec: spec.file,
+        dialect: folderDialects.get(dirname(spec.file)).name,
         criteria: [...criteria.entries()]
             .filter(([, value]) => value.spec === spec.file)
             .map(([id, value]) => ({
@@ -64,9 +73,12 @@ export async function claims(target, options = {}) {
         .filter(([id]) => !criteria.has(id))
         .map(([id, tests]) => ({ id, tests }))
         .sort((a, b) => compareCriterionIds(a.id, b.id));
+    // With no spec at all no folder resolved a dialect, so name the one a pass at the root
+    // would have run under rather than reporting none in play.
+    const inPlay = folders.length === 0 ? [dialectAt(".")] : [...folderDialects.values()];
     return {
         root,
-        dialect: dialect.name,
+        dialects: [...new Set(inPlay.map((entry) => entry.name))].sort(),
         testFiles,
         features,
         unclaimed,

package/dist/cli.js

@@ -5,11 +5,11 @@ import { claims } from "./claims.js";
 import { initConfig } from "./config.js";
 import { DEFAULT_DIALECT, DIALECT_NAMES } from "./dialects.js";
 import { doctor } from "./doctor.js";
-import { init, ownVersion } from "./init.js";
+import { detectDoubleLoad, init, ownVersion } from "./init.js";
 import { materializeLenses } from "./lenses.js";
 import { lint } from "./lint.js";
 import { recallRemedy, recordRemedy, REMEDY_ROUTES } from "./remedy.js";
-import { renderCalibrateRecord, renderCalibrateReport, renderCheck, renderClaims, renderConfigInit, renderDoctor, renderHuman, renderInit, renderLensesInit, renderRemedyRecall, renderRemedyRecord, renderReviewInit, renderReviewRun, renderRisk, renderSkillsInit, renderStrength, renderUpdate, renderVerify, } from "./render.js";
+import { renderCalibrateRecord, renderCalibrateReport, renderCheck, renderClaims, renderConfigInit, renderDoctor, renderDoubleLoad, renderHuman, renderInit, renderLensesInit, renderRemedyRecall, renderRemedyRecord, renderReviewInit, renderReviewRun, renderRisk, renderSkillsInit, renderStrength, renderUpdate, renderVerify, } from "./render.js";
 import { scaffoldReviewWorkflow } from "./reviewinit.js";
 import { reviewRun } from "./reviewrun.js";
 import { risk } from "./risk.js";
@@ -22,8 +22,10 @@ const USAGE = `Usage: speccle <command> [options]
 Commands:
   init [path] [--json]           Record repo facts in .speccle/config.json, materialize the
                                  skills into .claude/skills/ and the lenses into .speccle/lenses/
-  doctor [path] [--json]         Report staleness across the CLI, skills, lenses, and strength stack
-  update [path] [--json]         Refresh the skills and lenses as a diff; report stack and binary fixes
+  doctor [path] [--json]         Report staleness across the CLI, skills, lenses, the CI driver's
+                                 pin, and the strength stack
+  update [path] [--json]         Refresh the skills and lenses as a diff, and an already-installed
+                                 CI driver's pin; report stack and binary fixes
   lint [path] [--json]           Lint every SPEC.md under path (default: current directory)
   claims [path] [--json]         Join criteria to the test names that claim them — no reports needed
   verify [path] [--json]         Run .speccle/checks/ against the change set: cross-file invariants
@@ -640,19 +642,23 @@ async function runInit(args) {
     let config;
     let skills;
     let lenses;
+    let doubleLoad;
     try {
         // Materialize first, then stamp the version onto the config — so the recorded anchors
         // only ever name the skills and lenses that actually landed on disk.
         skills = await materializeSkills(root);
         lenses = await materializeLenses(root);
         config = await initConfig(root, await ownVersion());
+        // Asked after materializing: this run is what makes the repo a project-level vendor, so
+        // the double-load it may have just created is exactly what the human needs told (#183).
+        doubleLoad = await detectDoubleLoad(root);
     }
     catch (err) {
         console.error(message(err));
         return 2;
     }
     if (json) {
-        console.log(JSON.stringify({ config, skills, lenses }, null, 2));
+        console.log(JSON.stringify({ config, skills, lenses, doubleLoad }, null, 2));
     }
     else {
         console.log(renderConfigInit(config));
@@ -660,6 +666,10 @@ async function runInit(args) {
         console.log(renderSkillsInit(skills));
         console.log("");
         console.log(renderLensesInit(lenses));
+        if (doubleLoad) {
+            console.log("");
+            console.log(renderDoubleLoad());
+        }
     }
     return 0;
 }

package/dist/doctor.js

@@ -3,12 +3,14 @@ import { join, resolve } from "node:path";
 import { readConfig } from "./config.js";
 import { ownVersion, STRENGTH_DEPS, STRYKER_CONFIG_NAMES } from "./init.js";
 import { LENSES_DIR } from "./lenses.js";
+import { pinnedVersion, WORKFLOW_FILE } from "./reviewinit.js";
 import { SKILLS_DIR } from "./skills.js";
 /**
- * Reports the truth about the three things that drift in a Speccle consumer — the CLI, the
- * committed skills, and the strength stack — and never mutates a byte (#182, ADR-0046).
- * Offline and deterministic: it compares the repo against the installed CLI, not against
- * the npm registry — "is there a newer release" is `update`'s network job, not this one's.
+ * Reports the truth about everything that drifts in a Speccle consumer — the CLI, the
+ * committed skills and lenses, the CI driver's pin, and the strength stack — and never
+ * mutates a byte (#182, ADR-0046). Offline and deterministic: it compares the repo against
+ * the installed CLI, not against the npm registry — "is there a newer release" is `update`'s
+ * network job, not this one's.
  */
 export async function doctor(target) {
     const root = resolve(target);
@@ -20,6 +22,9 @@ export async function doctor(target) {
     const skillsStatus = derivePayloadStatus(await hasSkills(root), skillsRecorded, cli);
     const lensesRecorded = config?.lensesVersion ?? null;
     const lensesStatus = derivePayloadStatus(await hasLenses(root), lensesRecorded, cli);
+    const workflow = await readMaybe(join(root, WORKFLOW_FILE));
+    const driverPin = workflow === undefined ? null : (pinnedVersion(workflow) ?? null);
+    const driverStatus = derivePayloadStatus(workflow !== undefined, driverPin, cli);
     const provisioned = await anyPresent(root, STRYKER_CONFIG_NAMES);
     const declared = await declaredDeps(root);
     const deps = STRENGTH_DEPS.map((spec) => checkDep(spec, declared));
@@ -29,12 +34,16 @@ export async function doctor(target) {
             ? "drift"
             : "current";
     const current = (status) => status === "current" || status === "absent";
-    const ok = current(skillsStatus) && current(lensesStatus) && stackStatus !== "drift";
+    const ok = current(skillsStatus) &&
+        current(lensesStatus) &&
+        current(driverStatus) &&
+        stackStatus !== "drift";
     return {
         root,
         cli,
         skills: { recorded: skillsRecorded, bundled: cli, status: skillsStatus },
         lenses: { recorded: lensesRecorded, bundled: cli, status: lensesStatus },
+        driver: { recorded: driverPin, bundled: cli, status: driverStatus },
         stack: { provisioned, deps, status: stackStatus },
         ok,
     };
@@ -96,6 +105,14 @@ async function hasLenses(root) {
         return false;
     }
 }
+async function readMaybe(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
 async function anyPresent(root, names) {
     for (const name of names) {
         if (await exists(join(root, name)))

package/dist/git.js

@@ -0,0 +1,23 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+/**
+ * Spawning by name makes every call walk PATH, and the misses are what cost — measured at ~8ms
+ * each on macOS, against ~2ms for git itself. Under `npx`/`pnpm` the caller's PATH puts a dozen
+ * or more entries ahead of git's, so `risk`, which reads a baseline once per changed spec file,
+ * paid that walk per file. Resolved once here instead: the binary is fixed at module load rather
+ * than per call, which suits a short-lived CLI but means a PATH edit mid-process is not seen.
+ */
+const GIT = (process.env.PATH ?? "")
+    .split(delimiter)
+    .map((dir) => join(dir, "git"))
+    .find((candidate) => existsSync(candidate)) ?? "git";
+/** Run one git command in `root`, with the binary resolved once. */
+export function git(root, args) {
+    return spawnSync(GIT, args, { cwd: root, encoding: "utf8" });
+}
+/** Git's stdout, or undefined when the command could not run or failed. */
+export function gitStdout(root, args) {
+    const result = git(root, args);
+    return result.error === undefined && result.status === 0 ? result.stdout : undefined;
+}

package/dist/init.js

@@ -10,6 +10,10 @@ export const STRENGTH_DEPS = [
     "@stryker-mutator/core@^9",
     "@stryker-mutator/vitest-runner@^9",
 ];
+// Names this CLI has published under before (ADR-0045). A repo provisioned under an old name
+// keeps that package beside the current one, and `node_modules/.bin/` still exposes its stale
+// binary — dead weight the ladder never picks, but weight the repo should know it is carrying.
+export const SUPERSEDED_DEPS = ["speccle-oracle"];
 const LOCKFILES = [
     ["pnpm-lock.yaml", "pnpm"],
     ["package-lock.json", "npm"],
@@ -67,6 +71,8 @@ export async function init(root, options = {}) {
     const wantedDeps = [`speccle@^${await ownVersion()}`, ...STRENGTH_DEPS];
     const missingDeps = wantedDeps.filter((spec) => !declared.has(withoutVersion(spec)));
     const installCommand = missingDeps.length > 0 ? installCommandFor(packageManager, missingDeps) : null;
+    const supersededDeps = SUPERSEDED_DEPS.filter((name) => declared.has(name));
+    const removeCommand = supersededDeps.length > 0 ? removeCommandFor(packageManager, supersededDeps) : null;
     const files = [
         await provision(root, STRYKER_CONFIG_NAMES, "stryker.config.json", () => JSON.stringify(strykerConfig(packageManager, mutate), null, 2) + "\n"),
         await provision(root, VITEST_CONFIG_NAMES, "vitest.config.ts", () => vitestConfig(mutate)),
@@ -83,6 +89,8 @@ export async function init(root, options = {}) {
         missingDeps,
         installCommand,
         installRan,
+        supersededDeps,
+        removeCommand,
         mutate,
         files,
         doubleLoad,
@@ -143,6 +151,10 @@ export function installCommandFor(manager, deps) {
     const subcommand = manager === "npm" ? "install -D" : manager === "bun" ? "add -d" : "add -D";
     return `${manager} ${subcommand} ${deps.join(" ")}`;
 }
+export function removeCommandFor(manager, deps) {
+    const subcommand = manager === "npm" ? "uninstall" : "remove";
+    return `${manager} ${subcommand} ${deps.join(" ")}`;
+}
 function runInstall(root, command) {
     const [manager, ...args] = command.split(" ");
     const result = spawnSync(manager, args, { cwd: root, encoding: "utf8" });

package/dist/render.js

@@ -87,6 +87,7 @@ export function renderDoctor(report) {
         "",
         `skills   ${describePayload(report.skills, "materialized")}`,
         `lenses   ${describePayload(report.lenses, "vendored")}`,
+        `driver   ${describeDriver(report.driver)}`,
         `stack    ${describeStack(report.stack)}`,
     ];
     if (report.stack.status === "drift") {
@@ -100,6 +101,7 @@ export function renderDoctor(report) {
     lines.push("");
     const allAbsent = report.skills.status === "absent" &&
         report.lenses.status === "absent" &&
+        report.driver.status === "absent" &&
         report.stack.status === "absent";
     if (allAbsent) {
         lines.push("Speccle is not set up here — run `speccle init`");
@@ -126,6 +128,25 @@ function describePayload(payload, verb) {
             return `not ${verb} — run \`speccle init\``;
     }
 }
+/**
+ * The driver's own arm, because its two ends differ from a vendored payload's: absent means
+ * the repo never opted into a metered CI driver — a choice, not a gap to fix — and every
+ * remedy is `review init`, which is also the only thing that moves the pin.
+ */
+function describeDriver(driver) {
+    switch (driver.status) {
+        case "current":
+            return `current (${driver.bundled})`;
+        case "stale":
+            return `stale — the workflow pins ${driver.recorded}, this CLI is ${driver.bundled}; re-run \`speccle review init\``;
+        case "ahead":
+            return `ahead — the workflow pins ${driver.recorded}, newer than this CLI (${driver.bundled})`;
+        case "unstamped":
+            return "present but unpinned — re-run `speccle review init` to pin a version";
+        case "absent":
+            return "not installed — opt in with `speccle review init`";
+    }
+}
 function describeStack(stack) {
     if (stack.status === "absent")
         return "not provisioned — run `speccle strength init`";
@@ -155,6 +176,15 @@ export function renderUpdate(report) {
     else {
         lines.push(`lenses   ${report.lenses.from} → ${report.lenses.to} — review & commit the diff`);
     }
+    if (report.driver.to === null) {
+        lines.push("driver   not installed — opt in with `speccle review init`");
+    }
+    else if (report.driver.from === report.driver.to) {
+        lines.push(`driver   already pinned to ${report.driver.to} — rewritten in place`);
+    }
+    else {
+        lines.push(`driver   ${report.driver.from ?? "unpinned"} → ${report.driver.to} — review & commit the diff`);
+    }
     if (report.stack.status === "absent") {
         lines.push("stack    not provisioned — run `speccle strength init`");
     }
@@ -334,17 +364,21 @@ export function renderClaims(report) {
     if (report.features.length === 0)
         return "No SPEC.md files found.";
     const idWidth = Math.max(...report.features.flatMap((f) => f.criteria.map((c) => c.id.length)));
+    // Only a mixed pass needs to say which dialect read which slice; naming the one dialect
+    // above every spec in the common case is noise the footer already carries.
+    const mixed = report.dialects.length > 1;
     const lines = [];
     for (const feature of report.features) {
-        lines.push(feature.spec);
+        lines.push(mixed ? `${feature.spec}  (${feature.dialect})` : feature.spec);
         for (const c of feature.criteria) {
             const status = c.claimed ? plural(c.tests.length, "test name") : "unclaimed";
             lines.push(`  ${c.id.padEnd(idWidth)}  ${status.padEnd(13)}  ${c.statement}`);
         }
         lines.push("");
     }
+    const dialects = report.dialects.join(", ");
     if (report.testFiles.length === 0) {
-        lines.push(`no test files matched the ${report.dialect} dialect`);
+        lines.push(`no test files matched the ${dialects} dialect${mixed ? "s" : ""}`);
         lines.push("");
     }
     if (report.unclaimed.length > 0) {
@@ -364,7 +398,7 @@ export function renderClaims(report) {
     const claimed = report.features.reduce((n, f) => n + f.criteria.filter((c) => c.claimed).length, 0);
     const criteria = `${total} ${total === 1 ? "criterion" : "criteria"}`;
     const specs = plural(report.features.length, "spec file");
-    const counts = `${report.dialect} — ${specs}, ${criteria}, ${claimed} claimed`;
+    const counts = `${dialects} — ${specs}, ${criteria}, ${claimed} claimed`;
     lines.push(report.clean ? `${counts}, clean` : counts);
     return lines.join("\n");
 }
@@ -388,14 +422,26 @@ export function renderInit(report) {
         lines.push('  stryker config: coverageAnalysis "perTest", the json reporter');
         lines.push("  vitest config:  istanbul provider, json-summary reporter");
     }
+    if (report.supersededDeps.length > 0) {
+        lines.push("");
+        lines.push(`superseded devDependency: ${report.supersededDeps.join(", ")}`);
+        lines.push("this CLI publishes as speccle now — the old package is a stale binary beside");
+        lines.push(`the current one. Remove it yourself: ${report.removeCommand}`);
+    }
     if (report.doubleLoad) {
         lines.push("");
-        lines.push("warning: this repo vendors the speccle skills project-level AND the");
-        lines.push("speccle plugin is enabled user-level — two copies of every skill will");
-        lines.push("load. Disable one: /plugin (user-level) or remove .claude/skills/ here.");
+        lines.push(renderDoubleLoad());
     }
     return lines.join("\n");
 }
+/**
+ * One wording for both entry points. `speccle init` vendors the skills and `speccle strength
+ * init` provisions the stack; either run is a fair place to discover the double-load, so
+ * neither stays quiet about it (#183).
+ */
+export function renderDoubleLoad() {
+    return join("warning: this repo vendors the speccle skills project-level AND the", "speccle plugin is enabled user-level — two copies of every skill will", "load. Disable one: /plugin (user-level) or remove .claude/skills/ here.");
+}
 export function renderHuman(report) {
     if (report.files.length === 0)
         return "No SPEC.md files found.";

package/dist/risk.js

@@ -1,11 +1,11 @@
-import { spawnSync } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { assertPredicate, contentReader, gitChangeSet, gitRangeChangeSet, isDirectory, matching, messageOf, } from "./changeset.js";
 import { claims } from "./claims.js";
-import { readConfig } from "./config.js";
+import { readConfig, resolveFacts } from "./config.js";
 import { DEFAULT_DIALECT, resolveDialect } from "./dialects.js";
 import { discoverSpecs } from "./discover.js";
+import { gitStdout } from "./git.js";
 import { parseSpec } from "./spec.js";
 /** Where a repo declares its risk policy (ADR-0041) — judgement, so a single hand-edited file. */
 export const RISK_POLICY_FILE = ".speccle/risk.json";
@@ -30,8 +30,9 @@ export async function risk(target, options = {}) {
     // reads from, and the two must agree or the diff is measured against the wrong commit.
     const range = options.base === undefined ? undefined : gitRangeChangeSet(root, options.base);
     const changed = (options.changed ?? range?.changed ?? gitChangeSet(root)).slice().sort();
-    const declared = options.dialect ?? (await readConfig(root))?.dialect;
-    const dialect = resolveDialect(declared ?? DEFAULT_DIALECT);
+    // Resolved here rather than where it is used, so a bogus `--dialect` fails loudly even when
+    // every signal that would have read it is muted.
+    const forced = options.dialect === undefined ? undefined : resolveDialect(options.dialect);
     const baselineRef = range?.baseline ?? "HEAD";
     const baseline = options.baseline ?? ((file) => gitBaseline(root, file, baselineRef));
     const read = contentReader(root);
@@ -45,7 +46,7 @@ export async function risk(target, options = {}) {
     // Baseline signals — the spec-aware facts only Speccle can see. A muted (0-weight) signal is
     // not computed at all, keeping the git and claims work off the path when a repo has opted out.
     if (weightOf("spec-silent-change") > 0) {
-        fireBaseline("spec-silent-change", "production source changed in a governed slice whose SPEC.md did not", await specSilentChanges(root, changed, dialect));
+        fireBaseline("spec-silent-change", "production source changed in a governed slice whose SPEC.md did not", await specSilentChanges(root, changed, forced));
     }
     if (weightOf("criterion-retired") > 0 || weightOf("criterion-reworded") > 0) {
         const { retired, reworded } = await criterionDiffs(changed, read, baseline);
@@ -53,7 +54,7 @@ export async function risk(target, options = {}) {
         fireBaseline("criterion-reworded", "a criterion's statement was reworded", reworded);
     }
     if (weightOf("unclaimed-change") > 0) {
-        fireBaseline("unclaimed-change", "changed code lives in a slice with a criterion no test claims", await unclaimedChanges(root, changed, dialect.name));
+        fireBaseline("unclaimed-change", "changed code lives in a slice with a criterion no test claims", await unclaimedChanges(root, changed, options.dialect));
     }
     // Policy signals — repo-defined predicates over the change set.
     for (const signal of policy.signals ?? []) {
@@ -82,9 +83,20 @@ export async function risk(target, options = {}) {
         humanRequired: score >= threshold,
     };
 }
-/** Governed-slice production source that changed while the slice's SPEC.md stayed silent. */
-async function specSilentChanges(root, changed, dialect) {
+/**
+ * Governed-slice production source that changed while the slice's SPEC.md stayed silent.
+ *
+ * Whether a changed file is a test is a per-path question, so with no forced dialect each file
+ * is judged under the one the config resolves at its own path (ADR-0040) — a swift slice's
+ * `PlayerTests.swift` is a test even in a repo that defaults to ts-vitest. Resolved at the file
+ * rather than its spec folder: that also honours an override deeper than the folder, and keeps
+ * an outer slice from misreading a nested slice's tests as production source.
+ */
+async function specSilentChanges(root, changed, forced) {
     const specs = await discoverSpecs(root);
+    const config = forced === undefined ? await readConfig(root) : undefined;
+    const dialectAt = (file) => forced ??
+        resolveDialect(config === undefined ? DEFAULT_DIALECT : resolveFacts(config, file).dialect);
     const silent = [];
     for (const spec of specs) {
         const folder = dirname(spec);
@@ -93,7 +105,7 @@ async function specSilentChanges(root, changed, dialect) {
         for (const file of changed) {
             if (!underFolder(file, folder))
                 continue;
-            if (isContractFile(file, folder) || dialect.isTestFile(file))
+            if (isContractFile(file, folder) || dialectAt(file).isTestFile(file))
                 continue;
             silent.push(file);
         }
@@ -119,9 +131,13 @@ async function criterionDiffs(changed, read, baseline) {
     }
     return { retired, reworded };
 }
-/** Unclaimed criterion ids in the governed slices this change touched. */
+/**
+ * Unclaimed criterion ids in the governed slices this change touched. Only an explicit
+ * `--dialect` is passed down: without one, `claims` resolves each slice's own dialect from the
+ * config, so a mixed-language tree is not joined under whichever dialect the repo defaults to.
+ */
 async function unclaimedChanges(root, changed, dialect) {
-    const report = await claims(root, { dialect });
+    const report = await claims(root, { ...(dialect !== undefined && { dialect }) });
     const unclaimed = [];
     for (const feature of report.features) {
         const folder = dirname(feature.spec);
@@ -205,8 +221,7 @@ function assertPolicy(policy) {
 }
 /** Content of a path at `ref`, or undefined when git has no baseline for it (new or no commits). */
 function gitBaseline(root, file, ref) {
-    const result = spawnSync("git", ["show", `${ref}:./${file}`], { cwd: root, encoding: "utf8" });
-    return result.status === 0 ? result.stdout : undefined;
+    return gitStdout(root, ["show", `${ref}:./${file}`]);
 }
 function isSpecPath(file) {
     return file === "SPEC.md" || file.endsWith("/SPEC.md");

package/dist/update.js

@@ -3,6 +3,7 @@ import { initConfig, readConfig } from "./config.js";
 import { doctor } from "./doctor.js";
 import { detectPackageManager, installCommandFor } from "./init.js";
 import { materializeLenses } from "./lenses.js";
+import { scaffoldReviewWorkflow } from "./reviewinit.js";
 import { materializeSkills } from "./skills.js";
 /** The global-install one-liner. npm is the portable choice: it ships with Node. */
 const BINARY_UPDATE = "npm install -g speccle@latest";
@@ -13,6 +14,9 @@ const BINARY_UPDATE = "npm install -g speccle@latest";
  * left alone — while the strength stack and global binary are reported, never rewritten: the
  * ticket's principle that only the binary may update silently, and it does so through the
  * printed command, not through this deterministic tool.
+ *
+ * The CI driver moves only if it is already there (#187): the workflow spends a metered API
+ * key per run, so scaffolding one into a repo that never asked would be opting it in silently.
  */
 export async function update(target) {
     const root = resolve(target);
@@ -24,6 +28,9 @@ export async function update(target) {
     const materializedSkills = await materializeSkills(root);
     const materializedLenses = await materializeLenses(root);
     await initConfig(root, version); // re-stamp both anchors; the repo facts stay kept
+    const hasDriver = diagnosis.driver.status !== "absent";
+    if (hasDriver)
+        await scaffoldReviewWorkflow(root, version);
     const outstanding = diagnosis.stack.deps.filter((dep) => dep.status !== "ok");
     const fixCommand = diagnosis.stack.status === "drift"
         ? installCommandFor(await detectPackageManager(root), outstanding.map((dep) => `${dep.name}@^${dep.wantedMajor}`))
@@ -43,6 +50,7 @@ export async function update(target) {
             dir: materializedLenses.dir,
             lenses: materializedLenses.lenses,
         },
+        driver: { from: diagnosis.driver.recorded, to: hasDriver ? version : null },
         stack: { status: diagnosis.stack.status, deps: diagnosis.stack.deps, fixCommand },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speccle",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Speccle's deterministic tooling: spec lint and the oracle-strength heatmap. No LLM, bar the opt-in CI review driver.",
   "license": "MIT",
   "author": {