@mmerterden/multi-agent-pipeline 16.1.0 → 16.1.2

package/CHANGELOG.md

@@ -16,6 +16,32 @@ Internal file-layout changes that don't affect the slash-command surface are sti
 
 ## [Unreleased]
 
+## [16.1.2] - 2026-08-23
+
+The rule reached all three hosts in 16.1.1. It only WORKED on one.
+
+### Fixed
+
+- **Rules were installed with a byte copy, so every path in them dangled on two hosts.** Each CLI keeps its trees under its own root, and both installers carry a path-rewrite table that names `rules` explicitly - but `installRules` (Copilot) and `installTree` (Codex) used a plain `copyDir`, so the rewrite never ran on that tree. Result: all 13 rules told a Copilot or Codex session to run `~/.claude/lib/credential-store.sh`, a tree those installs never create. This is the same dangling-path class the Copilot rewrite was written to eliminate for skills; rules were named in the doctrine and left out of the code. It bites hardest on the one rule whose entire job is resolving that path. Both installers route rules through `copyTreeRewritten` now: `~/.copilot/lib/...` on Copilot, `~/.codex/lib/...` on Codex, unchanged on Claude Code. Twelve pre-existing rules were fixed along with the new one.
+- `outside-the-pipeline.md` says what to do when the refs tree is absent. Copilot installs no `multi-agent-refs/` by design - the doctrine routes those references to `~/.claude` when Claude Code shares the machine - so a Copilot-only install was being sent to a file that is not there with no explanation. The rule now states that the summary it carries IS the contract in that case.
+
+### Changed
+
+- `smoke-context-budget.sh` asserts both installers put rules through the rewriter. Verified by reverting the Copilot fix and watching it go red. Shipping a rule to a host is not the same as shipping a rule that works there, and only the second one is worth the bytes it costs every session.
+
+## [16.1.1] - 2026-08-23
+
+Found by reviewing 16.1.0 after it shipped, and by the `/mcp` reconnect confirming the fix worked.
+
+### Fixed
+
+- **Copilot installs a rules tree and never mentions it.** `copilot-instructions.md` names `skills/`, `scripts/` and `agents/` but has zero references to `rules/` - so all 13 files, 31874 bytes, land in `~/.copilot/rules/` with nothing telling the agent they exist. That predates this release; 16.1.0 simply added a fourteenth unread file to the pile. Codex got its pointer in 16.1.0 and Claude Code has always had the CLAUDE.md "Modular Rules" table; Copilot now has one too, naming which rule matches which kind of work.
+- `smoke-context-budget.sh` asserts reachability alongside size. A tree paid for by every session and pointed at by nothing is worse than one that is read: same cost, no return. Verified by removing the pointer and watching the gate go red.
+
+### Verified
+
+- The MCP scope fix works end to end: `/mcp` reports `Reconnected to multi-agent-toolkit` and all 83 tools are present. 16.1.0 could only show the server serving them when run directly.
+
 ## [16.1.0] - 2026-08-23
 
 Installing the pipeline set up three capabilities that only worked inside `/multi-agent`. A plain session had the tokens, the plugins and the MCP server on disk and no way to know it.

package/install/codex.mjs

@@ -493,6 +493,14 @@ function installScripts(pipelineSrc, dest, useSymlinks) {
  * Copy a pipeline tree verbatim (lib / schemas). These are executed, not read
  * as prose, and they resolve their own paths at runtime.
  */
+// Trees whose text references `$HOME/.claude/...` and therefore have to be
+// retargeted on the way in. The rewrite table already carries rules -> .codex
+// rules, but `rules` was installed with a byte copy, so every rule naming
+// `~/.claude/lib/credential-store.sh` pointed at a tree a Codex-only install
+// never creates. `lib` and `schemas` are data the pipeline reads by absolute
+// path from the caller's side, so they stay byte-identical.
+const REWRITTEN_TREES = new Set(["rules"]);
+
 function installTree(name, pipelineSrc, dest, useSymlinks) {
   const src = join(pipelineSrc, name);
   if (!existsSync(src)) return;
@@ -501,6 +509,11 @@ function installTree(name, pipelineSrc, dest, useSymlinks) {
     ensureDir(dest);
   }
   wipeDir(dest);
+  if (!useSymlinks && REWRITTEN_TREES.has(name)) {
+    const n = copyTreeRewritten(src, dest);
+    console.log(`    -> ${n} ${name} file(s) copied to ${dest} (paths retargeted)`);
+    return;
+  }
   copyDir(src, dest, { useSymlinks });
   console.log(`    -> ${countFiles(src)} ${name} file(s) copied to ${dest}`);
 }

package/install/copilot.mjs

@@ -283,8 +283,20 @@ function installRules(pipelineSrc, dest, useSymlinks) {
   if (!existsSync(rulesSrc)) return;
   if (!useSymlinks) ensureRealDir(dest);
   wipeDir(dest);
-  copyDir(rulesSrc, dest, { useSymlinks });
-  console.log(`    -> ${countFiles(rulesSrc)} files copied to ${dest}`);
+  if (useSymlinks) {
+    copyDir(rulesSrc, dest, { useSymlinks });
+    console.log(`    -> ${countFiles(rulesSrc)} files linked to ${dest}`);
+    return;
+  }
+  // Rewritten, not copied. COPILOT_PATH_REWRITES lists `rules` among the trees
+  // Copilot owns, but this function used plain copyDir - so every rule shipped
+  // here naming `~/.claude/lib/credential-store.sh` pointed at a tree a
+  // Copilot-only install never creates. The same dangling-path class the
+  // rewrite was introduced to kill for skills, still live in rules because
+  // rules never went through it. It matters most for the one rule whose whole
+  // job is resolving that path.
+  const n = copyTreeRewritten(rulesSrc, dest);
+  console.log(`    -> ${n} files copied to ${dest} (paths retargeted)`);
 }
 
 function installSkills(opts) {
@@ -379,7 +391,8 @@ function installSkills(opts) {
     let prevDelivered = null;
     try {
       const parsed = JSON.parse(readFileSync(join(dest, EXTERNAL_SKILLS_MANIFEST), "utf-8"));
-      if (Array.isArray(parsed)) prevDelivered = new Set(parsed.filter((n) => typeof n === "string"));
+      if (Array.isArray(parsed))
+        prevDelivered = new Set(parsed.filter((n) => typeof n === "string"));
     } catch {
       prevDelivered = null;
     }
@@ -421,7 +434,9 @@ function installSkills(opts) {
       }
     }
     writeExternalSkillsManifest(dest, keep);
-    console.log(`    -> stack filter (${selectionSource}): ${keep.length} kept, ${skipped.length} skipped`);
+    console.log(
+      `    -> stack filter (${selectionSource}): ${keep.length} kept, ${skipped.length} skipped`,
+    );
     if (keptForeign > 0) {
       console.log(
         `    note: ${keptForeign} skipped-stack dir(s) kept - not delivered by this pipeline (no manifest entry, differs from catalog)`,

package/install/templates/copilot-instructions.md

@@ -237,6 +237,23 @@ Cost block reads `phase-tracker.sh tokens` accumulators × `cost-table.json` pri
 
 ## Rules
 
+The installer lays down a rules tree at `~/.copilot/rules/` that nothing here used
+to point at, so it shipped and went unread. Load the file that matches what you are
+touching: `code-style.md` and `swiftui-qa.md` for Swift, `kotlin-android.md` for
+Kotlin, `tdd.md` and `testing.md` before writing tests, `code-review.md` when
+reviewing, `security.md` for anything handling credentials or user data,
+`git-conventions.md` before committing, `figma-pipeline.md` when a task carries a
+design reference.
+
+**`outside-the-pipeline.md` applies even with no pipeline run in progress**: the
+tokens onboarded by setup, the stack skills enabled for the repo, and the
+multi-agent-toolkit MCP are all usable in an ordinary session. Read freely, route
+writes (Jira comments, issue edits, PRs) through the pipeline commands that carry
+the rules making them safe, and never let a credential value reach argv, a log or a
+reply.
+
+Always, in every mode:
+
 - Never put "Copilot", "AI", "generated by" in code or commits
 - Never commit without passing build
 - Never auto-close issues (use Ref: not Closes:)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-pipeline",
-  "version": "16.1.0",
+  "version": "16.1.2",
   "description": "8-phase AI development pipeline with full orchestration on Claude Code, Copilot CLI and Codex CLI. Analysis, planning, TDD, CLI-aware parallel review with consensus surfacing + Fable triage, default-FAIL evidence gates, secret + intent guards, per-phase cost ledger, persistent learnings memory, wiki generation, commit automation. Token-preserving uninstall.",
   "type": "module",
   "main": "index.js",

package/pipeline/rules/outside-the-pipeline.md

@@ -3,7 +3,8 @@
 `/multi-agent` is not the only way to use what the install set up. Reach for
 these when the work calls for it - not eagerly, and not by starting an 8-phase
 run to read one ticket. Detail, commands and the safety contract:
-`$HOME/.claude/multi-agent-refs/outside-the-pipeline.md`.
+`$HOME/.claude/multi-agent-refs/outside-the-pipeline.md` - absent on a host that
+installs no refs tree, in which case the summary below is the contract.
 
 **Services.** Tokens onboarded by `/multi-agent:setup` are readable now. Logical
 name in `prefs.global.keychainMapping`, value via