@mmerterden/multi-agent-pipeline 16.17.0 → 16.17.1

package/CHANGELOG.md

@@ -16,6 +16,18 @@ Internal file-layout changes that don't affect the slash-command surface are sti
 
 ## [Unreleased]
 
+## [16.17.1] - 2026-08-31
+
+### Fixed
+
+- **The platform-parity cross-check shipped with a trigger nothing could satisfy.** 16.17.0 said the step runs when dev-context recorded a counterpart repo "whose stack resolves to the other mobile platform" - naming an `extras[]` / `readonlySiblings[]` entry and a `stack` field on it. None of the three existed: the picker's return value was never persisted anywhere, `agent-state.schema.json` declared no such array, and no phase wrote one. Phase 4 runs hours after Phase 0 and reads state, so the condition could never be true and the step could never fire. It was a feature that passed every gate and did nothing.
+
+  `state.siblings[]` now exists as the one source: declared in the schema with a closed shape (`name`, `root`, `stack`, `canPush`), written by the dev-context picker at Phase 0, and read by the parity step and nothing else. `stack` is resolved from marker files in the checkout using the table Phase 1 Step 2 already owns, never from the repo name - `my-app-android` is a naming convention, and a wrong stack sends a cross-repo reader at the wrong tree. An entry with no checkout, or an unresolved stack, is skipped rather than guessed at.
+
+  Two limits are now stated instead of discovered: a standalone `/multi-agent:review <PR-URL>` has no state file, so it has no siblings and skips the step - the counterpart repo is a human's choice in the picker, and inferring one from a PR URL would be a cross-repo read nobody authorized; and nothing is ever cloned, because cloning a repository in order to review a different one is a side effect nobody asked for.
+
+  The gate is the actual fix. `smoke-platform-parity.sh` asserted only that the four documents referenced each other, which is why it passed on a trigger that was about nothing. It now checks that the field the trigger reads is declared in the schema with the shape it expects AND written by a phase, that all four documents trigger off that same field, and that the name-based stack shortcut is ruled out in writing. Verified against the 16.17.0 tree: both new checks fail on it.
+
 ## [16.17.0] - 2026-08-31
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-pipeline",
-  "version": "16.17.0",
+  "version": "16.17.1",
   "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/commands/multi-agent/review/SKILL.md

@@ -203,11 +203,15 @@ Catalog-only  -  does NOT invoke binaries. For a full scan, use `/multi-agent:te
 
 ### 4b. Platform parity cross-check (advisory, read-only)
 
-When the run carries a counterpart app repo (dev-context `extras[]` /
-`readonlySiblings[]` whose stack is the other mobile platform) and the diff
-touches a screen, a service, a request model or a localization file, compare the
-change against that repo on four axes: endpoints called, parameters sent,
-business rules around the call, localization keys used.
+When `state.siblings[]` holds a checked-out repo whose `stack` is the other
+mobile platform and the diff touches a screen, a service, a request model or a
+localization file, compare the change against that repo on four axes: endpoints
+called, parameters sent, business rules around the call, localization keys used.
+
+That array is written by the Phase 0 dev-context picker, so a standalone review
+of a PR URL - no pipeline run, no state file - has no siblings and skips this
+step. The counterpart repo is a human's choice in the picker; guessing one from
+a PR URL would be a cross-repo read nobody authorized.
 
 The counterpart is located through the code graph, capped at 8 files, and is
 **read only** - never edited, staged, committed, pushed or built. Output is its

package/pipeline/multi-agent-refs/_dev-context.md

@@ -48,6 +48,26 @@ Selects extra repos the pipeline may touch beyond the primary repo(s)  -  typica
 
 4. **Empty submit**  -  user picks nothing → `extras=[]`, primary repo(s) only.
 
+5. **Persist the result into `state.siblings[]`.** Everything the picker learned
+   about repos this run will NOT modify goes here: every `readonlySiblings[]`
+   entry, plus any selected `extras[]` that is not being given a worktree. The
+   phases that consume them run hours later and have no access to the picker's
+   return value, so a result that is not written here is a result nothing can
+   read - Phase 4's platform-parity cross-check reads `state.siblings[]` and
+   nothing else.
+
+   Resolve each entry's `stack` from its local checkout, with the marker table
+   in `phases/phase-1-analysis.md` Step 2 (`.xcodeproj` / `Package.swift` →
+   `ios`, `build.gradle(.kts)` → `android`, and so on). No checkout, or no
+   marker matched → `stack: "unknown"` and `root: null`. Never infer a stack
+   from the repo NAME: `my-app-android` is a naming convention, not a marker,
+   and a wrong stack sends a cross-repo reader at the wrong tree.
+
+   ```bash
+   printf '{"siblings":%s}' "$SIBLINGS_JSON" \
+     | node $HOME/.claude/scripts/write-state.mjs "$STATE_FILE"
+   ```
+
 ## Web repos  -  `webRepos`
 
 Web repos are rarely submodules of the app repo, so submodule detection never finds them. `prefs.projects[<key>].webRepos[]` (or the pre-rename `frontendRepos[]`) is the primary source for them and is merged into the candidate list alongside the detected submodules. Only `/multi-agent:analysis` used to read this key, which meant the pipeline's own dev-context picker could not offer a web repo at all.

package/pipeline/multi-agent-refs/phases/phase-4-review.md

@@ -127,10 +127,11 @@ Cost ledger: `phase-4.repo_map_emitted bytes=N budget=B cache_hit=true|false`  -
 
 #### Step 1.8  -  Platform parity cross-check (advisory, read-only)
 
-Runs only when dev-context recorded a counterpart app repo (`extras[]` /
-`readonlySiblings[]` on the other mobile platform) AND the diff touches a
-screen, service, request model or localization file. Otherwise skip silently -
-no section, no placeholder.
+Runs only when `state.siblings[]` (written by the Phase 0 dev-context picker)
+holds a checked-out repo whose `stack` is the other mobile platform AND the diff
+touches a screen, service, request model or localization file. Otherwise skip
+silently - no section, no placeholder. No siblings entry means no comparison;
+nothing is cloned and no stack is guessed from a repo name.
 
 Load `$HOME/.claude/multi-agent-refs/platform-parity.md` and follow it. The
 counterpart repo is **read only**, and parity findings are **never blocking**.

package/pipeline/multi-agent-refs/platform-parity.md

@@ -17,15 +17,34 @@ it never blocks, never edits, and its silence is never evidence.
 
 Both conditions, or the step is skipped with no output and no placeholder:
 
-1. The dev-context picker recorded a counterpart app repo - an `extras[]` or
-   `readonlySiblings[]` entry whose stack resolves to the other mobile platform
-   (`android` when the primary is `ios`, `ios` when the primary is `android`).
+1. `state.siblings[]` holds an entry with a non-null `root` whose `stack` is the
+   other mobile platform - `android` when the run's stack is `ios`, `ios` when
+   it is `android`. That array is written by the dev-context picker at Phase 0
+   (`_dev-context.md` step 5) and is the only source consulted. `stack` there is
+   resolved from marker files in the checkout, never from the repo name.
 2. The diff touches something with a counterpart worth checking: a screen, a
    service/repository/use-case, a request model, or a localization file.
 
-A counterpart repo that is not checked out locally is skipped the same way. The
-step never clones one: cloning a repository to review a different one is a
-side effect nobody asked for.
+```bash
+SIB=$(node -e 'try{const s=require(process.argv[1]);const want=process.argv[2];
+const m=(s.siblings||[]).find(x=>x&&x.root&&x.stack===want);
+if(m)process.stdout.write(JSON.stringify({name:m.name,root:m.root,stack:m.stack}))}catch{}' \
+  "$STATE_FILE" "$COUNTERPART_STACK")
+[ -n "$SIB" ] || exit 0   # nothing to compare against; no section, no placeholder
+```
+
+Consequences worth stating rather than discovering:
+
+- **A run with no state file has no siblings, so the step never fires.** A bare
+  `/multi-agent:review <PR-URL>` outside a pipeline run is exactly that case.
+  This is a limit, not a bug: the counterpart repo is something a human chose in
+  the picker, and guessing one from a PR URL would be a cross-repo read nobody
+  authorized.
+- **A sibling with `root: null` is skipped**, and the step never clones one.
+  Cloning a repository in order to review a different one is a side effect
+  nobody asked for.
+- **`stack: "unknown"` is skipped**, because the marker scan found nothing and a
+  guess would send the reader at the wrong tree.
 
 ## Read-only, without exception
 

package/pipeline/schemas/agent-state.schema.json

@@ -104,6 +104,36 @@
       "type": ["string", "null"],
       "description": "Set when a phase halts on a hard error (validator failed twice, no subagent returned, dispatch error past fallback, lock irrecoverable). Format '<phase>:<cause>'. Surfaced to the user and cleared on successful resume. See operations.md 'Halt visibility'."
     },
+    "siblings": {
+      "type": "array",
+      "maxItems": 10,
+      "description": "Repos the dev-context picker offered that this run does not modify: read-only siblings, plus any extra the user selected. Persisted at Phase 0 because the phases that consume them run much later - Phase 4's platform-parity cross-check reads this and nothing else, so a picker result that is not written here is a step that can never fire.",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["name", "root", "stack"],
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "Repo name as the picker showed it."
+          },
+          "root": {
+            "type": ["string", "null"],
+            "description": "Absolute path to the local checkout, or null when the repo is known but not checked out. A null root is skipped by every consumer: nothing clones a repo to review a different one."
+          },
+          "stack": {
+            "type": "string",
+            "enum": ["ios", "android", "node", "python", "go", "unknown"],
+            "description": "Resolved from the checkout's marker files by the same table Phase 1 Step 2 uses (.xcodeproj/Package.swift -> ios, build.gradle(.kts) -> android, ...). 'unknown' when no marker matched or there is no checkout - never guessed from the repo name."
+          },
+          "canPush": {
+            "type": "boolean",
+            "default": false,
+            "description": "Carried from the picker. Informational here: a sibling is read-only to Phase 4 regardless."
+          }
+        }
+      }
+    },
     "rev": {
       "type": "integer",
       "minimum": 0,

package/pipeline/skills/shared/core/multi-agent-review/SKILL.md

@@ -55,11 +55,12 @@ Skip Phase 0-3 and review a diff only. Input shapes: a PR (`#N`, `repo#N`, GitHu
 
    It does NOT invoke any binary/tool  -  the review stage only uses the catalog. For a full scan use `multi-agent-test "store-ready"`.
 
-4b. **Platform parity cross-check** (advisory, read-only)  -  when the run carries a
-   counterpart app repo (dev-context `extras[]` / `readonlySiblings[]` whose stack is
-   the other mobile platform) and the diff touches a screen, a service, a request model
+4b. **Platform parity cross-check** (advisory, read-only)  -  when `state.siblings[]`
+   (written by the Phase 0 dev-context picker) holds a checked-out repo whose `stack` is
+   the other mobile platform and the diff touches a screen, a service, a request model
    or a localization file, compare the change against that repo on four axes: endpoints
    called, parameters sent, business rules around the call, localization keys used.
+   A standalone review with no state file has no siblings and skips the step.
 
    The counterpart is located through the code graph, capped at 8 files, and is **read
    only**  -  never edited, staged, committed, pushed or built. Output is its own