@nanobpm/nano-workforce 0.171.4 → 0.171.5

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.171.5](https://github.com/nanobpm/nano-workforce/compare/v0.171.4...v0.171.5) (2026-09-01)
+
+### Performance Improvements
+
+* **agents:** warm the build cache once, then build module-scoped — never a cold `-am` reactor build ([#682](https://github.com/nanobpm/nano-workforce/issues/682)) ([338057b](https://github.com/nanobpm/nano-workforce/commit/338057b7f65cbf4e61cf4d74efaa596b3422532b)), closes [#681](https://github.com/nanobpm/nano-workforce/issues/681)
+
 ## [0.171.4](https://github.com/nanobpm/nano-workforce/compare/v0.171.3...v0.171.4) (2026-09-01)
 
 ### Bug Fixes

package/docs/agent-guide.md

@@ -154,6 +154,30 @@ Track a plan the same way you track PRs — its `process_key` is an engine insta
 can inspect in §5, and the PRs it opens show up in `/status` as ordinary convergence
 loops.
 
+### Build hygiene — implementation agents warm up once, then build module-scoped
+
+Implementation and CI-fix agents run on **stateless / ephemeral workers**: the
+workspace, including its build outputs, is thrown away between runs, so each worker pays any
+cold whole-reactor build tax independently. To keep iterations fast, the implementation
+prompts (`resources/prompts/feature.md`, `resources/prompts/fix-ci.md`) instruct every
+agent to, **before iterating on a build in the target repo**:
+
+1. **Read the target repo's own `AGENTS.md` / `CONTRIBUTING.md` build section** — the
+   recipe is authored there, never duplicated into nano-workforce (a per-repo copy here
+   would rot as the target's build changes).
+2. **Run the prescribed dependency warm-up once**, right after checkout. For a Maven
+   monorepo that ships the fast path (e.g. camunda), that is
+   `./mvnw install -Dquickly -T1C` — it installs every reactor SNAPSHOT into `~/.m2`.
+3. **Then build only the changed module, offline, without `-am`** —
+   `./mvnw -Dquickly -o -pl <module> <goals>`. Never run a cold `-am` reactor build per
+   iteration.
+
+The repo-agnostic infra levers behind this — a host-persisted `~/.m2` and a shared
+remote Maven build cache for JVM-capable worker hosts — live in worker-host config, not
+in per-repo files here. The retro loop (`resources/prompts/retro.md`) promotes any
+durable "warm the cache, then build module-scoped" lesson into the *target repo's*
+`AGENTS.md`, keeping each target's recipe sharp without nano-workforce owning it.
+
 ---
 
 ## 3. Answer escalations (unblock a human-in-the-loop wait)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.171.4",
+  "version": "0.171.5",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",

package/resources/prompts/feature.md

@@ -91,6 +91,28 @@ against the wrong base will not be merged into the epic.
    pointing at an issue).
 5. Clean up any scratch clone/worktree you created outside the commit.
 
+## Build hygiene — warm up once, then build module-scoped; never a cold `-am` reactor build
+
+Before you iterate on a build in the target repo,
+**read its `AGENTS.md` / `CONTRIBUTING.md` build section** and run the prescribed
+**dependency warm-up exactly once** right after checkout, then scope every
+subsequent build to the module you changed. Do **not** run a cold whole-reactor /
+all-modules build on each iteration — a stateless worker that skips the warm-up
+pays the upstream reactor-compile tax inline on every run, which can block for
+many minutes.
+
+- **Warm up once (blocking, right after branching).** For a Maven monorepo that
+  ships this fast path (e.g. camunda), that is
+  `./mvnw install -Dquickly -T1C` — it installs every reactor SNAPSHOT into
+  `~/.m2` so later module builds resolve them instead of recompiling them.
+- **Then build only the changed module, offline, without `-am`.** e.g.
+  `./mvnw -Dquickly -o -pl <module> test-compile`. Dropping `-am` after the
+  warm-up is what keeps each iteration to seconds; a per-iteration
+  `-am <goals>` (e.g. `-am clean test-compile`) re-compiles the upstream modules from source.
+- **The recipe lives in the target repo, not here.** Always defer to that repo's
+  own `AGENTS.md` / `CONTRIBUTING.md` build section for the exact commands — the
+  Maven lines above are the common case, not a substitute for reading it.
+
 ## Closing keywords vs. scope splits — don't close a broader-scoped parent
 
 The convergence loop runs a **scope-integrity classifier** on your PR before it

package/resources/prompts/fix-ci.md

@@ -50,6 +50,14 @@ the PR's checks yourself (`gh pr checks`, `gh run view`).
 3. Apply the **minimal, correct** fix. Keep it scoped to what the failing checks
    demand — do not refactor unrelated code.
 4. Run the relevant check locally to confirm it now passes.
+   **Build module-scoped, not cold.** Before iterating, read the target repo's
+   `AGENTS.md` / `CONTRIBUTING.md` build section and run its prescribed
+   **dependency warm-up once** (for a Maven monorepo that ships it, e.g. camunda,
+   `./mvnw install -Dquickly -T1C`), then scope the build to the changed module
+   and drop `-am` (`./mvnw -Dquickly -o -pl <module> <goals>`). Never run a cold
+   whole-reactor `-am` build per iteration — a stateless worker that skips the
+   warm-up pays the upstream reactor-compile tax inline and can block for many
+   minutes.
 5. Commit (sign off with `-s` if the repo enforces DCO) and push to the branch.
 6. **Make CI re-validate your fix.** Some repos deliberately run CI only when a
    PR is *opened* (to keep review cheap), so a follow-up push does **not**

package/resources/prompts/retro.md

@@ -44,7 +44,11 @@ You have `gh` / git authenticated for the target repository.
 4. **Choose the right home for each promoted lesson** — the whole point is to make the knowledge
    *load-bearing*, not just written down:
    - **`AGENTS.md`** (or `CONTRIBUTING.md`) — a convention, a "before you build, run X", a
-     non-obvious constraint. The default home.
+     non-obvious constraint. The default home. A **build recipe** is the textbook case:
+     a durable "warm the dependency cache once, then build module-scoped — never a cold
+     whole-reactor build" lesson (e.g. Maven's `./mvnw install -Dquickly -T1C` warm-up,
+     then `-pl <module>` without `-am`) belongs in the *target repo's* `AGENTS.md`
+     build section, never duplicated into nano-workforce.
    - **A script** — if the lesson is "always run these steps in this order", encode it as a
      script (or a `make`/`npm`/`deno task` target) so it can't be forgotten.
    - **A CI step** — if the lesson is "this class of mistake should never merge", add a guard/gate