@elalfner/relevo 0.5.0 → 0.6.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "relevo",
   "displayName": "Relevo",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "An automatic issue-to-merge workflow where an agent builds and people verify.",
   "author": {
     "name": "Elias Alfaro"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elalfner/relevo",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Relevo: an automatic issue-to-merge workflow where an agent builds and people verify.",
   "type": "module",
   "license": "MIT",

package/scripts/go-worktree.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+// The worktree of an interactive `go` in Claude Code. Usage:
+//   node scripts/go-worktree.mjs create <issue> [--config relevo.yml]   prints {"worktree","base"} as JSON
+//   node scripts/go-worktree.mjs remove <issue>
+//   exit 0: done   1: git failed   2: bad usage   3: the worktree of the issue already exists   4: already in a linked worktree
+// The skill reads exit 3 as "stop" and exit 4 as "build where you are".
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { loadConfig } from './lib/config.mjs';
+import { createWorktree, EXIT, removeWorktree } from './lib/go-worktree.mjs';
+
+const args = process.argv.slice(2);
+const [command, issue] = args;
+const configAt = args.indexOf('--config');
+const fail = (message, code = EXIT.usage) => {
+  console.error(message);
+  process.exit(code);
+};
+
+const runner = {
+  capture: (cmd, cmdArgs, options) => execFileSync(cmd, cmdArgs, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], cwd: options.cwd }),
+};
+
+let result;
+if (command === 'create') {
+  const configPath = resolve(configAt === -1 ? 'relevo.yml' : args[configAt + 1]);
+  if (!existsSync(configPath)) fail(`relevo.yml not found at ${configPath}. Run /relevo:init to create it.`);
+  const loaded = loadConfig(readFileSync(configPath, 'utf8'));
+  if (!loaded.ok) fail(loaded.errors.map((e) => `error: ${e.message}`).join('\n'));
+  result = createWorktree({ issue, config: loaded.config, runner, exists: existsSync });
+  if (result.status === EXIT.ok) console.log(JSON.stringify({ worktree: result.worktree, base: result.base }));
+} else if (command === 'remove') {
+  result = removeWorktree({ issue, runner, exists: existsSync });
+} else {
+  fail('usage: go-worktree.mjs create|remove <issue>');
+}
+result.messages.forEach((m) => console.error(m));
+process.exit(result.status);

package/scripts/lib/doctor.mjs

@@ -13,7 +13,7 @@ import { loadConfig } from './config.mjs';
 import { labelDefinitions } from './labels.mjs';
 import { credentialMode, cloudBuilds, CLOUD_VARIABLE } from './execution-mode.mjs';
 import { SKILL_DIRS, SIZE_BUDGET_BYTES, folderHash, lockDifferences, resolveRoleSkills, skillBudget } from './role-skills.mjs';
-import { ROLES, profileLocations, profileLookups, resolveProfile } from './stack-profile.mjs';
+import { ROLES, profileLocations, profileLookups, repositoryProfilePath, resolveProfile } from './stack-profile.mjs';
 
 export const REQUIRED_SKILLS = ['openspec-explore', 'grill-with-docs', 'grilling', 'domain-modeling'];
 export const SKILL_INSTALL = {
@@ -338,6 +338,14 @@ function gatherPlatforms(f, p, tryRun) {
         const tool = resolved.profile.targets[target] ?? '';
         return { target, tool, ok: tool === '' ? true : available(tool) };
       });
+      // The cloud and a fresh clone read the repository's layer from git, not from this working copy. `null` means
+      // git could not say (no git, or not a repository).
+      if (resolved.profile.layers.includes('repository')) {
+        const path = repositoryProfilePath(platform.stack);
+        if (!f.git) entry.repositoryLayerTracked = null;
+        else if (tryRun(() => { p.tool('git', ['ls-files', '--error-unmatch', path]); return true; }, false)) entry.repositoryLayerTracked = true;
+        else entry.repositoryLayerTracked = tryRun(() => { p.tool('git', ['rev-parse', '--is-inside-work-tree']); return true; }, false) ? false : null;
+      }
     }
     f.platformFacts.push(entry);
   });
@@ -474,6 +482,11 @@ function platformChecks(f) {
     }
     const layers = e.profile.layers.map((l) => (l === 'plugin' ? 'default of the plugin' : `.relevo/stacks/${e.stack}.md`)).join(' + ');
     r.push(pass(`platform.${e.name}.profile`, `platform ${e.name} (${e.stack}, ${e.path}): profile = ${layers}`));
+    if (e.repositoryLayerTracked === false) {
+      const path = `.relevo/stacks/${e.stack}.md`;
+      const effect = e.profile.layers.includes('plugin') ? `use only the plugin's profile for ${e.stack}, without your rules` : `have no profile for ${e.stack}`;
+      r.push(warn(`platform.${e.name}.profile.tracked`, `platform ${e.name}: ${path} is not tracked by git, so the cloud run and a fresh clone ${effect}`, `commit ${path} and push it with the rest of the repository's Relevo files`));
+    }
     (e.profile.ignored ?? []).forEach((x) => {
       r.push(warn(`platform.${e.name}.ignored.${x.key}`, `platform ${e.name}: the repository profile sets ${x.key} = "${x.value}", which is ignored (the plugin keeps "${x.kept}")`, `a command is replaced with platforms.${e.name}.checks in relevo.yml, not in the profile`));
     });

package/scripts/lib/go-local.mjs

@@ -6,12 +6,13 @@
 //   stream(cmd, args, { cwd, env }) -> exit status (the output goes to the terminal); throws with code ENOENT when missing
 
 import { tmpdir } from 'node:os';
-import { basename, dirname, join } from 'node:path';
+import { basename, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { cloudBuilds } from './execution-mode.mjs';
 import { runFlags } from './run-flags.mjs';
+import { WORKTREES_FOLDER, worktreePath } from './worktree-path.mjs';
 
-export const WORKTREES_FOLDER = '.relevo-worktrees';
+export { WORKTREES_FOLDER };
 // The guard is part of the plugin, not of the project that is built, so it is found next to this file.
 const GUARD = fileURLToPath(new URL('../agent-guard.mjs', import.meta.url));
 // The same time limit as the cloud step of the Antigravity agent.
@@ -20,7 +21,7 @@ export const GUARD_TIMEOUT_MINUTES = 50;
 /** What a local run will do, without doing it: the worktree and the `claude` or `agy` command. Pure. */
 export function planLocalRun({ issue, repoRoot, config }) {
   const base = config.branches.base;
-  const worktree = join(dirname(repoRoot), WORKTREES_FOLDER, `${basename(repoRoot)}-${issue}`);
+  const worktree = worktreePath(repoRoot, issue);
   const isAntigravity = config.agent?.build === 'antigravity';
   const command = isAntigravity
     ? ['node', [

package/scripts/lib/go-worktree.mjs

@@ -0,0 +1,85 @@
+// The worktree of an interactive `go` in Claude Code. Implements "An interactive Claude Code run builds in its own
+// worktree" of the execution-modes specification: the skill makes the worktree here, enters it with EnterWorktree, and
+// asks for its removal here when the run ends cleanly.
+//
+// Every process goes through an injected runner so the logic is tested without git or a network:
+//   capture(cmd, args, { cwd }) -> stdout (throws when the command fails)
+
+import { worktreePath } from './worktree-path.mjs';
+
+/** Exit codes of `go-worktree.mjs`. `exists` and `linked` are answers, not failures: the skill reads them. */
+export const EXIT = { ok: 0, failed: 1, usage: 2, exists: 3, linked: 4 };
+
+const fail = (status, message) => ({ status, worktree: null, messages: [message] });
+// git prints progress ("Preparing worktree ...") before the reason, so the reason is the `fatal:` or `error:` line, or the last one.
+function firstLine(err) {
+  const lines = String(err.stderr ?? err.message).trim().split('\n').map((l) => l.trim()).filter(Boolean);
+  return lines.find((l) => /^(fatal|error):/.test(l)) ?? lines.at(-1) ?? 'git failed';
+}
+
+function context(issue, runner) {
+  if (!/^\d+$/.test(String(issue))) return { early: fail(EXIT.usage, 'give the issue number: go-worktree.mjs create|remove <issue>') };
+  try {
+    const repoRoot = runner.capture('git', ['rev-parse', '--show-toplevel'], {}).trim();
+    const [gitDir, commonDir] = runner
+      .capture('git', ['rev-parse', '--path-format=absolute', '--git-dir', '--git-common-dir'], { cwd: repoRoot })
+      .trim()
+      .split('\n');
+    return { repoRoot, linked: gitDir !== commonDir };
+  } catch {
+    return { early: fail(EXIT.usage, 'not inside a git repository (or git is older than 2.31)') };
+  }
+}
+
+/**
+ * Make the worktree of an issue from `origin/<base>`. `linked` when the session is already in a linked worktree (the
+ * build runs where it is), `exists` when the worktree of the issue is already there (the same issue twice).
+ */
+export function createWorktree({ issue, config, runner, exists = () => false }) {
+  const ctx = context(issue, runner);
+  if (ctx.early) return ctx.early;
+  if (ctx.linked) {
+    return fail(EXIT.linked, 'this session is already in a linked worktree: build here, no worktree is made');
+  }
+  const base = config.branches.base;
+  const worktree = worktreePath(ctx.repoRoot, issue);
+  if (exists(worktree)) {
+    return {
+      status: EXIT.exists,
+      worktree,
+      messages: [`${worktree} already exists: another run is building #${issue}, or a failed one left it. Finish it or remove it first (git worktree remove --force "${worktree}")`],
+    };
+  }
+  try {
+    // A folder deleted by hand leaves a registration that makes `worktree add` fail; prune only drops those.
+    runner.capture('git', ['worktree', 'prune'], { cwd: ctx.repoRoot });
+    runner.capture('git', ['fetch', 'origin', base], { cwd: ctx.repoRoot });
+    runner.capture('git', ['worktree', 'add', '--detach', worktree, `origin/${base}`], { cwd: ctx.repoRoot });
+  } catch (err) {
+    return fail(EXIT.failed, `could not prepare the worktree: ${firstLine(err)}`);
+  }
+  return { status: EXIT.ok, worktree, base, messages: [] };
+}
+
+/** Remove the worktree of an issue, after a clean end. Run it from the main working tree, not from inside. */
+export function removeWorktree({ issue, runner, exists = () => true }) {
+  const ctx = context(issue, runner);
+  if (ctx.early) return ctx.early;
+  if (ctx.linked) return fail(EXIT.linked, 'leave the worktree first (ExitWorktree with keep), then remove it from the main working tree');
+  const worktree = worktreePath(ctx.repoRoot, issue);
+  if (!exists(worktree)) {
+    // The folder may be gone while git still lists it: drop that registration so the issue can be built again.
+    try {
+      runner.capture('git', ['worktree', 'prune'], { cwd: ctx.repoRoot });
+    } catch (err) {
+      return { status: EXIT.failed, worktree, messages: [`could not prune the worktrees: ${firstLine(err)}; run git worktree prune`] };
+    }
+    return { status: EXIT.ok, worktree, messages: [`${worktree} is not there: nothing to remove`] };
+  }
+  try {
+    runner.capture('git', ['worktree', 'remove', '--force', worktree], { cwd: ctx.repoRoot });
+  } catch (err) {
+    return { status: EXIT.failed, worktree, messages: [`could not remove ${worktree}: ${firstLine(err)}; run git worktree remove --force "${worktree}"`] };
+  }
+  return { status: EXIT.ok, worktree, messages: [] };
+}

package/scripts/lib/init.mjs

@@ -208,11 +208,11 @@ export function planInit({ facts, answers, templates, current, admin }) {
   if (facts.configText !== null) items.push(item('config', facts.config ? 'ok' : 'differs', facts.config ? 'relevo.yml exists and is valid' : `relevo.yml exists but is invalid: ${facts.configErrors.join('; ')}`));
   else items.push(item('config', 'todo', 'Create relevo.yml from the answers', { content: renderConfig(templates.config, { base, release, ...answers }) }));
 
-  // optional stack profiles of the repository (created only when asked for, and never committed by init)
+  // optional stack profiles of the repository (created only when asked for; init never commits them, the person does)
   (answers.stackProfiles ?? []).forEach((stack) => {
     const path = `.relevo/stacks/${stack}.md`;
     if ((current.stackProfiles ?? {})[stack]) items.push(item(`stack-profile.${stack}`, 'ok', `${path} exists`));
-    else items.push(item(`stack-profile.${stack}`, 'todo', `Create ${path}, a commented profile that adds to the plugin's (not committed)`, { path, content: stackProfileTemplate(stack) }));
+    else items.push(item(`stack-profile.${stack}`, 'todo', `Create ${path}, a commented profile that adds to the plugin's (left for you to commit)`, { path, content: stackProfileTemplate(stack) }));
   });
 
   // labels

package/scripts/lib/worktree-path.mjs

@@ -0,0 +1,11 @@
+// Where the worktree of an issue lives: next to the repository, never inside it. Shared by `go-local` and
+// `go-worktree` so that the two cannot name it differently.
+
+import { basename, dirname, join } from 'node:path';
+
+export const WORKTREES_FOLDER = '.relevo-worktrees';
+
+/** The worktree of an issue: `<parent of the repository>/.relevo-worktrees/<repository>-<issue>`. Pure. */
+export function worktreePath(repoRoot, issue) {
+  return join(dirname(repoRoot), WORKTREES_FOLDER, `${basename(repoRoot)}-${issue}`);
+}

package/skills/go/SKILL.md

@@ -27,10 +27,22 @@ Launch `relevo:dev` and `relevo:qa` in the foreground and wait for each report b
 
 ## Where it runs
 
-In the cloud the workflow starts this skill with the decision already made. A person can also start it on their machine: `node ${CLAUDE_PLUGIN_ROOT}/scripts/go-local.mjs <issue>` runs it in a separate git worktree, with the same limits and tool lists as the workflow, and removes the worktree when it ends cleanly. Started by hand without that script, it needs a clean working tree (the preflight below stops otherwise).
+In the cloud the workflow starts this skill with the decision already made. A person can also start it on their machine: `node ${CLAUDE_PLUGIN_ROOT}/scripts/go-local.mjs <issue>` runs it in a separate git worktree, with the same limits and tool lists as the workflow, and removes the worktree when it ends cleanly.
 
 **When `$ARGUMENTS` has `--local`**, do not build in this session: run `node ${CLAUDE_PLUGIN_ROOT}/scripts/go-local.mjs <issue>`, show what it prints, and stop. The build happens in the process that script starts, in its own worktree and with the closed tool lists, which a plain session does not have.
 
+**In an interactive session** (started by hand without `--decision` and without `--local`), do not build in the folder you were started in: another session may be building another issue there, and the person may have changes of their own. Before step 0, make a worktree for the issue:
+
+```bash
+node ${CLAUDE_PLUGIN_ROOT}/scripts/go-worktree.mjs create <issue>
+```
+
+- Exit 0: it prints `{"worktree": "<path>", "base": "<base>"}`. Enter it with `EnterWorktree` and its `path` (never its `name`, which would branch from the default branch and not from the base of the project). From then on every step, command and agent works in that folder.
+- Exit 4: the session is already in a linked worktree (a run of `go-local.mjs`, or one the person made). Build where you are, make no worktree, and skip the exit below.
+- Any other exit (for example 3, the worktree of this issue already exists because another run is building it or a failed one left it): show its message and stop without changing anything.
+
+At the end of the run, before the final report, leave the worktree: call `ExitWorktree` with `keep`. Then, from the folder you came from, remove it with `node ${CLAUDE_PLUGIN_ROOT}/scripts/go-worktree.mjs remove <issue>` when the outcome is `built` or a gate decision that stopped before step 2 (nothing was built, so nothing is lost). After the failure path, or if the run stopped for any other reason, leave the worktree on disk and say its path in the report.
+
 ## OpenSpec commands
 
 Use these OpenSpec commands and no others:

package/skills/init/SKILL.md

@@ -36,7 +36,7 @@ If `relevo.yml` already exists and is valid, skip this step. Otherwise ask, in s
 - the platforms: for each one a name, its stack (look at the project to propose one: the profiles in `${CLAUDE_PLUGIN_ROOT}/stacks/` are the stacks Relevo ships with: `flutter`, `vue`, `laravel` and `supabase`), the folder where it lives (`.` for a repository with one platform, `apps/web` in a monorepo) and, for a stack that has targets, which ones (for Flutter: `android`, `ios`, `web`; for Vue: `web`; Laravel and Supabase have none). Several platforms in one repository are written down, but `go` builds only a repository with one for now;
 - where `go` builds: in the cloud, on each person's machine, or both (the default), and, for the cloud, with an API key from the Anthropic Console (the default) or with a subscription token. A subscription's quota is shared by every run and by the interactive use of the account, so `init` sets `limits.concurrent_agents` to 1 for it. Nothing about this goes in `relevo.yml` apart from that number: the installed workflows, the secret that exists and the repository variable `RELEVO_CLOUD_GO` (`off` pauses the cloud at once, with no pull request) decide it;
 - the repositories this one depends on, if any (`owner/repo`, for example the back end of a front end): they are written to `links`, the closed list that `Depends-on: owner/repo#N` is checked against;
-- whether to create a commented `.relevo/stacks/<stack>.md` for each stack, where the project can add its own hygiene to the plugin's profile (optional; it is not committed);
+- whether to create a commented `.relevo/stacks/<stack>.md` for each stack, where the project can add its own hygiene to the plugin's profile (optional; `init` creates it but does not commit it: it is left for the person to commit, because the cloud and teammates read it from git);
 - which agent builds in the cloud, only when the person says they use Antigravity: `claude` (the default) or `antigravity`. With `antigravity` the model key is `GEMINI_API_KEY`, a key made only for Relevo in its own Google Cloud project with a quota, and the limit asked below is a number of tokens (`limits.run_max_tokens`) because that agent has no cost limit; `docs/security.md` says what else it cannot enforce;
 - the cost limit per unattended run in US dollars: the template's 5 is a placeholder the person must accept or change (with `antigravity`, the token limit instead).
 
@@ -72,4 +72,4 @@ Run `node ${CLAUDE_PLUGIN_ROOT}/scripts/doctor.mjs` and show its output.
 
 ## Report
 
-Finish with: what was created, what was left alone, what the person must still do by hand (always the model credential in the repository secrets, with all whitespace removed from a subscription token, and committing and pushing the new files to the default branch, because a workflow only runs from there), and the doctor result.
+Finish with: what was created, what was left alone, what the person must still do by hand (always the model credential in the repository secrets, with all whitespace removed from a subscription token, and committing and pushing the new files to the default branch, because a workflow only runs from there; name each `.relevo/stacks/<stack>.md` it created among them), and the doctor result.

package/stacks/flutter.md

@@ -4,7 +4,7 @@ commands:
   analyze: flutter analyze --no-pub
   test: flutter test --reporter=compact --no-pub
   format: dart format
-generated: ['*.g.dart', '*.freezed.dart']
+generated: ['*.g.dart', '*.freezed.dart', '*.mocks.dart']
 tools: [flutter]
 requires_skills: []
 skills:
@@ -22,29 +22,67 @@ targets:
 
 ## Verification
 
-Prefer the Dart tooling server's tools when they are available in this session (analysis, running tests, formatting). Otherwise use the commands of this profile: `analyze`, `test` and `format`.
+Run the commands of this profile from the folder of the platform: `analyze`, `test` and `format`. Run `format` on the files you changed, never on generated files.
+
+When the Dart and Flutter MCP server is connected, you may use the tools that write nothing: `analyze_files` for analysis, `lsp` and `read_package_uris` to check an API or a symbol instead of guessing it, and `run_tests` when the server enables it (it is off by default). When a tool is missing, use the command of this profile. No agent uses `dart_format`, `dart_fix`, `pub`, `hot_reload`, `hot_restart` or `launch_app` during a run: they write files or drive an app, and `dart_format` formats the whole project, generated files included.
+
+When annotated models or mocks changed, run `dart run build_runner build --delete-conflicting-outputs` before the tests.
 
 Do not claim the code compiles, analyses clean or passes tests unless you ran the tools and saw it. If neither the tooling server nor Flutter is available, say so plainly in your report.
 
+## Architecture
+
+Follow the architecture that the project's rules declare (MVVM, bloc, riverpod or another). When they declare none, write new code with the structure of Flutter's architecture guide: UI and data in separate layers; data reached through repositories, which call stateless services that wrap each API or plugin; dependencies passed by constructor and kept private; no data logic in widgets. Command and Result objects, and any state-management package, are not required by this profile; use them when the project's rules do.
+
 ## Hygiene for the developer
 
+Lifecycle and state:
+
 - Check `mounted` before using a `BuildContext` or calling `setState` after an `await`.
-- Dispose every controller, stream subscription and listener you create.
+- Dispose every controller, stream subscription and listener you create. A `ChangeNotifierProvider(create:)` disposes its model itself.
+- Never call an API, create a future or show a dialog inside `build()`; start them in `initState` or in an event handler.
 - Avoid the null-assertion operator unless a prior check makes it provably safe.
 - Give every screen loading, empty and error states.
 - Prevent double submission of actions.
-- Keep layouts from overflowing on small screens.
+
+Layout:
+
+- Keep layouts from overflowing on small screens: wrap a long `Text` or other unconstrained child of a `Row` or `Column` in `Expanded` or `Flexible`.
+- Give a `ListView` or `GridView` inside a `Column` a bound (`Expanded` or a fixed height), and a `TextField` inside a `Row` a width (`Expanded` or `SizedBox`).
+- Put `Expanded` and `Flexible` directly in a `Row`, `Column` or `Flex`, and `Positioned` directly in a `Stack`.
+- Give each scroll view its own `ScrollController`.
+
+Performance:
+
+- Build long lists and grids with the builder constructors, not with a list of children.
+- Keep `build()` cheap, and call `setState` as low in the tree as the change allows.
+- Split large widgets into smaller widget classes rather than helper methods that return widgets.
+- Keep `Opacity` and clipping out of animations; use `AnimatedOpacity` or a semi-transparent colour.
+- Move heavy work, such as decoding a large JSON response, off the UI isolate with `Isolate.run`. On the web it still runs on the main thread.
+
+Web:
+
+- Use `package:web` and `dart:js_interop`; `dart:html` and `package:js` prevent the Wasm build.
+- Do not use `dart:io` or `Platform` in code that runs on the web; check `kIsWeb` or use a conditional import.
+
+Tests:
+
 - Write unit and widget tests for the scenarios the platform allows. A scenario that can only be seen on a device or in another app is covered by correct code, and is verified later in the on-device review.
+- Make fakes of repositories and services for tests; a mock is also acceptable. A plugin throws `MissingPluginException` in unit and widget tests, so put it behind the project's own class and fake that class.
 
 ## What the auditor looks for in the diff
 
-- **Async and lifecycle**: a `BuildContext` use or `setState` after an `await` without a `mounted` check.
+- **Async and lifecycle**: a `BuildContext` use or `setState` after an `await` without a `mounted` check; a network call, a new future, `setState` or `showDialog` inside `build()`.
 - **Leaks**: a controller, stream subscription or listener created and never disposed.
 - **Null safety**: an unchecked null-assertion operator that can throw at runtime.
-- **Layout**: unconstrained content that can overflow on a small screen.
+- **Layout**: unconstrained content that can overflow on a small screen; a `ListView` or `GridView` in a `Column` without a bound; a `TextField` in a `Row` without a width; `Expanded`, `Flexible` or `Positioned` outside a compatible parent; one `ScrollController` attached to several scroll views.
 - **States**: missing loading, empty or error states; an action that can be triggered twice.
+- **Performance**: a long list built from a list of children; costly work in `build()`; `setState` high in the tree for a local change; `Opacity` or clipping inside an animation; a large JSON decode on the UI isolate.
+- **Web**: an import of `dart:html` or `package:js`; `dart:io` or `Platform` in code that runs on the web.
+- **Tests**: a test that calls a real plugin, network or service instead of a fake or a mock.
+- **Architecture**: report only what breaks a rule the project wrote down. Whatever the project declares, an HTTP or GraphQL client called from a widget is a finding.
 - **Android specifics**: an external-app launch with no handling for the app being missing, permission use without handling denial, behaviour on the back button.
-- **Generated code**: leave generated files (`*.g.dart`, `*.freezed.dart`) out of the review.
+- **Generated code**: leave generated files (`*.g.dart`, `*.freezed.dart`, `*.mocks.dart`) out of the review.
 
 ## Targets
 

package/templates/workflows/relevo-digest.yml

@@ -9,7 +9,7 @@ name: relevo-digest
 # The version of @elalfner/relevo whose scripts this workflow runs. The plugin's templates carry the version they
 # were released with, and `/relevo:init` reports this file as different when it is older; change it by hand to update.
 env:
-  RELEVO_VERSION: '0.5.0'
+  RELEVO_VERSION: '0.6.0'
 
 on:
   schedule:

package/templates/workflows/relevo-go.yml

@@ -15,7 +15,7 @@ name: relevo-go
 # The version of @elalfner/relevo whose scripts this workflow runs. The plugin's templates carry the version they
 # were released with, and `/relevo:init` reports this file as different when it is older; change it by hand to update.
 env:
-  RELEVO_VERSION: '0.5.0'
+  RELEVO_VERSION: '0.6.0'
 
 on:
   issues:

package/templates/workflows/relevo-queue.yml

@@ -10,7 +10,7 @@ name: relevo-queue
 # The version of @elalfner/relevo whose scripts this workflow runs. The plugin's templates carry the version they
 # were released with, and `/relevo:init` reports this file as different when it is older; change it by hand to update.
 env:
-  RELEVO_VERSION: '0.5.0'
+  RELEVO_VERSION: '0.6.0'
 
 on:
   issues:

package/templates/workflows/relevo-review.yml

@@ -10,7 +10,7 @@ name: relevo-review
 # The version of @elalfner/relevo whose scripts this workflow runs. The plugin's templates carry the version they
 # were released with, and `/relevo:init` reports this file as different when it is older; change it by hand to update.
 env:
-  RELEVO_VERSION: '0.5.0'
+  RELEVO_VERSION: '0.6.0'
 
 on:
   pull_request_review:

package/templates/workflows/relevo-sla.yml

@@ -8,7 +8,7 @@ name: relevo-sla
 # The version of @elalfner/relevo whose scripts this workflow runs. The plugin's templates carry the version they
 # were released with, and `/relevo:init` reports this file as different when it is older; change it by hand to update.
 env:
-  RELEVO_VERSION: '0.5.0'
+  RELEVO_VERSION: '0.6.0'
 
 on:
   schedule: